railties 3.0.0.beta

data/lib/rails/generators/actions.rb

@@ -0,0 +1,309 @@
+require 'open-uri'
+require 'active_support/deprecation'
+
+module Rails
+  module Generators
+    module Actions
+
+      # Install a plugin. You must provide either a Subversion url or Git url.
+      #
+      # For a Git-hosted plugin, you can specify a branch and
+      # whether it should be added as a submodule instead of cloned.
+      #
+      # For a Subversion-hosted plugin you can specify a revision.
+      #
+      # ==== Examples
+      #
+      #   plugin 'restful-authentication', :git => 'git://github.com/technoweenie/restful-authentication.git'
+      #   plugin 'restful-authentication', :git => 'git://github.com/technoweenie/restful-authentication.git', :branch => 'stable'
+      #   plugin 'restful-authentication', :git => 'git://github.com/technoweenie/restful-authentication.git', :submodule => true
+      #   plugin 'restful-authentication', :svn => 'svn://svnhub.com/technoweenie/restful-authentication/trunk'
+      #   plugin 'restful-authentication', :svn => 'svn://svnhub.com/technoweenie/restful-authentication/trunk', :revision => 1234
+      #
+      def plugin(name, options)
+        log :plugin, name
+
+        if options[:git] && options[:submodule]
+          options[:git] = "-b #{options[:branch]} #{options[:git]}" if options[:branch]
+          in_root do
+            run "git submodule add #{options[:git]} vendor/plugins/#{name}", :verbose => false
+          end
+        elsif options[:git] || options[:svn]
+          options[:git] = "-b #{options[:branch]} #{options[:git]}"   if options[:branch]
+          options[:svn] = "-r #{options[:revision]} #{options[:svn]}" if options[:revision]
+          in_root do
+            run_ruby_script "script/plugin install #{options[:svn] || options[:git]}", :verbose => false
+          end
+        else
+          log "! no git or svn provided for #{name}. Skipping..."
+        end
+      end
+
+      # Adds an entry into config/environment.rb for the supplied gem. If env
+      # is specified, add the gem to the given environment.
+      #
+      # ==== Example
+      #
+      #   gem "rspec", :env => :test
+      #   gem "technoweenie-restful-authentication", :lib => "restful-authentication", :source => "http://gems.github.com/"
+      #   gem "rails", "3.0", :git => "git://github.com/rails/rails"
+      #
+      def gem(*args)
+        options = args.extract_options!
+        name, version = args
+
+        # Deal with deprecated options
+        { :env => :only, :lib => :require_as }.each do |old, new|
+          next unless options[old]
+          options[new] = options.delete(old)
+          ActiveSupport::Deprecation.warn "#{old.inspect} option in gem is deprecated, use #{new.inspect} instead"
+        end
+
+        # Deal with deprecated source
+        if source = options.delete(:source)
+          ActiveSupport::Deprecation.warn ":source option in gem is deprecated, use add_source method instead"
+          add_source(source)
+        end
+
+        # Set the message to be shown in logs. Uses the git repo if one is given,
+        # otherwise use name (version).
+        parts, message = [ name.inspect ], name
+        if version ||= options.delete(:version)
+          parts   << version
+          message << " (#{version})"
+        end
+        message = options[:git] if options[:git]
+
+        log :gemfile, message
+
+        options.each do |option, value|
+          parts << ":#{option} => #{value.inspect}"
+        end
+
+        in_root do
+          append_file "Gemfile", "gem #{parts.join(", ")}", :verbose => false
+        end
+      end
+
+      # Add the given source to Gemfile
+      #
+      # ==== Example
+      #
+      #   source "http://gems.github.com/"
+      def add_source(source, options={})
+        log :source, source
+
+        in_root do
+          prepend_file "Gemfile", "source #{source.inspect}", :verbose => false
+        end
+      end
+
+      # Adds a line inside the Initializer block for config/environment.rb.
+      #
+      # If options :env is specified, the line is appended to the corresponding
+      # file in config/environments.
+      #
+      def environment(data=nil, options={}, &block)
+        sentinel = /class [a-z_:]+ < Rails::Application/i
+        data = block.call if !data && block_given?
+
+        in_root do
+          if options[:env].nil?
+            inject_into_file 'config/application.rb', "\n  #{data}", :after => sentinel, :verbose => false
+          else
+            Array.wrap(options[:env]).each do|env|
+              append_file "config/environments/#{env}.rb", "\n#{data}", :verbose => false
+            end
+          end
+        end
+      end
+      alias :application :environment
+
+      # Run a command in git.
+      #
+      # ==== Examples
+      #
+      #   git :init
+      #   git :add => "this.file that.rb"
+      #   git :add => "onefile.rb", :rm => "badfile.cxx"
+      #
+      def git(command={})
+        if command.is_a?(Symbol)
+          run "git #{command}"
+        else
+          command.each do |command, options|
+            run "git #{command} #{options}"
+          end
+        end
+      end
+
+      # Create a new file in the vendor/ directory. Code can be specified
+      # in a block or a data string can be given.
+      #
+      # ==== Examples
+      #
+      #   vendor("sekrit.rb") do
+      #     sekrit_salt = "#{Time.now}--#{3.years.ago}--#{rand}--"
+      #     "salt = '#{sekrit_salt}'"
+      #   end
+      #
+      #   vendor("foreign.rb", "# Foreign code is fun")
+      #
+      def vendor(filename, data=nil, &block)
+        log :vendor, filename
+        create_file("vendor/#{filename}", data, :verbose => false, &block)
+      end
+
+      # Create a new file in the lib/ directory. Code can be specified
+      # in a block or a data string can be given.
+      #
+      # ==== Examples
+      #
+      #   lib("crypto.rb") do
+      #     "crypted_special_value = '#{rand}--#{Time.now}--#{rand(1337)}--'"
+      #   end
+      #
+      #   lib("foreign.rb", "# Foreign code is fun")
+      #
+      def lib(filename, data=nil, &block)
+        log :lib, filename
+        create_file("lib/#{filename}", data, :verbose => false, &block)
+      end
+
+      # Create a new Rakefile with the provided code (either in a block or a string).
+      #
+      # ==== Examples
+      #
+      #   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 'im plantin ur seedz'")
+      #
+      def rakefile(filename, data=nil, &block)
+        log :rakefile, filename
+        create_file("lib/tasks/#{filename}", data, :verbose => false, &block)
+      end
+
+      # Create a new initializer with the provided code (either in a block or a string).
+      #
+      # ==== Examples
+      #
+      #   initializer("globals.rb") do
+      #     data = ""
+      #
+      #     ['MY_WORK', 'ADMINS', 'BEST_COMPANY_EVAR'].each do
+      #       data << "#{const} = :entp"
+      #     end
+      #
+      #     data
+      #   end
+      #
+      #   initializer("api.rb", "API_KEY = '123456'")
+      #
+      def initializer(filename, data=nil, &block)
+        log :initializer, filename
+        create_file("config/initializers/#{filename}", data, :verbose => false, &block)
+      end
+
+      # 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.
+      #
+      # ==== Example
+      #
+      #   generate(:authenticated, "user session")
+      #
+      def generate(what, *args)
+        log :generate, what
+        argument = args.map {|arg| arg.to_s }.flatten.join(" ")
+
+        in_root { run_ruby_script("script/generate #{what} #{argument}", :verbose => false) }
+      end
+
+      # Runs the supplied rake task
+      #
+      # ==== Example
+      #
+      #   rake("db:migrate")
+      #   rake("db:migrate", :env => "production")
+      #   rake("gems:install", :sudo => true)
+      #
+      def rake(command, options={})
+        log :rake, command
+        env  = options[:env] || 'development'
+        sudo = options[:sudo] && RUBY_PLATFORM !~ /mswin|mingw/ ? 'sudo ' : ''
+        in_root { run("#{sudo}#{extify(:rake)} #{command} RAILS_ENV=#{env}", :verbose => false) }
+      end
+
+      # Just run the capify command in root
+      #
+      # ==== Example
+      #
+      #   capify!
+      #
+      def capify!
+        log :capify, ""
+        in_root { run("#{extify(:capify)} .", :verbose => false) }
+      end
+
+      # Add Rails to /vendor/rails
+      #
+      # ==== Example
+      #
+      #   freeze!
+      #
+      def freeze!(args={})
+        ActiveSupport::Deprecation.warn "freeze! is deprecated since your rails app now comes bundled with Rails by default, please check your Gemfile"
+      end
+
+      # Make an entry in Rails routing file conifg/routes.rb
+      #
+      # === Example
+      #
+      #   route "root :to => 'welcome'"
+      #
+      def route(routing_code)
+        log :route, routing_code
+        sentinel = "routes.draw do |map|"
+
+        in_root do
+          inject_into_file 'config/routes.rb', "\n  #{routing_code}\n", { :after => sentinel, :verbose => false }
+        end
+      end
+
+      protected
+
+        # Define log for backwards compatibility. If just one argument is sent,
+        # invoke say, otherwise invoke say_status.
+        #
+        def log(*args)
+          if args.size == 1
+            say args.first.to_s
+          else
+            args << (self.behavior == :invoke ? :green : :red)
+            say_status *args
+          end
+        end
+
+        # Add an extension to the given name based on the platform.
+        #
+        def extify(name)
+          if RUBY_PLATFORM =~ /mswin|mingw/
+            "#{name}.bat"
+          else
+            name
+          end
+        end
+
+    end
+  end
+end

