Module: Rails::Generators::Actions

Included in:
Base
Defined in:
railties/lib/rails/generators/actions.rb,
railties/lib/rails/generators/actions/create_migration.rb

Defined Under Namespace

Classes: CreateMigration

Instance Method Summary collapse

Instance Method Details

#add_source(source, options = {}, &block) ⇒ Object

Add the given source to Gemfile

If block is given, gem entries in block are wrapped into the source group.

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

add_source "http://gems.github.com/" do
  gem "rspec-rails"
end

106
107
108
109
110
111
112
113
114
115
116
117
118
# File 'railties/lib/rails/generators/actions.rb', line 106

def add_source(source, options = {}, &block)
  log :source, source

  in_root do
    if block
      append_file_with_newline "Gemfile", "\nsource #{quote(source)} do", force: true
      with_indentation(&block)
      append_file_with_newline "Gemfile", "end", force: true
    else
      prepend_file "Gemfile", "source #{quote(source)}\n", verbose: false
    end
  end
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.asset_host = 'cdn.provider.com'"
end

environment(nil, env: "development") do
  "config.asset_host = 'localhost:3000'"
end

132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
# File 'railties/lib/rails/generators/actions.rb', line 132

def environment(data = nil, options = {})
  sentinel = "class Application < Rails::Application\n"
  env_file_sentinel = "Rails.application.configure do\n"
  data ||= yield if block_given?

  in_root do
    if options[:env].nil?
      inject_into_file "config/application.rb", optimize_indentation(data, 4), after: sentinel, verbose: false
    else
      Array(options[:env]).each do |env|
        inject_into_file "config/environments/#{env}.rb", optimize_indentation(data, 2), after: env_file_sentinel, verbose: false
      end
    end
  end
end

#gem(*args) ⇒ 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: "https://github.com/rails/rails"
gem "RedCloth", ">= 4.1.0", "< 4.2.0"
gem "rspec", comment: "Put this comment above the gem declaration"

22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
# File 'railties/lib/rails/generators/actions.rb', line 22

def gem(*args)
  options = args.extract_options!
  name, *versions = args

  # 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.dup

  # Output a comment above the gem declaration.
  comment = options.delete(:comment)

  if versions = versions.any? ? versions : options.delete(:version)
    _versions = Array(versions)
    _versions.each do |version|
      parts << quote(version)
    end
    message << " (#{_versions.join(", ")})"
  end
  message = options[:git] if options[:git]

  log :gemfile, message

  parts << quote(options) unless options.empty?

  in_root do
    str = []
    if comment
      comment.each_line do |comment_line|
        str << indentation
        str << "# #{comment_line}"
      end
      str << "\n"
    end
    str << indentation
    str << "gem #{parts.join(", ")}"
    append_file_with_newline "Gemfile", str.join, verbose: false
  end
end

#gem_group(*names, &block) ⇒ Object

Wraps gem entries inside a group.

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

66
67
68
69
70
71
72
73
74
75
76
77
78
# File 'railties/lib/rails/generators/actions.rb', line 66

def gem_group(*names, &block)
  options = names.extract_options!
  str = names.map(&:inspect)
  str << quote(options) unless options.empty?
  str = str.join(", ")
  log :gemfile, "group #{str}"

  in_root do
    append_file_with_newline "Gemfile", "\ngroup #{str} do", force: true
    with_indentation(&block)
    append_file_with_newline "Gemfile", "end", 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")

238
239
240
241
242
243
244
245
# File 'railties/lib/rails/generators/actions.rb', line 238

def generate(what, *args)
  log :generate, what

  options = args.extract_options!
  options[:abort_on_failure] = !options[:inline]

  rails_command "generate #{what} #{args.join(" ")}", options
end

#git(commands = {}) ⇒ Object

Run a command in git.

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

154
155
156
157
158
159
160
161
162
# File 'railties/lib/rails/generators/actions.rb', line 154

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

#github(repo, options = {}, &block) ⇒ Object


80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
# File 'railties/lib/rails/generators/actions.rb', line 80

def github(repo, options = {}, &block)
  str = [quote(repo)]
  str << quote(options) unless options.empty?
  str = str.join(", ")
  log :github, "github #{str}"

  in_root do
    if @indentation.zero?
      append_file_with_newline "Gemfile", "\ngithub #{str} do", force: true
    else
      append_file_with_newline "Gemfile", "#{indentation}github #{str} do", force: true
    end
    with_indentation(&block)
    append_file_with_newline "Gemfile", "#{indentation}end", force: true
  end
end

#initializeObject

:nodoc:


10
11
12
13
# File 'railties/lib/rails/generators/actions.rb', line 10

def initialize(*) # :nodoc:
  super
  @indentation = 0
