wycats-thor 0.9.8 → 0.10.26

data/lib/thor/actions/empty_directory.rb

@@ -0,0 +1,30 @@
+require 'thor/actions/templater'
+
+class Thor
+  module Actions
+
+    # Creates an empty directory.
+    #
+    # ==== Parameters
+    # destination<String>:: the relative path to the destination root
+    # log_status<Boolean>:: if false, does not log the status. True by default.
+    #
+    # ==== Examples
+    #
+    #   empty_directory "doc"
+    #
+    def empty_directory(destination, log_status=true)
+      action EmptyDirectory.new(self, nil, destination, log_status)
+    end
+
+    class EmptyDirectory < Templater #:nodoc:
+
+      def invoke!
+        invoke_with_options!(base.options) do
+          ::FileUtils.mkdir_p(destination)
+        end
+      end
+
+    end
+  end
+end

data/lib/thor/actions/get.rb

@@ -0,0 +1,58 @@
+require 'thor/actions/templater'
+require 'open-uri'
+
+class Thor
+  module Actions
+
+    # Gets the content at the given address and places it at the given relative
+    # destination. If a block is given instead of destination, the content of
+    # the url is yielded and used as location.
+    #
+    # ==== Parameters
+    # source<String>:: the address of the given content
+    # destination<String>:: the relative path to the destination root
+    # log_status<Boolean>:: if false, does not log the status. True by default.
+    #
+    # ==== Examples
+    #
+    #   get "http://gist.github.com/103208", "doc/README"
+    #
+    #   get "http://gist.github.com/103208" do |content|
+    #     content.split("\n").first
+    #   end
+    #
+    def get(source, destination=nil, log_status=true, &block)
+      action Get.new(self, source, block || destination, log_status)
+    end
+
+    class Get < Templater #:nodoc:
+
+      def render
+        @render ||= open(source).read
+      end
+
+      protected
+
+        def source=(source)
+          if source =~ /^http\:\/\//
+            @source = source
+          else
+            super(source)
+          end
+        end
+
+        def destination=(destination)
+          destination = if destination.nil?
+            File.basename(source)
+          elsif destination.is_a?(Proc)
+            destination.arity == 1 ? destination.call(render) : destination.call
+          else
+            destination
+          end
+
+          super(destination)
+        end
+
+    end
+  end
+end

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 shell method.
+        #
+        def say_status(status)
+          base.shell.say_status 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,38 @@
+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 removing .tt from the filename.
+    #
+    # ==== 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)
+      destination ||= source.gsub(/.tt$/, '')
+      action Template.new(self, source, destination, 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,195 @@
+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, :given_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 :remove, :red
+        ::FileUtils.rm_rf(destination) if !pretend? && exists?
+      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 absolute source value from a relative source value. Notice
+        # that we need to take into consideration both the source_root as the
+        # relative_root.
+        #
+        # Let's suppose that we are on the directory "dest", with source root set
+        # to "source" and with the following scenario:
+        #
+        #   inside "bar" do
+        #     copy_file "baz.rb"
+        #   end
+        #
+        # In this case, the user wants to copy the file at "source/bar/baz.rb"
+        # to "dest/bar/baz.rb". If we don't take into account the relative_root
+        # (in this case, "bar"), it would copy the contents at "source/baz.rb".
+        #
+        def source=(source)
+          if source
+            @source = ::File.expand_path(source.to_s, File.join(base.source_root, base.relative_root))
+          end
+        end
+
+        # Sets the absolute destination value from a relative destination value.
+        # It also stores the given and relative destination. Let's suppose our
+        # script is being executed on "dest", it sets the destination root to
+        # "dest". The destination, given_destination and relative_destination
+        # are related in the following way:
+        #
+        #   inside "bar" do
+        #     empty_directory "baz"
+        #   end
+        #
+        #   destination          #=> dest/bar/baz
+        #   relative_destination #=> bar/baz
+        #   given_destination    #=> baz
+        #
+        def destination=(destination)
+          if destination
+            @given_destination = convert_encoded_instructions(destination.to_s)
+            @destination = ::File.expand_path(@given_destination, base.destination_root)
+            @relative_destination = base.relative_to_absolute_root(@destination)
+          end
+        end
+
+        # Filenames in the encoded form are converted. If you have a file:
+        #
+        #   %class_name%.rb
+        #
+        # It gets the class name from the base and replace it:
+        #
+        #   user.rb
+        #
+        def convert_encoded_instructions(filename)
+          filename.gsub(/%(.*?)%/) do |string|
+            instruction = $1.strip
+            base.respond_to?(instruction) ? base.send(instruction) : string
+          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
+
+          destination
+        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
+
+    end
+  end
+end

data/lib/thor/actions.rb

@@ -0,0 +1,328 @@
+require 'fileutils'
+
+Dir[File.join(File.dirname(__FILE__), "actions", "*.rb")].each do |action|
+  require action
+end
+
+class Thor
+  # Some actions require that a class method called source root is defined in
+  # the class. Remember to always cache the source root value, because Ruby
+  # __FILE__ always return the relative path, which may lead to mistakes if you
+  # are calling an action inside the "inside(path)" method.
+  #
+  module Actions
+    attr_accessor :behavior
+
+    # On inclusion, add some options to base.
+    #
+    def self.included(base) #:nodoc:
+      return unless base.respond_to?(:class_option)
+
+      base.class_option :pretend, :type => :boolean, :aliases => "-p", :group => :runtime,
+                                  :desc => "Run but do not make any changes"
+
+      base.class_option :force, :type => :boolean, :aliases => "-f", :group => :runtime,
+                                :desc => "Overwrite files that already exist"
+
+      base.class_option :skip, :type => :boolean, :aliases => "-s", :group => :runtime,
+                               :desc => "Skip files that already exist"
+
+      base.class_option :quiet, :type => :boolean, :aliases => "-q", :group => :runtime,
+                                :desc => "Supress status output"
+    end
+
+    # Extends initializer to add more configuration options.
+    #
+    # ==== Configuration
+    # behavior<Symbol>:: The actions default behavior. Can be :invoke or :revoke.
+    #                    It also accepts :force, :skip and :pretend to set the behavior
+    #                    and the respective option.
+    #
+    # root<String>:: The root directory needed for some actions. It's also known
+    #                as destination root.
+    #
+    def initialize(args=[], options={}, config={})
+      self.behavior = case config[:behavior].to_s
+        when "force", "skip"
+          _cleanup_options_and_set(options, config[:behavior])
+          :invoke
+        when "revoke"
+          :revoke
+        else
+          :invoke
+      end
+
+      super
+      self.root = config[:root]
+    end
+
+    # Wraps an action object and call it accordingly to the thor class behavior.
+    #
+    def action(instance)
+      if behavior == :revoke
+        instance.revoke!
+      else
+        instance.invoke!
+      end
+    end
+
+    # Returns the root for this thor class (also aliased as destination root).
+    #
+    def root
+      @root_stack.last
+    end
+    alias :destination_root :root
+
+    # Sets the root for this thor class. Relatives path are added to the
+    # directory where the script was invoked and expanded.
+    #
+    def root=(root)
+      @root_stack ||= []
+      @root_stack[0] = File.expand_path(root || '')
+    end
+
+    # Gets the current root relative to the absolute root.
+    #
+    #   inside "foo" do
+    #     relative_root #=> "foo"
+    #   end
+    #
+    def relative_root(remove_dot=true)
+      relative_to_absolute_root(root, remove_dot)
+    end
+
+    # Returns the given path relative to the absolute root (ie, root where
+    # the script started).
+    #
+    def relative_to_absolute_root(path, remove_dot=true)
+      path = path.gsub(@root_stack[0], '.')
+      remove_dot ? (path[2..-1] || '') : path
+    end
+
+    # Get the source root in the class. Raises an error if a source root is
+    # not specified in the thor class.
+    #
+    def source_root
+      self.class.source_root
+    rescue NoMethodError => e
+      raise NoMethodError, "You have to specify the class method source_root in your thor class."
+    end
+
+    # Do something in the root or on a provided subfolder. If a relative path
+    # is given it's referenced from the current root. The full path is yielded
+    # to the block you provide. The path is set back to the previous path when
+    # the method exits.
+    #
+    # ==== Parameters
+    # dir<String>:: the directory to move to.
+    #
+    def inside(dir='', &block)
+      @root_stack.push File.expand_path(dir, root)
+      FileUtils.mkdir_p(root) unless File.exist?(root)
+      FileUtils.cd(root) { block.arity == 1 ? yield(root) : yield }
+      @root_stack.pop
+    end
+
+    # Goes to the root and execute the given block.
+    #
+    def in_root
+      inside(@root_stack.first) { yield }
+    end
+
+    # Changes the mode of the given file or directory.
+    #
+    # ==== Parameters
+    # mode<Integer>:: the file mode
+    # path<String>:: the name of the file to change mode
+    # log_status<Boolean>:: if false, does not log the status. True by default.
+    #                       If a symbol is given, uses it as the output color.
+    #
+    # ==== Example
+    #
+    #   chmod "script/*", 0755
+    #
+    def chmod(path, mode, log_status=true)
+      return unless behavior == :invoke
+      path = File.expand_path(path, root)
+      say_status :chmod, relative_to_absolute_root(path), log_status
+      FileUtils.chmod_R(mode, path) unless options[:pretend]
+    end
+
+    # Executes a command.
+    #
+    # ==== Parameters
+    # command<String>:: the command to be executed.
+    # log_status<Boolean>:: if false, does not log the status. True by default.
+    #                       If a symbol is given, uses it as the output color.
+    #
+    # ==== Example
+    #
+    #   inside('vendor') do
+    #     run('ln -s ~/edge rails')
+    #   end
+    #
+    def run(command, log_status=true)
+      return unless behavior == :invoke
+      say_status :run, "\"#{command}\" from #{relative_to_absolute_root(root, false)}", log_status
+      `#{command}` unless options[:pretend]
+    end
+
+    # Executes a ruby script (taking into account WIN32 platform quirks).
+    #
+    # ==== Parameters
+    # command<String>:: the command to be executed.
+    # log_status<Boolean>:: if false, does not log the status. True by default.
+    #                       If a symbol is given, uses it as the output color.
+    #
+    def run_ruby_script(command, log_status=true)
+      return unless behavior == :invoke
+      say_status File.basename(Thor::Util.ruby_command), command, log_status
+      `#{Thor::Util.ruby_command} #{command}` unless options[:pretend]
+    end
+
+    # Run a thor command. A hash of options can be given and it's converted to 
+    # switches.
+    #
+    # ==== Parameters
+    # task<String>:: the task to be invoked
+    # args<Array>:: arguments to the task
+    # options<Hash>:: a hash with options used on invocation
+    # 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
+    #
+    #   thor :install, "http://gist.github.com/103208"
+    #   #=> thor install http://gist.github.com/103208
+    #
+    #   thor :list, :all => true, :substring => 'rails'
+    #   #=> thor list --all --substring=rails
+    #
+    def thor(task, *args)
+      log_status = args.last.is_a?(Symbol) || [true, false].include?(args.last) ? args.pop : true
+      options    = args.last.is_a?(Hash) ? args.pop : {}
+
+      args.unshift task
+      args.push Thor::Options.to_switches(options)
+      command = args.join(' ').strip
+
+      say_status :thor, command, log_status
+      run "thor #{command}", false
+    end
+
+    # Removes a file at the given location.
+    #
+    # ==== Parameters
+    # path<String>:: path of the file to be changed
+    # log_status<Boolean>:: if false, does not log the status. True by default.
+    #                       If a symbol is given, uses it as the output color.
+    #
+    # ==== Example
+    #
+    #   remove_file 'README'
+    #   remove_file 'app/controllers/application_controller.rb'
+    #
+    def remove_file(path, log_status=true)
+      return unless behavior == :invoke
+      path  = File.expand_path(path, root)
+      color = log_status.is_a?(Symbol) ? log_status : :red
+
+      say_status :remove, relative_to_absolute_root(path), log_status
+      ::FileUtils.rm_rf(path) if !options[:pretend] && File.exists?(path)
+    end
+
+    # Run a regular expression replacement on a file.
+    #
+    # ==== Parameters
+    # path<String>:: path of the file to be changed
+    # flag<Regexp|String>:: the regexp or string to be replaced
+    # replacement<String>:: the replacement, can be also given as a block
+    # log_status<Boolean>:: if false, does not log the status. True by default.
+    #                       If a symbol is given, uses it as the output color.
+    #
+    # ==== Example
+    #
+    #   gsub_file 'app/controllers/application_controller.rb', /#\s*(filter_parameter_logging :password)/, '\1'
+    #
+    #   gsub_file 'README', /rake/, :green do |match|
+    #     match << " no more. Use thor!"
+    #   end
+    #
+    def gsub_file(path, flag, *args, &block)
+      return unless behavior == :invoke
+      log_status = args.last.is_a?(Symbol) || [ true, false ].include?(args.last) ? args.pop : true
+
+      path = File.expand_path(path, root)
+      say_status :gsub, relative_to_absolute_root(path), log_status
+
+      unless options[:pretend]
+        content = File.read(path)
+        content.gsub!(flag, *args, &block)
+        File.open(path, 'wb') { |file| file.write(content) }
+      end
+    end
+
+    # Append text to a file.
+    #
+    # ==== Parameters
+    # path<String>:: path of the file to be changed
+    # data<String>:: the data to append to the file, can be also given as a block.
+    # log_status<Boolean>:: if false, does not log the status. True by default.
+    #                       If a symbol is given, uses it as the output color.
+    #
+    # ==== Example
+    #
+    #   append_file 'config/environments/test.rb', 'config.gem "rspec"'
+    #
+    def append_file(path, data=nil, log_status=true, &block)
+      return unless behavior == :invoke
+      path = File.expand_path(path, root)
+      say_status :append, relative_to_absolute_root(path), log_status
+      File.open(path, 'ab') { |file| file.write(data || block.call) } unless options[:pretend]
+    end
+
+    # Prepend text to a file.
+    #
+    # ==== Parameters
+    # path<String>:: path of the file to be changed
+    # data<String>:: the data to prepend to the file, can be also given as a block.
+    # log_status<Boolean>:: if false, does not log the status. True by default.
+    #                       If a symbol is given, uses it as the output color.
+    #
+    # ==== Example
+    #
+    #   prepend_file 'config/environments/test.rb', 'config.gem "rspec"'
+    #
+    def prepend_file(path, data=nil, log_status=true, &block)
+      return unless behavior == :invoke
+      path = File.expand_path(path, root)
+      say_status :prepend, relative_to_absolute_root(path), log_status
+
+      unless options[:pretend]
+        content = data || block.call
+        content << File.read(path)
+        File.open(path, 'wb') { |file| file.write(content) }
+      end
+    end
+
+    protected
+
+      # Allow current root to be shared between invocations.
+      #
+      def _shared_configuration #:nodoc:
+        super.merge!(:root => self.root)
+      end
+
+      def _cleanup_options_and_set(options, key) #:nodoc:
+        case options
+          when Array
+            %w(--force -f --skip -s).each { |i| options.delete(i) }
+            options << "--#{key}"
+          when Hash
+            [:force, :skip, "force", "skip"].each { |i| options.delete(i) }
+            options.merge!(key => true)
+        end
+      end
+
+  end
+end