data/lib/rails/generators/active_model.rb

@@ -0,0 +1,78 @@
+module Rails
+  module Generators
+    # ActiveModel is a class to be implemented by each ORM to allow Rails to
+    # generate customized controller code.
+    #
+    # The API has the same methods as ActiveRecord, but each method returns a
+    # string that matches the ORM API.
+    #
+    # For example:
+    #
+    #   ActiveRecord::Generators::ActiveModel.find(Foo, "params[:id]")
+    #   #=> "Foo.find(params[:id])"
+    #
+    #   Datamapper::Generators::ActiveModel.find(Foo, "params[:id]")
+    #   #=> "Foo.get(params[:id])"
+    #
+    # On initialization, the ActiveModel accepts the instance name that will
+    # receive the calls:
+    #
+    #   builder = ActiveRecord::Generators::ActiveModel.new "@foo"
+    #   builder.save #=> "@foo.save"
+    #
+    # The only exception in ActiveModel for ActiveRecord is the use of self.build
+    # instead of self.new.
+    #
+    class ActiveModel
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+
+      # GET index
+      def self.all(klass)
+        "#{klass}.all"
+      end
+
+      # GET show
+      # GET edit
+      # PUT update
+      # DELETE destroy
+      def self.find(klass, params=nil)
+        "#{klass}.find(#{params})"
+      end
+
+      # GET new
+      # POST create
+      def self.build(klass, params=nil)
+        if params
+          "#{klass}.new(#{params})"
+        else
+          "#{klass}.new"
+        end
+      end
+
+      # POST create
+      def save
+        "#{name}.save"
+      end
+
+      # PUT update
+      def update_attributes(params=nil)
+        "#{name}.update_attributes(#{params})"
+      end
+
+      # POST create
+      # PUT update
+      def errors
+        "#{name}.errors"
+      end
+
+      # DELETE destroy
+      def destroy
+        "#{name}.destroy"
+      end
+    end
+  end
+end

