millisami-thor 0.14.6

data/lib/thor.rb

@@ -0,0 +1,336 @@
+require 'thor/base'
+
+class Thor
+  class << self
+    # Sets the default task when thor is executed without an explicit task to be called.
+    #
+    # ==== Parameters
+    # meth<Symbol>:: name of the defaut task
+    #
+    def default_task(meth=nil)
+      case meth
+        when :none
+          @default_task = 'help'
+        when nil
+          @default_task ||= from_superclass(:default_task, 'help')
+        else
+          @default_task = meth.to_s
+      end
+    end
+
+    # Registers another Thor subclass as a command.
+    #
+    # ==== Parameters
+    # klass<Class>:: Thor subclass to register
+    # command<String>:: Subcommand name to use
+    # usage<String>:: Short usage for the subcommand
+    # description<String>:: Description for the subcommand
+    def register(klass, subcommand_name, usage, description, options={})
+      if klass <= Thor::Group
+        desc usage, description, options
+        define_method(subcommand_name) { invoke klass }
+      else
+        desc usage, description, options
+        subcommand subcommand_name, klass
+      end
+    end
+
+    # Defines the usage and the description of the next task.
+    #
+    # ==== Parameters
+    # usage<String>
+    # description<String>
+    # options<String>
+    #
+    def desc(usage, description, options={})
+      if options[:for]
+        task = find_and_refresh_task(options[:for])
+        task.usage = usage             if usage
+        task.description = description if description
+      else
+        @usage, @desc, @hide = usage, description, options[:hide] || false
+      end
+    end
+
+    # Defines the long description of the next task.
+    #
+    # ==== Parameters
+    # long description<String>
+    #
+    def long_desc(long_description, options={})
+      if options[:for]
+        task = find_and_refresh_task(options[:for])
+        task.long_description = long_description if long_description
+      else
+        @long_desc = long_description
+      end
+    end
+
+    # Maps an input to a task. If you define:
+    #
+    #   map "-T" => "list"
+    #
+    # Running:
+    #
+    #   thor -T
+    #
+    # Will invoke the list task.
+    #
+    # ==== Parameters
+    # Hash[String|Array => Symbol]:: Maps the string or the strings in the array to the given task.
+    #
+    def map(mappings=nil)
+      @map ||= from_superclass(:map, {})
+
+      if mappings
+        mappings.each do |key, value|
+          if key.respond_to?(:each)
+            key.each {|subkey| @map[subkey] = value}
+          else
+            @map[key] = value
+          end
+        end
+      end
+
+      @map
+    end
+
+    # Declares the options for the next task to be declared.
+    #
+    # ==== Parameters
+    # Hash[Symbol => Object]:: The hash key is the name of the option and the value
+    # is the type of the option. Can be :string, :array, :hash, :boolean, :numeric
+    # or :required (string). If you give a value, the type of the value is used.
+    #
+    def method_options(options=nil)
+      @method_options ||= {}
+      build_options(options, @method_options) if options
+      @method_options
+    end
+
+    # Adds an option to the set of method options. If :for is given as option,
+    # it allows you to change the options from a previous defined task.
+    #
+    #   def previous_task
+    #     # magic
+    #   end
+    #
+    #   method_option :foo => :bar, :for => :previous_task
+    #
+    #   def next_task
+    #     # magic
+    #   end
+    #
+    # ==== Parameters
+    # name<Symbol>:: The name of the argument.
+    # options<Hash>:: Described below.
+    #
+    # ==== Options
+    # :desc     - Description for the argument.
+    # :required - If the argument is required or not.
+    # :default  - Default value for this argument. It cannot be required and have default values.
+    # :aliases  - Aliases for this option.
+    # :type     - The type of the argument, can be :string, :hash, :array, :numeric or :boolean.
+    # :banner   - String to show on usage notes.
+    #
+    def method_option(name, options={})
+      scope = if options[:for]
+        find_and_refresh_task(options[:for]).options
+      else
+        method_options
+      end
+
+      build_option(name, options, scope)
+    end
+
+    # Prints help information for the given task.
+    #
+    # ==== Parameters
+    # shell<Thor::Shell>
+    # task_name<String>
+    #
+    def task_help(shell, task_name)
+      meth = normalize_task_name(task_name)
+      task = all_tasks[meth]
+      handle_no_task_error(meth) unless task
+
+      shell.say "Usage:"
+      shell.say "  #{banner(task)}"
+      shell.say
+      class_options_help(shell, nil => task.options.map { |_, o| o })
+      if task.long_description
+        shell.say "Description:"
+        shell.print_wrapped(task.long_description, :ident => 2)
+      else
+        shell.say task.description
+      end
+    end
+
+    # Prints help information for this class.
+    #
+    # ==== Parameters
+    # shell<Thor::Shell>
+    #
+    def help(shell, subcommand = false)
+      list = printable_tasks(true, subcommand)
+      Thor::Util.thor_classes_in(self).each do |klass|
+        list += klass.printable_tasks(false)
+      end
+      list.sort!{ |a,b| a[0] <=> b[0] }
+
+      shell.say "Tasks:"
+      shell.print_table(list, :ident => 2, :truncate => true)
+      shell.say
+      class_options_help(shell)
+    end
+
+    # Returns tasks ready to be printed.
+    def printable_tasks(all = true, subcommand = false)
+      (all ? all_tasks : tasks).map do |_, task|
+        next if task.hidden?
+        item = []
+        item << banner(task, false, subcommand)
+        item << (task.description ? "# #{task.description.gsub(/\s+/m,' ')}" : "")
+        item
+      end.compact
+    end
+
+    def subcommands
+      @subcommands ||= from_superclass(:subcommands, [])
+    end
+
+    def subcommand(subcommand, subcommand_class)
+      self.subcommands << subcommand.to_s
+      subcommand_class.subcommand_help subcommand
+      define_method(subcommand) { |*args| invoke subcommand_class, args }
+    end
+
+    # Extend check unknown options to accept a hash of conditions.
+    #
+    # === Parameters
+    # options<Hash>: A hash containing :only and/or :except keys
+    def check_unknown_options!(options={})
+      @check_unknown_options ||= Hash.new
+      options.each do |key, value|
+        if value
+          @check_unknown_options[key] = Array(value)
+        else
+          @check_unknown_options.delete(key)
+        end
+      end
+      @check_unknown_options
+    end
+
+    # Overwrite check_unknown_options? to take subcommands and options into account.
+    def check_unknown_options?(config) #:nodoc:
+      options = check_unknown_options
+      return false unless options
+
+      task = config[:current_task]
+      return true unless task
+
+      name = task.name
+
+      if subcommands.include?(name)
+        false
+      elsif options[:except]
+        !options[:except].include?(name.to_sym)
+      elsif options[:only]
+        options[:only].include?(name.to_sym)
+      else
+        true
+      end
+    end
+
+    protected
+
+      # The method responsible for dispatching given the args.
+      def dispatch(meth, given_args, given_opts, config) #:nodoc:
+        meth ||= retrieve_task_name(given_args)
+        task = all_tasks[normalize_task_name(meth)]
+
+        if task
+          args, opts = Thor::Options.split(given_args)
+        else
+          args, opts = given_args, nil
+          task = Thor::DynamicTask.new(meth)
+        end
+
+        opts = given_opts || opts || []
+        config.merge!(:current_task => task, :task_options => task.options)
+
+        instance = new(args, opts, config)
+        args = instance.args
+        trailing = args[Range.new(arguments.size, -1)]
+        instance.invoke_task(task, trailing || [])
+      end
+
+      # The banner for this class. You can customize it if you are invoking the
+      # thor class by another ways which is not the Thor::Runner. It receives
+      # the task that is going to be invoked and a boolean which indicates if
+      # the namespace should be displayed as arguments.
+      #
+      def banner(task, namespace = nil, subcommand = false)
+        "#{basename} #{task.formatted_usage(self, $thor_runner, subcommand)}"
+      end
+
+      def baseclass #:nodoc:
+        Thor
+      end
+
+      def create_task(meth) #:nodoc:
+        if @usage && @desc
+          base_class = @hide ? Thor::HiddenTask : Thor::Task
+          tasks[meth] = base_class.new(meth, @desc, @long_desc, @usage, method_options)
+          @usage, @desc, @long_desc, @method_options, @hide = nil
+          true
+        elsif self.all_tasks[meth] || meth == "method_missing"
+          true
+        else
+          puts "[WARNING] Attempted to create task #{meth.inspect} without usage or description. " <<
+               "Call desc if you want this method to be available as task or declare it inside a " <<
+               "no_tasks{} block. Invoked from #{caller[1].inspect}."
+          false
+        end
+      end
+
+      def initialize_added #:nodoc:
+        class_options.merge!(method_options)
+        @method_options = nil
+      end
+
+      # Retrieve the task name from given args.
+      def retrieve_task_name(args) #:nodoc:
+        meth = args.first.to_s unless args.empty?
+
+        if meth && (map[meth] || meth !~ /^\-/)
+          args.shift
+        else
+          nil
+        end
+      end
+
+      # Receives a task name (can be nil), and try to get a map from it.
+      # If a map can't be found use the sent name or the default task.
+      def normalize_task_name(meth) #:nodoc:
+        meth = map[meth.to_s] || meth || default_task
+        meth.to_s.gsub('-','_') # treat foo-bar > foo_bar
+      end
+
+      def subcommand_help(cmd)
+        desc "help [COMMAND]", "Describe subcommands or one specific subcommand"
+        class_eval <<-RUBY
+          def help(task = nil, subcommand = true); super; end
+        RUBY
+      end
+  end
+
+  include Thor::Base
+
+  map HELP_MAPPINGS => :help
+
+  desc "help [TASK]", "Describe available tasks or one specific task"
+  def help(task = nil, subcommand = false)
+    task ? self.class.task_help(shell, task) : self.class.help(shell, subcommand)
+  end
+end

