josevalim-thor 0.10.0

data/lib/thor/actions/inject_into_file.rb

@@ -0,0 +1,93 @@
+class Thor
+  module Actions
+
+    # Injects the given content into a file. Different from append_file,
+    # prepend_file and gsub_file, this method is reversible. By this reason,
+    # the flag can only be strings. gsub_file is your friend if you need to
+    # deal with more complex cases.
+    #
+    # ==== Parameters
+    # destination<String>:: Relative path to the destination root
+    # data<String>:: Data to add to the file. Can be given as a block.
+    # flag<String>:: Flag of where to add the changes.
+    # log_status<Boolean>:: If false, does not log the status. True by default.
+    #                       If a symbol is given, uses it as the output color.
+    # 
+    # ==== Examples
+    #
+    #   inject_into_file "config/environment.rb", "config.gem thor", :after => "Rails::Initializer.run do |config|\n"
+    #
+    #   inject_into_file "config/environment.rb", :after => "Rails::Initializer.run do |config|\n" do
+    #     gems = ask "Which gems would you like to add?"
+    #     gems.split(" ").map{ |gem| "  config.gem #{gem}" }.join("\n")
+    #   end
+    #
+    def inject_into_file(destination, *args, &block)
+      if block_given?
+        data, flag = block, args.shift
+      else
+        data, flag = args.shift, args.shift
+      end
+
+      log_status = args.empty? || args.pop
+      action InjectIntoFile.new(self, destination, data, flag, log_status)
+    end
+
+    class InjectIntoFile #:nodoc:
+      attr_reader :base, :destination, :relative_destination, :flag, :replacement
+
+      def initialize(base, destination, data, flag, log_status=true)
+        @base, @log_status = base, log_status
+        behavior, @flag = flag.keys.first, flag.values.first
+
+        self.destination = destination
+        data = data.call if data.is_a?(Proc)
+
+        @replacement = if behavior == :after
+          @flag + data
+        else
+          data + @flag
+        end
+      end
+
+      def invoke!
+        say_status :inject
+        replace!(flag, replacement)
+      end
+
+      def revoke!
+        say_status :deinject
+        replace!(replacement, flag)
+      end
+
+      protected
+
+        # Sets the destination value from a relative destination value. The
+        # relative destination is kept to be used in output messages.
+        #
+        def destination=(destination)
+          if destination
+            @destination = ::File.expand_path(destination.to_s, base.destination_root)
+            @relative_destination = base.relative_to_absolute_root(@destination)
+          end
+        end
+
+        # Shortcut to say_status base method.
+        #
+        def say_status(status)
+          base.send :say_status_if_log, status, relative_destination, @log_status
+        end
+
+        # Adds the content to the file.
+        #
+        def replace!(regexp, string)
+          unless base.options[:pretend]
+            content = File.read(destination)
+            content.gsub!(regexp, string)
+            File.open(destination, 'wb') { |file| file.write(content) }
+          end
+        end
+
+    end
+  end
+end

data/lib/thor/actions/template.rb

@@ -0,0 +1,37 @@
+require 'thor/actions/templater'
+require 'erb'
+
+class Thor
+  module Actions
+
+    # Gets an ERB template at the relative source, executes it and makes a copy
+    # at the relative destination. If the destination is not given it's assumed
+    # to be equal to the source.
+    #
+    # ==== Parameters
+    # source<String>:: the relative path to the source root
+    # destination<String>:: the relative path to the destination root
+    # log_status<Boolean>:: if false, does not log the status. True by default.
+    #
+    # ==== Examples
+    #
+    #   template "README", "doc/README"
+    #
+    #   template "doc/README"
+    #
+    def template(source, destination=nil, log_status=true)
+      action Template.new(self, source, destination || source, log_status)
+    end
+
+    class Template < Templater #:nodoc:
+
+      def render
+        @render ||= begin
+          context = base.instance_eval('binding')
+          ERB.new(::File.read(source), nil, '-').result(context)
+        end
+      end
+
+    end
+  end
+end

data/lib/thor/actions/templater.rb