end

#initializer(filename, data = nil) ⇒ Object

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

initializer("globals.rb") do
  data = ""

  ['MY_WORK', 'ADMINS', 'BEST_COMPANY_EVAR'].each do |const|
    data << "#{const} = :entp\n"
  end

  data
end

initializer("api.rb", "API_KEY = '123456'")

227
228
229
230
231
# File 'railties/lib/rails/generators/actions.rb', line 227

def initializer(filename, data = nil)
  log :initializer, filename
  data ||= yield if block_given?
  create_file("config/initializers/#{filename}", optimize_indentation(data), verbose: false)
end

#lib(filename, data = nil) ⇒ 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")

187
188
189
190
191
# File 'railties/lib/rails/generators/actions.rb', line 187

def lib(filename, data = nil)
  log :lib, filename
  data ||= yield if block_given?
  create_file("lib/#{filename}", optimize_indentation(data), verbose: false)
end

#rails_command(command, options = {}) ⇒ Object

Runs the supplied rake task (invoked with 'rails …')

rails_command("db:migrate")
rails_command("db:migrate", env: "production")
rails_command("gems:install", sudo: true)
rails_command("gems:install", capture: true)

263
264
265
266
267
268
269
270
271
272
273
274
275
# File 'railties/lib/rails/generators/actions.rb', line 263

def rails_command(command, options = {})
  if options[:inline]
    log :rails, command
    command, *args = Shellwords.split(command)
    in_root do
      silence_warnings do
        ::Rails::Command.invoke(command, args, **options)
      end
    end
  else
    execute_command :rails, command, options
  end
end

#rake(command, options = {}) ⇒ Object

Runs the supplied rake task (invoked with 'rake …')

rake("db:migrate")
rake("db:migrate", env: "production")
rake("gems:install", sudo: true)
rake("gems:install", capture: true)

253
254
255
# File 'railties/lib/rails/generators/actions.rb', line 253

def rake(command, options = {})
  execute_command :rake, command, options
end

#rakefile(filename, data = nil) ⇒ 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"')

208
209
210
211
212
# File 'railties/lib/rails/generators/actions.rb', line 208

def rakefile(filename, data = nil)
  log :rakefile, filename
  data ||= yield if block_given?
  create_file("lib/tasks/#{filename}", optimize_indentation(data), verbose: false)
end

#readme(path) ⇒ Object

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

readme "README"

314
315
316
# File 'railties/lib/rails/generators/actions.rb', line 314

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

#route(routing_code, namespace: nil) ⇒ Object

Make an entry in Rails routing file config/routes.rb

route "root 'welcome#index'"
route "root 'admin#index'", namespace: :admin

281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
# File 'railties/lib/rails/generators/actions.rb', line 281

def route(routing_code, namespace: nil)
  namespace = Array(namespace)
  namespace_pattern = route_namespace_pattern(namespace)
  routing_code = namespace.reverse.reduce(routing_code) do |code, name|
    "namespace :#{name} do\n#{rebase_indentation(code, 2)}end"
  end

  log :route, routing_code

  in_root do
    if namespace_match = match_file("config/routes.rb", namespace_pattern)
      base_indent, *, existing_block_indent = namespace_match.captures.compact.map(&:length)
      existing_line_pattern = /^[ ]{,#{existing_block_indent}}\S.+\n?/
      routing_code = rebase_indentation(routing_code, base_indent + 2).gsub(existing_line_pattern, "")
      namespace_pattern = /#{Regexp.escape namespace_match.to_s}/
    end

    inject_into_file "config/routes.rb", routing_code, after: namespace_pattern, verbose: false, force: false

    if behavior == :revoke && namespace.any? && namespace_match
      empty_block_pattern = /(#{namespace_pattern})((?:\s*end\n){1,#{namespace.size}})/
      gsub_file "config/routes.rb", empty_block_pattern, verbose: false, force: true do |matched|
        beginning, ending = empty_block_pattern.match(matched).captures
        ending.sub!(/\A\s*end\n/, "") while !ending.empty? && beginning.sub!(/^[ ]*namespace .+ do\n\s*\z/, "")
        beginning + ending
      end
    end
  end
end

#vendor(filename, data = nil) ⇒ Object

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

vendor("sekrit.rb") do
  sekrit_salt = "#{Time.now}--#{3.years.ago}--#{rand}--"
  "salt = '#{sekrit_salt}'"
end

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

173
174
175
176
177
# File 'railties/lib/rails/generators/actions.rb', line 173

def vendor(filename, data = nil)
  log :vendor, filename
  data ||= yield if block_given?
  create_file("vendor/#{filename}", optimize_indentation(data), verbose: false)
end