Module: Origen::CodeGenerators::Actions

Includes:
Helpers
Included in:
Base
Defined in:
lib/origen/code_generators/actions.rb

Overview

Common helpers available to all Origen code generators. Some of these have been copied from Rails and don't make a lot of sense in an Origen context, however they are being kept around for now as they serve as good examples of how to write generator helpers.

Defined Under Namespace

Modules: Helpers

Instance Method Summary collapse

Methods included from Helpers

#add_type_to_namespaces, #class_name_to_blocks_dir, #class_name_to_lib_file, #internal_depth, #resource_path, #resource_path_to_blocks_dir, #resource_path_to_class, #resource_path_to_lib_file, #unless_has_method, #unless_valid_underscored_identifier, #validate_resource_path

Instance Method Details

#add_acronyms ⇒ Object 



43
44
45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/origen/code_generators/actions.rb', line 43

def add_acronyms
  unless @required_acronyms.empty?
    top_level_file = File.join('app', 'lib', "#{underscored_app_namespace}.rb")
    if File.exist?(top_level_file)
      require_origen = "require 'origen'\n"
      prepend_to_file top_level_file, require_origen
      comment = "# The following acronyms are required to ensure that auto-loading works\n# properly with some of this application's class names\n"
      insert_into_file top_level_file, comment, after: require_origen
      @required_acronyms.each do |acronym|
        insert_into_file top_level_file, "Origen.register_acronym '#{acronym}'\n", after: comment
      end
    end
  end
end

#add_autoload(name, options = {}) ⇒ Object

Adds an autoload statement for the given resource name into app/lib/my_app_name.rb

An array of namespaces can optionally be supplied in the arguments. The name and namespaces should all be lower cased and underscored.

add_autoload "my_model", namespaces: ["my_namespace", "my_other_namespace"]



64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/origen/code_generators/actions.rb', line 64

def add_autoload(name, options = {})
  namespaces = Array(options[:namespaces])
  # Remove the app namespace if present, we will add the autoload inside the top-level module block
  namespaces.shift if namespaces.first == app_namespace
  top_level_file = File.join('app', 'lib', "#{underscored_app_namespace}.rb")
  if namespaces.empty?
    line = "  autoload :#{camelcase(name)}, '#{underscored_app_namespace}/#{name}'\n"
    insert_into_file top_level_file, line, after: /module #{Origen.app.namespace}\n/
  else
    contents = File.read(top_level_file)
    regex = "module #{Origen.app.namespace}\s*(#.*)?\n"
    indent = ''
    namespaces.each do |namespace|
      indent += '  '
      new_regex = regex + "(\n|.)*^\s*module #{camelcase(namespace)}\s*(#.*)?\n"
      unless contents =~ Regexp.new(new_regex)
        lines = "#{indent}module #{camelcase(namespace)}\n"
        lines << "#{indent}end\n"
        insert_into_file top_level_file, lines, after: Regexp.new(regex), force: true
      end
      regex = new_regex
    end
    line = "#{indent}  autoload :#{camelcase(name)}, '#{underscored_app_namespace}/#{namespaces.join('/')}/#{name}'\n"
    insert_into_file top_level_file, line, after: Regexp.new(regex)
  end
end

#add_config(name, value, options = {}) ⇒ Object

Adds an entry into config/application.rb



103
104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/origen/code_generators/actions.rb', line 103

def add_config(name, value, options = {})
  # Set the message to be shown in logs
  message = name.to_s
  if value ||= options.delete(:value)
    message << " (#{value})"
  end
  log :insert, message

  file = File.join(Origen.root, 'config', 'application.rb')
  value = quote(value) if value.is_a?(String)
  value = ":#{value}" if value.is_a?(Symbol)
  insert_into_file file, "  config.#{name} = #{value}\n\n", after: /^\s*class.*\n/
end

#add_source(source, _options = {}) ⇒ Object

Add the given source to Gemfile

add_source "http://gems.github.com/"



169
170
171
172
173
174
175
 
# File 'lib/origen/code_generators/actions.rb', line 169

def add_source(source, _options = {})
  log :source, source

  in_root do
    prepend_file 'Gemfile', "source #{quote(source)}\n", verbose: false
  end
end

#camelcase(name) ⇒ Object

Equivalent to calling name.camelcase, but this will identify the need to register any acronyms necessary to ensure the camelcased name can be translated back to the original name by the underscore method. The required acronyms will be saved to an instance variable, @required_acronyms, and calling the add_acronyms will add the code to register them to the current application.



33
34
35
36
37
38
39
40
41
 
# File 'lib/origen/code_generators/actions.rb', line 33

def camelcase(name)
  name = name.to_s
  name.split('_').each do |n|
    # Numbers won't be recognized as a split point when going back to underscore, so need to
    # register this field beginning with a number as an acronym
    @required_acronyms << n if n =~ /^\d/
  end
  name.camelcase
end

#comment_config(name, options = {}) ⇒ Object

Removes (comments out) the specified configuration setting from config/application.rb

comment_config :semantically_version



94
95
96
97
98
99
100
 
# File 'lib/origen/code_generators/actions.rb', line 94