@@ -0,0 +1,163 @@
+class Thor
+  module Actions
+
+    # This is the base class for templater actions, ie. that copies something
+    # from some directory (source) to another (destination).
+    #
+    # This implementation is completely based in Templater actions, created
+    # by Jonas Nicklas and Michael S. Klishin under MIT LICENSE.
+    #
+    class Templater #:nodoc:
+      attr_reader :base, :source, :destination, :relative_destination
+
+      # Initializes given the source and destination.
+      #
+      # ==== Parameters
+      # base<Thor::Base>:: A Thor::Base instance
+      # source<String>:: Relative path to the source of this file
+      # destination<String>:: Relative path to the destination of this file
+      # log_status<Boolean>:: If false, does not log the status. True by default.
+      #                       Templater log status does not accept color.
+      #
+      def initialize(base, source, destination, log_status=true)
+        @base, @log_status = base, log_status
+        self.source = source
+        self.destination = destination
+      end
+
+      # Returns the contents of the source file as a String. If render is
+      # available, a diff option is shown in the file collision menu.
+      #
+      # ==== Returns
+      # String:: The source file.
+      #
+      # def render
+      # end
+
+      # Checks if the destination file already exists.
+      #
+      # ==== Returns
+      # Boolean:: true if the file exists, false otherwise.
+      #
+      def exists?
+        ::File.exists?(destination)
+      end
+
+      # Checks if the content of the file at the destination is identical to the rendered result.
+      #
+      # ==== Returns
+      # Boolean:: true if it is identical, false otherwise.
+      #
+      def identical?
+        exists? && (is_not_comparable? || ::File.read(destination) == render)
+      end
+
+      # Invokes the action. By default it adds to the file the content rendered,
+      # but you can modify in the subclass.
+      #
+      def invoke!
+        invoke_with_options!(base.options) do
+          ::FileUtils.mkdir_p(::File.dirname(destination))
+          ::File.open(destination, 'w'){ |f| f.write render }
+        end
+      end
+
+      # Revokes the action.
+      #
+      def revoke!
+        say_status :deleted, :green
+        ::FileUtils.rm_rf(destination) unless pretend?
+      end
+
+      protected
+
+        # Shortcut for pretend.
+        #
+        def pretend?
+          base.options[:pretend]
+        end
+
+        # A templater is comparable if responds to render. In such cases, we have
+        # to show the conflict menu to the user unless the files are identical.
+        #
+        def is_not_comparable?
+          !respond_to?(:render)
+        end
+
+        # Sets the source value from a relative source value.
+        #
+        def source=(source)
+          if source
+            @source = ::File.expand_path(source.to_s, base.source_root)
+          end
+        end
+
+        # Sets the destination value from a relative destination value. The
+        # relative destination is kept to be used in output messages.
+        #
+        def destination=(destination)
+          if destination
+            @destination = ::File.expand_path(destination.to_s, base.destination_root)
+            @relative_destination = base.relative_to_absolute_root(@destination)
+          end
+        end
+
+        # Receives a hash of options and just execute the block if some
+        # conditions are met.
+        #
+        def invoke_with_options!(options, &block)
+          if exists?
+            if is_not_comparable?
+              say_status :exist, :blue
+            elsif identical?
+              say_status :identical, :blue
+            else
+              force_or_skip_or_conflict(options[:force], options[:skip], &block)
+            end
+          else
+            say_status :create, :green
+            block.call unless pretend?
+          end
+        end
+
+        # If force is true, run the action, otherwise check if it's not being
+        # skipped. If both are false, show the file_collision menu, if the menu
+        # returns true, force it, otherwise skip.
+        #
+        def force_or_skip_or_conflict(force, skip, &block)
+          if force
+            say_status :force, :yellow
+            block.call unless pretend?
+          elsif skip
+            say_status :skip, :yellow
+          else
+            say_status :conflict, :red
+            force_or_skip_or_conflict(force_on_collision?, true, &block)
+          end
+        end
+
+        # Shows the file collision menu to the user and gets the result.
+        #
+        def force_on_collision?
+          base.shell.file_collision(destination){ render }
+        end
+
+        # Shortcut to say_status shell method.
+        #
+        def say_status(status, color)
+          base.shell.say_status status, relative_destination, color if @log_status
+        end
+
+        # TODO Add this behavior to all actions.
+        #
+        def after_invoke
+          # Optionally change permissions.
+          FileUtils.chmod(base.options[:chmod], destination) if base.options[:chmod]
+
+          # Optionally add file to subversion or git
+          system("git add -v #{relative_destination}") if options[:git]
+        end
+
+    end
+  end
+end

data/lib/thor/base.rb