data/spec/actions/create_file_spec.rb

@@ -0,0 +1,170 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'thor/actions'
+
+describe Thor::Actions::CreateFile do
+  before(:each) do
+    ::FileUtils.rm_rf(destination_root)
+  end
+
+  def create_file(destination=nil, config={}, options={})
+    @base = MyCounter.new([1,2], options, { :destination_root => destination_root })
+    @base.stub!(:file_name).and_return('rdoc')
+
+    @action = Thor::Actions::CreateFile.new(@base, destination, "CONFIGURATION",
+                                            { :verbose => !@silence }.merge(config))
+  end
+
+  def invoke!
+    capture(:stdout){ @action.invoke! }
+  end
+
+  def revoke!
+    capture(:stdout){ @action.revoke! }
+  end
+
+  def silence!
+    @silence = true
+  end
+
+  describe "#invoke!" do
+    it "creates a file" do
+      create_file("doc/config.rb")
+      invoke!
+      File.exists?(File.join(destination_root, "doc/config.rb")).should be_true
+    end
+
+    it "does not create a file if pretending" do
+      create_file("doc/config.rb", {}, :pretend => true)
+      invoke!
+      File.exists?(File.join(destination_root, "doc/config.rb")).should be_false
+    end
+
+    it "shows created status to the user" do
+      create_file("doc/config.rb")
+      invoke!.should == "      create  doc/config.rb\n"
+    end
+
+    it "does not show any information if log status is false" do
+      silence!
+      create_file("doc/config.rb")
+      invoke!.should be_empty
+    end
+
+    it "returns the given destination" do
+      capture(:stdout) do
+        create_file("doc/config.rb").invoke!.should == "doc/config.rb"
+      end
+    end
+
+    it "converts encoded instructions" do
+      create_file("doc/%file_name%.rb.tt")
+      invoke!
+      File.exists?(File.join(destination_root, "doc/rdoc.rb.tt")).should be_true
+    end
+
+    describe "when file exists" do
+      before(:each) do
+        create_file("doc/config.rb")
+        invoke!
+      end
+
+      describe "and is identical" do
+        it "shows identical status" do
+          create_file("doc/config.rb")
+          invoke!
+          invoke!.should == "   identical  doc/config.rb\n"
+        end
+      end
+
+      describe "and is not identical" do
+        before(:each) do
+          File.open(File.join(destination_root, 'doc/config.rb'), 'w'){ |f| f.write("FOO = 3") }
+        end
+
+        it "shows forced status to the user if force is given" do
+          create_file("doc/config.rb", {}, :force => true).should_not be_identical
+          invoke!.should == "       force  doc/config.rb\n"
+        end
+
+        it "shows skipped status to the user if skip is given" do
+          create_file("doc/config.rb", {}, :skip => true).should_not be_identical
+          invoke!.should == "        skip  doc/config.rb\n"
+        end
+
+        it "shows forced status to the user if force is configured" do
+          create_file("doc/config.rb", :force => true).should_not be_identical
+          invoke!.should == "       force  doc/config.rb\n"
+        end
+
+        it "shows skipped status to the user if skip is configured" do
+          create_file("doc/config.rb", :skip => true).should_not be_identical
+          invoke!.should == "        skip  doc/config.rb\n"
+        end
+
+        it "shows conflict status to ther user" do
+          create_file("doc/config.rb").should_not be_identical
+          $stdin.should_receive(:gets).and_return('s')
+          file = File.join(destination_root, 'doc/config.rb')
+
+          content = invoke!
+          content.should =~ /conflict  doc\/config\.rb/
+          content.should =~ /Overwrite #{file}\? \(enter "h" for help\) \[Ynaqdh\]/
+          content.should =~ /skip  doc\/config\.rb/
+        end
+
+        it "creates the file if the file collision menu returns true" do
+          create_file("doc/config.rb")
+          $stdin.should_receive(:gets).and_return('y')
+          invoke!.should =~ /force  doc\/config\.rb/
+        end
+
+        it "skips the file if the file collision menu returns false" do
+          create_file("doc/config.rb")
+          $stdin.should_receive(:gets).and_return('n')
+          invoke!.should =~ /skip  doc\/config\.rb/
+        end
+
+        it "executes the block given to show file content" do
+          create_file("doc/config.rb")
+          $stdin.should_receive(:gets).and_return('d')
+          $stdin.should_receive(:gets).and_return('n')
+          @base.shell.should_receive(:system).with(/diff -u/)
+          invoke!
+        end
+      end
+    end
+  end
+
+  describe "#revoke!" do
+    it "removes the destination file" do
+      create_file("doc/config.rb")
+      invoke!
+      revoke!
+      File.exists?(@action.destination).should be_false
+    end
+
+    it "does not raise an error if the file does not exist" do
+      create_file("doc/config.rb")
+      revoke!
+      File.exists?(@action.destination).should be_false
+    end
+  end
+
+  describe "#exists?" do
+    it "returns true if the destination file exists" do
+      create_file("doc/config.rb")
+      @action.exists?.should be_false
+      invoke!
+      @action.exists?.should be_true
+    end
+  end
+
+  describe "#identical?" do
+    it "returns true if the destination file and is identical" do
+      create_file("doc/config.rb")
+      @action.identical?.should be_false
+      invoke!
+      @action.identical?.should be_true
+    end
+  end
+end

