module Origen::CodeGenerators::Actions

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.

Public Instance Methods

add_acronyms() click to toggle source
# 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 = {}) click to toggle source

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"]
# 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 = {}) click to toggle source

Adds an entry into config/application.rb

# 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 = {}) click to toggle source

Add the given source to Gemfile

add_source "http://gems.github.com/"
# 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
application(data = nil, options = {})
Alias for: environment
camelcase(name) click to toggle source

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.

# 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 = {}) click to toggle source

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

comment_config :semantically_version
# 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() click to toggle source
# File lib/origen/code_generators/actions.rb, line 20
def config
  @config
end
environment(data = nil, options = {}) { || ... } click to toggle source

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
# 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
Also aliased as: application
gem(name, version, options = {}) click to toggle source

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"
# 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) click to toggle source

Wraps gem entries inside a group.

gem_group :development, :test do
  gem "rspec-rails"
end
# 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) click to toggle source

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")
# 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 = {}) click to toggle source

Run a command in git.

git :init
git add: "this.file that.rb"
git add: "onefile.rb", rm: "badfile.cxx"
# 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
lib(filename, data = nil, &block) click to toggle source

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")
# 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) click to toggle source

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"')
# 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) click to toggle source

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

readme "README"
# File lib/origen/code_generators/actions.rb, line 269
def readme(path)
  log File.read(find_in_source_paths(path))
end
underscored_app_namespace() click to toggle source
# File lib/origen/code_generators/actions.rb, line 24
def underscored_app_namespace
  Origen.app.namespace.to_s.underscore
end

Protected Instance Methods

in_root() { || ... } click to toggle source
# File lib/origen/code_generators/actions.rb, line 449
def in_root
  Dir.chdir(Origen.root) do
    yield
  end
end
log(*args) click to toggle source

Define log for backwards compatibility. If just one argument is sent, invoke say, otherwise invoke say_status. Differently from say and similarly to say_status, this method respects the quiet? option given.

# File lib/origen/code_generators/actions.rb, line 440
def log(*args)
  if args.size == 1
    say args.first.to_s unless options.quiet?
  else
    args << (behavior == :invoke ? :green : :red)
    say_status(*args)
  end
end
quote(value) click to toggle source

Surround string with single quotes if there are no quotes, otherwise fall back to double quotes

# File lib/origen/code_generators/actions.rb, line 457
def quote(value)
  return value.inspect unless value.is_a? String

  if value.include?("'")
    value.inspect
  else
    "'#{value}'"
  end
end