@@ -0,0 +1,447 @@
+require 'thor/core_ext/hash_with_indifferent_access'
+require 'thor/core_ext/ordered_hash'
+require 'thor/shell/basic'
+require 'thor/error'
+require 'thor/options'
+require 'thor/task'
+require 'thor/util'
+
+class Thor
+  HELP_MAPPINGS = ["-h", "-?", "--help", "-D"]
+
+  class Maxima < Struct.new(:usage, :options, :class_options)
+  end
+
+  module Base
+
+    def self.included(base) #:nodoc:
+      base.send :extend,  ClassMethods
+      base.send :include, SingletonMethods
+    end
+
+    # Returns the classes that inherits from Thor or Thor::Group.
+    #
+    # ==== Returns
+    # Array[Class]
+    #
+    def self.subclasses
+      @subclasses ||= []
+    end
+
+    # Returns the files where the subclasses are kept.
+    #
+    # ==== Returns
+    # Hash[path<String> => Class]
+    #
+    def self.subclass_files
+      @subclass_files ||= Hash.new{ |h,k| h[k] = [] }
+    end
+
+    # Returns the shell used in all Thor classes.
+    #
+    def self.shell
+      @shell || Thor::Shell::Basic
+    end
+
+    # Sets the shell used in all Thor classes.
+    #
+    def self.shell=(klass)
+      @shell = klass
+    end
+
+    # Whenever a class inherits from Thor or Thor::Group, we should track the
+    # class and the file on Thor::Base. This is the method responsable for it.
+    #
+    def self.register_klass_file(klass) #:nodoc:
+      file = caller[1].match(/(.*):\d+/)[1]
+      Thor::Base.subclasses << klass unless Thor::Base.subclasses.include?(klass)
+
+      file_subclasses = Thor::Base.subclass_files[File.expand_path(file)]
+      file_subclasses << klass unless file_subclasses.include?(klass)
+    end
+
+    module ClassMethods
+      # Adds an argument to the class and creates an attr_accessor for it.
+      #
+      # Arguments are different from options in several aspects. The first one
+      # is how they are parsed from the command line, arguments are retrieved
+      # from position:
+      #
+      #   thor task NAME
+      #
+      # Instead of:
+      #
+      #   thor task --name=NAME
+      #
+      # Besides, arguments are used inside your code as an accessor (self.argument),
+      # while options are all kept in a hash (self.options).
+      #
+      # Finally, arguments cannot have type :default or :boolean but can be
+      # optional (supplying :optional => :true or :required => false), although
+      # you cannot have a required argument after a non-required argument. If you
+      # try it, an error is raised.
+      #
+      # ==== Parameters
+      # name<Symbol>:: The name of the argument.
+      # options<Hash>:: The description, type, default value for this argument.
+      #                 The type can be :string, :numeric, :hash or :array. If none, string is assumed.
+      #
+      # ==== Errors
+      # ArgumentError:: Raised if you supply a required argument after a non required one.
+      #
+      def argument(name, options={})
+        no_tasks { attr_accessor name }
+
+        required = if options.key?(:optional)
+          !options[:optional]
+        elsif options.key?(:required)
+          options[:required]
+        else
+          options[:default].nil?
+        end
+
+        class_options.values.each do |option|
+          next unless option.argument? && !option.required?
+          raise ArgumentError, "You cannot have #{name.to_s.inspect} as required argument after " <<
+                               "the non-required argument #{option.human_name.inspect}."
+        end if required
+
+        class_options[name] = Thor::Argument.new(name, options[:desc], required,
+                                                 options[:type], options[:default])
+      end
+
+      # Returns this class arguments, looking up in the ancestors chain.
+      #
+      # ==== Returns
+      # Array[Thor::Argument]
+      #
+      def arguments
+        class_options.values.select{ |o| o.argument? }
+      end
+
+      # Adds a bunch of options to the set of class options.
+      #
+      #   class_options :foo => :optional, :bar => :required, :baz => :string
+      #
+      # If you prefer more detailed declaration, check class_option.
+      #
+      # ==== Parameters
+      # Hash[Symbol => Object]
+      #
+      def class_options(options=nil)
+        @class_options ||= from_superclass(:class_options, Thor::CoreExt::OrderedHash.new)
+        build_options(options, @class_options) if options
+        @class_options
+      end
+
+      # Adds an option to the set of class options
+      #
+      # ==== Parameters
+      # name<Symbol>:: The name of the argument.
+      # options<Hash>:: The description, type, default value, aliases and if this option is required or not.
+      #                 The type can be :string, :boolean, :numeric, :hash or :array. If none is given
+      #                 a default type which accepts both (--name and --name=NAME) entries is assumed.
+      #
+      def class_option(name, options)
+        build_option(name, options, class_options)
+      end
+
+      # Defines the group. This is used when thor list is invoked so you can specify
+      # that only tasks from a pre-defined group will be shown. Defaults to standard.
+      #
+      # ==== Parameters
+      # name<String|Symbol>
+      #
+      def group(name)
+        @group_name = name.to_s
+      end
+
+      # Returns the group name.
+      #
+      # ==== Returns
+      # String
+      #
+      def group_name
+        @group_name ||= from_superclass(:group_name, 'standard')
+      end
+
+      # Returns the tasks for this Thor class.
+      #
+      # ==== Returns
+      # OrderedHash:: An ordered hash with this class tasks.
+      #
+      def tasks
+        @tasks ||= Thor::CoreExt::OrderedHash.new
+      end
+
+      # Returns the tasks for this Thor class and all subclasses.
+      #
+      # ==== Returns
+      # OrderedHash
+      #
+      def all_tasks
+        @all_tasks ||= from_superclass(:all_tasks, Thor::CoreExt::OrderedHash.new)
+        @all_tasks.merge(tasks)
+      end
+
+      # Removes a given task from this Thor class. This is usually done if you
+      # are inheriting from another class and don't want it to be available
+      # anymore.
+      #
+      # By default it only remove the mapping to the task. But you can supply
+      # :undefine => true to undefine the method from the class as well.
+      #
+      # ==== Parameters
+      # name<Symbol|String>:: The name of the task to be removed
+      # options<Hash>:: You can give :undefine => true if you want tasks the method
+      #                 to be undefined from the class as well.
+      #
+      def remove_task(*names)
+        options = names.last.is_a?(Hash) ? names.pop : {}
+
+        names.each do |name|
+          tasks.delete(name.to_s)
+          all_tasks.delete(name.to_s)
+          undef_method name if options[:undefine]
+        end
+      end
+
+      # Retrieve a specific task from this Thor class. If the desired Task cannot
+      # be found, returns a dynamic Thor::Task that will map to the given method.
+      #
+      # ==== Parameters
+      # meth<Symbol>:: the name of the task to be retrieved
+      #
+      # ==== Returns
+      # Task
+      #
+      def [](meth)
+        all_tasks[meth.to_s] || Thor::Task.dynamic(meth)
+      end
+
+      # All methods defined inside the given block are not added as tasks.
+      #
+      # So you can do:
+      #
+      #   class MyScript < Thor
+      #     no_tasks do
+      #       def this_is_not_a_task
+      #       end
+      #     end
+      #   end
+      #
+      # You can also add the method and remove it from the task list:
+      #
+      #   class MyScript < Thor
+      #     def this_is_not_a_task
+      #     end
+      #     remove_task :this_is_not_a_task
+      #   end
+      #
+      def no_tasks
+        @no_tasks = true
+        yield
+        @no_tasks = false
+      end
+
+      # Sets the namespace for the Thor or Thor::Group class. By default the
+      # namespace is retrieved from the class name. If your Thor class is named
+      # Scripts::MyScript, the help method, for example, will be called as:
+      #
+      #   thor scripts:my_script -h
+      #
+      # If you change the namespace:
+      #
+      #   namespace :my_scripts
+      #
+      # You change how your tasks are invoked:
+      #
+      #   thor my_scripts -h
+      #
+      # Finally, if you change your namespace to default:
+      #
+      #   namespace :default
+      #
+      # Your tasks can be invoked with a shortcut. Instead of:
+      #
+      #   thor :my_task
+      #
+      def namespace(name=nil)
+        case name
+          when nil
+            @namespace ||= Thor::Util.constant_to_namespace(self, false)
+          else
+            @namespace = name.to_s
+        end
+      end
+
+      protected
+
+        # Build an option and adds it to the given scope.
+        #
+        # ==== Parameters
+        # name<Symbol>:: The name of the argument.
+        # options<Hash>:: The desc, type, default value and aliases for this option.
+        #                 The type can be :string, :boolean, :numeric, :hash or :array. If none is given
+        #                 a default type which accepts both (--name and --name=NAME) entries is assumed.
+        #
+        def build_option(name, options, scope)
+          scope[name] = Thor::Option.new(name, options[:desc], options[:required],
+                                         options[:type], options[:default], options[:aliases])
+        end
+
+        # Receives a hash of options, parse them and add to the scope. This is a
+        # fast way to set a bunch of options:
+        #
+        #   build_options :foo => :optional, :bar => :required, :baz => :string
+        #
+        # ==== Parameters
+        # Hash[Symbol => Object]
+        #
+        def build_options(options, scope)
+          options.each do |key, value|
+            scope[key] = Thor::Option.parse(key, value)
+          end
+        end
+
+        # Finds a task with the given name. If the task belongs to the current
+        # class, just return it, otherwise dup it and add the fresh copy to the
+        # current task hash.
+        #
+        def find_and_refresh_task(name)
+          task = if task = tasks[name.to_s]
+            task
+          elsif task = all_tasks[name.to_s]
+            tasks[name.to_s] = task.clone
+          else
+            raise ArgumentError, "You supplied :for => #{name.inspect}, but the task #{name.inspect} could not be found."
+          end
+        end
+
+        # Everytime someone inherits from a Thor class, register the klass
+        # and file into baseclass.
+        #
+        def inherited(klass)
+          Thor::Base.register_klass_file(klass)
+        end
+
+        # Fire this callback whenever a method is added. Added methods are
+        # tracked as tasks if the requirements set by valid_task? are valid.
+        #
+        def method_added(meth)
+          meth = meth.to_s
+
+          if meth == "initialize"
+            initialize_added
+            return
+          end
+
+          return if @no_tasks || !valid_task?(meth)
+          Thor::Base.register_klass_file(self)
+          create_task(meth)
+        end
+
+        def from_superclass(method, default=nil)
+          self == baseclass ? default : superclass.send(method).dup
+        end
+
+        # SIGNATURE: Sets the baseclass. This is where the superclass lookup
+        # finishes.
+        def baseclass #:nodoc:
+        end
+
+        # SIGNATURE: Defines if a given method is a valid_task?. This method is
+        # called before a new method is added to the class.
+        def valid_task?(meth) #:nodoc:
+        end
+
+        # SIGNATURE: Creates a new task if valid_task? is true. This method is
+        # called when a new method is added to the class.
+        def create_task(meth) #:nodoc:
+        end
+
+        # SIGNATURE: Defines behavior when the initialize method is added to the
+        # class.
+        def initialize_added #:nodoc:
+        end
+    end
+
+    module SingletonMethods
+      attr_accessor :options
+
+      SHELL_DELEGATED_METHODS = [:ask, :yes?, :no?, :say, :say_status, :print_list, :print_table]
+
+      # It receives arguments in an Array and two hashes, one for options and
+      # other for configuration.
+      #
+      # Notice that it does not check arguments type neither if all required
+      # arguments were supplied. It should be done by the parser.
+      #
+      # ==== Parameters
+      # args<Array[Object]>:: An array of objects. The objects are applied to their
+      #                       respective accessors declared with <tt>argument</tt>.
+      #
+      # options<Hash>:: An options hash that will be available as self.options.
+      #                 The hash given is converted to a hash with indifferent
+      #                 access, magic predicates (options.skip?) and then frozen.
+      #
+      # config<Hash>:: Configuration for this Thor class.
+      #
+      # ==== Configuration
+      # shell<Object>:: An instance of the shell to be used.
+      #
+      # ==== Examples
+      #
+      #   class MyScript < Thor
+      #     argument :first, :type => :numeric
+      #   end
+      #
+      #   MyScript.new [1.0], { :foo => :bar }, :shell => Thor::Shell::Basic.new
+      #
+      def initialize(args=[], options={}, config={})
+        self.class.arguments.zip(args).each do |argument, value|
+          send("#{argument.human_name}=", value)
+        end
+
+        self.options = Thor::CoreExt::HashWithIndifferentAccess.new(options).freeze
+        self.shell   = config[:shell]
+
+        # Add base to shell if an accessor is provided.
+        self.shell.base = self if self.shell.respond_to?(:base)
+      end
+
+      # Common methods that are delegated to the shell.
+      #
+      SHELL_DELEGATED_METHODS.each do |method|
+        module_eval <<-METHOD, __FILE__, __LINE__
+          def #{method}(*args)
+            shell.#{method}(*args)
+          end
+        METHOD
+      end
+
+      # Holds the shell for the given Thor instance. If no shell is given,
+      # it gets a default shell from Thor::Base.shell.
+      #
+      def shell
+        @shell ||= Thor::Base.shell.new
+      end
+
+      # Sets the shell for this thor class.
+      #
+      def shell=(shell)
+        @shell = shell
+      end
+
+      # Finds a task with the name given and invokes it with the given arguments.
+      # This is the default interface to invoke tasks. You can always run a task
+      # directly, but the invocation system will be implemented in a fashion
+      # that a same task cannot be invoked twice (a la rake).
+      #
+      def invoke(name, *args)
+        self.class[name].run(self, *args)
+      end
+    end
+
+  end
+end