data/lib/rails/generators/base.rb

@@ -0,0 +1,362 @@
+require 'thor/group'
+require 'rails/generators/actions'
+
+module Rails
+  module Generators
+    class Error < Thor::Error
+    end
+
+    class Base < Thor::Group
+      include Thor::Actions
+      include Rails::Generators::Actions
+
+      add_runtime_options!
+
+      # Automatically sets the source root based on the class name.
+      #
+      def self.source_root
+        @_rails_source_root ||= begin
+          if base_name && generator_name
+            File.expand_path(File.join("../../generators", base_name, generator_name, 'templates'), File.dirname(__FILE__))
+          end
+        end
+      end
+
+      # Tries to get the description from a USAGE file one folder above the source
+      # root otherwise uses a default description.
+      #
+      def self.desc(description=nil)
+        return super if description
+        usage = File.expand_path(File.join(source_root, "..", "USAGE"))
+
+        @desc ||= if File.exist?(usage)
+          File.read(usage)
+        else
+          "Description:\n    Create #{base_name.humanize.downcase} files for #{generator_name} generator."
+        end
+      end
+
+      # Convenience method to get the namespace from the class name. It's the
+      # same as Thor default except that the Generator at the end of the class
+      # is removed.
+      #
+      def self.namespace(name=nil)
+        return super if name
+        @namespace ||= super.sub(/_generator$/, '').sub(/:generators:/, ':')
+      end
+
+      # Invoke a generator based on the value supplied by the user to the
+      # given option named "name". A class option is created when this method
+      # is invoked and you can set a hash to customize it.
+      #
+      # ==== Examples
+      #
+      #   module Rails::Generators
+      #     class ControllerGenerator < Base
+      #       hook_for :test_framework, :aliases => "-t"
+      #     end
+      #   end
+      #
+      # The example above will create a test framework option and will invoke
+      # a generator based on the user supplied value.
+      #
+      # For example, if the user invoke the controller generator as:
+      #
+      #   ruby script/generate controller Account --test-framework=test_unit
+      #
+      # The controller generator will then try to invoke the following generators:
+      #
+      #   "rails:test_unit", "test_unit:controller", "test_unit"
+      #
+      # Notice that "rails:generators:test_unit" could be loaded as well, what
+      # Rails looks for is the first and last parts of the namespace. This is what
+      # allows any test framework to hook into Rails as long as it provides any
+      # of the hooks above.
+      #
+      # ==== Options
+      #
+      # The first and last part used to find the generator to be invoked are
+      # guessed based on class invokes hook_for, as noticed in the example above.
+      # This can be customized with two options: :base and :as.
+      #
+      # Let's suppose you are creating a generator that needs to invoke the 
+      # controller generator from test unit. Your first attempt is:
+      #
+      #   class AwesomeGenerator < Rails::Generators::Base
+      #     hook_for :test_framework
+      #   end
+      #
+      # The lookup in this case for test_unit as input is:
+      #
+      #   "test_unit:awesome", "test_unit"
+      #
+      # Which is not the desired the lookup. You can change it by providing the
+      # :as option:
+      #
+      #   class AwesomeGenerator < Rails::Generators::Base
+      #     hook_for :test_framework, :as => :controller
+      #   end
+      #
+      # And now it will lookup at:
+      #
+      #   "test_unit:controller", "test_unit"
+      #
+      # Similarly, if you want it to also lookup in the rails namespace, you just
+      # need to provide the :base value:
+      #
+      #   class AwesomeGenerator < Rails::Generators::Base
+      #     hook_for :test_framework, :in => :rails, :as => :controller
+      #   end
+      #
+      # And the lookup is exactly the same as previously:
+      #
+      #   "rails:test_unit", "test_unit:controller", "test_unit"
+      #
+      # ==== Switches
+      #
+      # All hooks come with switches for user interface. If the user don't want
+      # to use any test framework, he can do:
+      #
+      #   ruby script/generate controller Account --skip-test-framework
+      #
+      # Or similarly:
+      #
+      #   ruby script/generate controller Account --no-test-framework
+      #
+      # ==== Boolean hooks
+      #
+      # In some cases, you want to provide a boolean hook. For example, webrat
+      # developers might want to have webrat available on controller generator.
+      # This can be achieved as:
+      #
+      #   Rails::Generators::ControllerGenerator.hook_for :webrat, :type => :boolean
+      #
+      # Then, if you want, webrat to be invoked, just supply:
+      #
+      #   ruby script/generate controller Account --webrat
+      #
+      # The hooks lookup is similar as above:
+      #
+      #   "rails:generators:webrat", "webrat:generators:controller", "webrat"
+      #
+      # ==== Custom invocations
+      #
+      # You can also supply a block to hook_for to customize how the hook is
+      # going to be invoked. The block receives two arguments, an instance
+      # of the current class and the klass to be invoked.
+      #
+      # For example, in the resource generator, the controller should be invoked
+      # with a pluralized class name. But by default it is invoked with the same
+      # name as the resource generator, which is singular. To change this, we
+      # can give a block to customize how the controller can be invoked.
+      #
+      #   hook_for :resource_controller do |instance, controller|
+      #     instance.invoke controller, [ instance.name.pluralize ]
+      #   end
+      #
+      def self.hook_for(*names, &block)
+        options = names.extract_options!
+        in_base = options.delete(:in) || base_name
+        as_hook = options.delete(:as) || generator_name
+
+        names.each do |name|
+          defaults = if options[:type] == :boolean
+            { }
+          elsif [true, false].include?(default_value_for_option(name, options))
+            { :banner => "" }
+          else
+            { :desc => "#{name.to_s.humanize} to be invoked", :banner => "NAME" }
+          end
+
+          unless class_options.key?(name)
+            class_option(name, defaults.merge!(options))
+          end
+
+          hooks[name] = [ in_base, as_hook ]
+          invoke_from_option(name, options, &block)
+        end
+      end
+
+      # Remove a previously added hook.
+      #
+      # ==== Examples
+      #
+      #   remove_hook_for :orm
+      #
+      def self.remove_hook_for(*names)
+        remove_invocation(*names)
+
+        names.each do |name|
+          hooks.delete(name)
+        end
+      end
+
+      # Make class option aware of Rails::Generators.options and Rails::Generators.aliases.
+      #
+      def self.class_option(name, options={}) #:nodoc:
+        options[:desc]    = "Indicates when to generate #{name.to_s.humanize.downcase}" unless options.key?(:desc)
+        options[:aliases] = default_aliases_for_option(name, options)
+        options[:default] = default_value_for_option(name, options)
+        super(name, options)
+      end
+
+      # Cache source root and add lib/generators/base/generator/templates to
+      # source paths.
+      #
+      def self.inherited(base) #:nodoc:
+        super
+
+        # Cache source root, we need to do this, since __FILE__ is a relative value
+        # and can point to wrong directions when inside an specified directory.
+        base.source_root
+
+        if base.name && base.name !~ /Base$/
+          Rails::Generators.subclasses << base
+
+          if defined?(Rails.root) && Rails.root
+            path = File.expand_path(File.join(Rails.root, 'lib', 'templates'))
+            if base.name.include?('::')
+              base.source_paths << File.join(path, base.base_name, base.generator_name)
+            else
+              base.source_paths << File.join(path, base.generator_name)
+            end
+          end
+        end
+      end
+
+      protected
+
+        # Check whether the given class names are already taken by user
+        # application or Ruby on Rails.
+        #
+        def class_collisions(*class_names) #:nodoc:
+          return unless behavior == :invoke
+
+          class_names.flatten.each do |class_name|
+            class_name = class_name.to_s
+            next if class_name.strip.empty?
+
+            # Split the class from its module nesting
+            nesting = class_name.split('::')
+            last_name = nesting.pop
+
+            # Hack to limit const_defined? to non-inherited on 1.9
+            extra = []
+            extra << false unless Object.method(:const_defined?).arity == 1
+
+            # Extract the last Module in the nesting
+            last = nesting.inject(Object) do |last, nest|
+              break unless last.const_defined?(nest, *extra)
+              last.const_get(nest)
+            end
+
+            if last && last.const_defined?(last_name.camelize, *extra)
+              raise Error, "The name '#{class_name}' is either already used in your application " <<
+                           "or reserved by Ruby on Rails. Please choose an alternative and run "  <<
+                           "this generator again."
+            end
+          end
+        end
+
+        # Use Rails default banner.
+        #
+        def self.banner
+          "rails generate #{generator_name} #{self.arguments.map{ |a| a.usage }.join(' ')} [options]"
+        end
+
+        # Sets the base_name taking into account the current class namespace.
+        #
+        def self.base_name
+          @base_name ||= begin
+            if base = name.to_s.split('::').first
+              base.underscore
+            end
+          end
+        end
+
+        # Removes the namespaces and get the generator name. For example,
+        # Rails::Generators::MetalGenerator will return "metal" as generator name.
+        #
+        def self.generator_name
+          @generator_name ||= begin
+            if generator = name.to_s.split('::').last
+              generator.sub!(/Generator$/, '')
+              generator.underscore
+            end
+          end
+        end
+
+        # Return the default value for the option name given doing a lookup in
+        # Rails::Generators.options.
+        #
+        def self.default_value_for_option(name, options)
+          default_for_option(Rails::Generators.options, name, options, options[:default])
+        end
+
+        # Return default aliases for the option name given doing a lookup in
+        # Rails::Generators.aliases.
+        #
+        def self.default_aliases_for_option(name, options)
+          default_for_option(Rails::Generators.aliases, name, options, options[:aliases])
+        end
+
+        # Return default for the option name given doing a lookup in config.
+        #
+        def self.default_for_option(config, name, options, default)
+          if generator_name and c = config[generator_name.to_sym] and c.key?(name)
+            c[name]
+          elsif base_name and c = config[base_name.to_sym] and c.key?(name)
+            c[name]
+          elsif config[:rails].key?(name)
+            config[:rails][name]
+          else
+            default
+          end
+        end
+
+        # Keep hooks configuration that are used on prepare_for_invocation.
+        #
+        def self.hooks #:nodoc:
+          @hooks ||= from_superclass(:hooks, {})
+        end
+
+        # Prepare class invocation to search on Rails namespace if a previous
+        # added hook is being used.
+        #
+        def self.prepare_for_invocation(name, value) #:nodoc:
+          return super unless value.is_a?(String) || value.is_a?(Symbol)
+
+          if value && constants = self.hooks[name]
+            value = name if TrueClass === value
+            Rails::Generators.find_by_namespace(value, *constants)
+          elsif klass = Rails::Generators.find_by_namespace(value)
+            klass
+          else
+            super
+          end
+        end
+
+        # Small macro to add ruby as an option to the generator with proper
+        # default value plus an instance helper method called shebang.
+        #
+        def self.add_shebang_option!
+          class_option :ruby, :type => :string, :aliases => "-r", :default => Thor::Util.ruby_command,
+                              :desc => "Path to the Ruby binary of your choice", :banner => "PATH"
+
+          no_tasks {
+            define_method :shebang do
+              @shebang ||= begin
+                command = if options[:ruby] == Thor::Util.ruby_command
+                  "/usr/bin/env #{File.basename(Thor::Util.ruby_command)}"
+                else
+                  options[:ruby]
+                end
+                "#!#{command}"
+              end
+            end
+          }
+        end
+
+    end
+  end
+end