data/spec/actions/directory_spec.rb

@@ -0,0 +1,136 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'thor/actions'
+
+describe Thor::Actions::Directory do
+  before(:each) do
+    ::FileUtils.rm_rf(destination_root)
+    invoker.stub!(:file_name).and_return("rdoc")
+  end
+
+  def invoker
+    @invoker ||= WhinyGenerator.new([1,2], {}, { :destination_root => destination_root })
+  end
+
+  def revoker
+    @revoker ||= WhinyGenerator.new([1,2], {}, { :destination_root => destination_root, :behavior => :revoke })
+  end
+
+  def invoke!(*args, &block)
+    capture(:stdout){ invoker.directory(*args, &block) }
+  end
+
+  def revoke!(*args, &block)
+    capture(:stdout){ revoker.directory(*args, &block) }
+  end
+
+  def exists_and_identical?(source_path, destination_path)
+    %w(config.rb README).each do |file|
+      source      = File.join(source_root, source_path, file)
+      destination = File.join(destination_root, destination_path, file)
+
+      File.exists?(destination).should be_true
+      FileUtils.identical?(source, destination).should be_true
+    end
+  end
+
+  describe "#invoke!" do
+    it "raises an error if the source does not exist" do
+      lambda {
+        invoke! "unknown"
+      }.should raise_error(Thor::Error, /Could not find "unknown" in any of your source paths/)
+    end
+
+    it "should not create a directory in pretend mode" do
+      invoke! "doc", "ghost", :pretend => true
+      File.exists?("ghost").should be_false
+    end
+
+    it "copies the whole directory recursively to the default destination" do
+      invoke! "doc"
+      exists_and_identical?("doc", "doc")
+    end
+
+    it "copies the whole directory recursively to the specified destination" do
+      invoke! "doc", "docs"
+      exists_and_identical?("doc", "docs")
+    end
+
+    it "copies only the first level files if recursive" do
+      invoke! ".", "tasks", :recursive => false
+
+      file = File.join(destination_root, "tasks", "group.thor")
+      File.exists?(file).should be_true
+
+      file = File.join(destination_root, "tasks", "doc")
+      File.exists?(file).should be_false
+
+      file = File.join(destination_root, "tasks", "doc", "README")
+      File.exists?(file).should be_false
+    end
+
+    it "copies files from the source relative to the current path" do
+      invoker.inside "doc" do
+        invoke! "."
+      end
+      exists_and_identical?("doc", "doc")
+    end
+
+    it "copies and evaluates templates" do
+      invoke! "doc", "docs"
+      file = File.join(destination_root, "docs", "rdoc.rb")
+      File.exists?(file).should be_true
+      File.read(file).should == "FOO = FOO\n"
+    end
+
+    it "copies directories" do
+      invoke! "doc", "docs"
+      file = File.join(destination_root, "docs", "components")
+      File.exists?(file).should be_true
+      File.directory?(file).should be_true
+    end
+
+    it "does not copy .empty_directory files" do
+      invoke! "doc", "docs"
+      file = File.join(destination_root, "docs", "components", ".empty_directory")
+      File.exists?(file).should be_false
+    end
+
+    it "copies directories even if they are empty" do
+      invoke! "doc/components", "docs/components"
+      file = File.join(destination_root, "docs", "components")
+      File.exists?(file).should be_true
+    end
+
+    it "does not copy empty directories twice" do
+      content = invoke!("doc/components", "docs/components")
+      content.should_not =~ /exist/
+    end
+
+    it "logs status" do
+      content = invoke!("doc")
+      content.should =~ /create  doc\/README/
+      content.should =~ /create  doc\/config\.rb/
+      content.should =~ /create  doc\/rdoc\.rb/
+      content.should =~ /create  doc\/components/
+    end
+
+    it "yields a block" do
+      checked = false
+      invoke!("doc") do |content|
+        checked ||= !!(content =~ /FOO/)
+      end
+      checked.should be_true
+    end
+  end
+
+  describe "#revoke!" do
+    it "removes the destination file" do
+      invoke! "doc"
+      revoke! "doc"
+
+      File.exists?(File.join(destination_root, "doc", "README")).should be_false
+      File.exists?(File.join(destination_root, "doc", "config.rb")).should be_false
+      File.exists?(File.join(destination_root, "doc", "components")).should be_false
+    end
+  end
+end