def comment_config(name, options = {})
  # Set the message to be shown in logs
  log :comment, name

  file = File.join(Origen.root, 'config', 'application.rb')
  comment_lines(file, /^\s*config.#{name}\s*=.*\n/)
end

#config ⇒ Object 



20
21
22
 
# File 'lib/origen/code_generators/actions.rb', line 20

def config
  @config
end

#environment(data = nil, options = {}) ⇒ Object Also known as: application

Adds a line inside the Application class for config/application.rb.

If options :env is specified, the line is appended to the corresponding file in config/environments.

environment do
  "config.autoload_paths += %W(#{config.root}/extras)"
end

environment(nil, env: "development") do
  "config.autoload_paths += %W(#{config.root}/extras)"
end



189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
 
# File 'lib/origen/code_generators/actions.rb', line 189

def environment(data = nil, options = {})
  sentinel = /class [a-z_:]+ < Rails::Application/i
  env_file_sentinel = /Rails\.application\.configure do/
  data = yield if !data && block_given?

  in_root do
    if options[:env].nil?.map(&:camelcase).join('::')
      inject_into_file 'config/application.rb', "\n    #{data}", after: sentinel, verbose: false
    else
      Array(options[:env]).each do |env|
        inject_into_file "config/environments/#{env}.rb", "\n  #{data}", after: env_file_sentinel, verbose: false
      end
    end
  end
end

#gem(name, version, options = {}) ⇒ Object

Adds an entry into Gemfile for the supplied gem.

gem "rspec", group: :test
gem "technoweenie-restful-authentication", lib: "restful-authentication", source: "http://gems.github.com/"
gem "rails", "3.0", git: "git://github.com/rails/rails"



122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
 
# File 'lib/origen/code_generators/actions.rb', line 122

def gem(name, version, options = {})
  # Set the message to be shown in logs. Uses the git repo if one is given,
  # otherwise use name (version).
  parts, message = [quote(name)], name
  if version ||= options.delete(:version)
    parts << quote(version)
    message << " (#{version})"
  end
  message = options[:git] if options[:git]

  log :gemfile, message

  options.each do |option, value|
    parts << "#{option}: #{quote(value)}"
  end

  in_root do
    str = "gem #{parts.join(', ')}"
    str = '  ' + str if @in_group
    str = "\n" + str
    append_file 'Gemfile', str, verbose: false
  end
end

#gem_group(*names, &block) ⇒ Object

Wraps gem entries inside a group.

gem_group :development, :test do
  gem "rspec-rails"
end



151
152
153
154
155
156
157
158
159
160
161
162
163
164
 
# File 'lib/origen/code_generators/actions.rb', line 151

def gem_group(*names, &block)
  name = names.map(&:inspect).join(', ')
  log :gemfile, "group #{name}"

  in_root do
    append_file 'Gemfile', "\ngroup #{name} do", force: true

    @in_group = true
    instance_eval(&block)
    @in_group = false

    append_file 'Gemfile', "\nend\n", force: true
  end
end

#generate(what, *args) ⇒ Object

Generate something using a generator from Rails or a plugin. The second parameter is the argument string that is passed to the generator or an Array that is joined.

generate(:authenticated, "user session")



259
260
261
262
263
264
 
# File 'lib/origen/code_generators/actions.rb', line 259

def generate(what, *args)
  log :generate, what
  argument = args.flat_map(&:to_s).join(' ')

  in_root { run_ruby_script("bin/rails generate #{what} #{argument}", verbose: false) }
end

#git(commands = {}) ⇒ Object

Run a command in git.

git :init
git add: "this.file that.rb"
git add: "onefile.rb", rm: "badfile.cxx"



211
212
213
214
215
216
217
218
219
 
# File 'lib/origen/code_generators/actions.rb', line 211

def git(commands = {})
  if commands.is_a?(Symbol)
    run "git #{commands}"
  else
    commands.each do |cmd, options|
      run "git #{cmd} #{options}"
    end
  end
end

#initialize(*args) ⇒ Object

:nodoc:



11
12
13
14
15
16
17
18
 
# File 'lib/origen/code_generators/actions.rb', line 11

def initialize(*args) # :nodoc:
  if args.last.is_a?(Hash)
    @config = args.last.delete(:config) || {}
  end
  @required_acronyms = Set.new
  super
  @in_group = nil
end

#lib(filename, data = nil, &block) ⇒ Object

Create a new file in the lib/ directory. Code can be specified in a block or a data string can be given.

lib("crypto.rb") do
  "crypted_special_value = '#{rand}--#{Time.now}--#{rand(1337)}--'"
end

lib("foreign.rb", "# Foreign code is fun")



229
230
231
232
 
# File 'lib/origen/code_generators/actions.rb', line 229

def lib(filename, data = nil, &block)
  log :lib, filename
  create_file("lib/#{filename}", data, verbose: false, &block)
end

#rakefile(filename, data = nil, &block) ⇒ Object

Create a new Rakefile with the provided code (either in a block or a string).

rakefile("bootstrap.rake") do
  project = ask("What is the UNIX name of your project?")

  <<-TASK
    namespace :#{project} do
      task :bootstrap do
        puts "I like boots!"
      end
    end
  TASK
end

rakefile('seed.rake', 'puts "Planting seeds"')



249
250
251
252
 
# File 'lib/origen/code_generators/actions.rb', line 249

def rakefile(filename, data = nil, &block)
  log :rakefile, filename
  create_file("lib/tasks/#{filename}", data, verbose: false, &block)
end

#readme(path) ⇒ Object

Reads the given file at the source root and prints it in the console.

readme "README"



269
270
271
 
# File 'lib/origen/code_generators/actions.rb', line 269

def readme(path)
  log File.read(find_in_source_paths(path))
end

#underscored_app_namespace ⇒ Object 



24
25
26
 
# File 'lib/origen/code_generators/actions.rb', line 24

def underscored_app_namespace
  Origen.app.namespace.to_s.underscore
end