thor 0.16.0 → 1.2.1

data/bin/rake2thor

@@ -1,86 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'ruby2ruby'
-require 'parse_tree'
-if Ruby2Ruby::VERSION >= "1.2.0"
-  require 'parse_tree_extensions'
-end
-require 'rake'
-
-input  = ARGV[0] || 'Rakefile'
-output = ARGV[1] || 'Thorfile'
-
-$requires = []
-
-module Kernel
-  def require_with_record(file)
-    $requires << file if caller[1] =~ /rake2thor:/
-    require_without_record file
-  end
-  alias_method :require_without_record, :require
-  alias_method :require, :require_with_record
-end
-
-load input
-
-@private_methods = []
-
-def file_task_name(name)
-  "compile_" + name.gsub('/', '_slash_').gsub('.', '_dot_').gsub(/\W/, '_')
-end
-
-def method_for_task(task)
-  file_task = task.is_a?(Rake::FileTask)
-  comment = task.instance_variable_get('@comment')
-  prereqs = task.instance_variable_get('@prerequisites').select(&Rake::Task.method(:task_defined?))
-  actions = task.instance_variable_get('@actions')
-  name = task.name.gsub(/^([^:]+:)+/, '')
-  name = file_task_name(name) if file_task
-  meth = ''
-
-  meth << "desc #{name.inspect}, #{comment.inspect}\n" if comment
-  meth << "def #{name}\n"
-
-  meth << prereqs.map do |pre|
-    pre = pre.to_s
-    pre = file_task_name(pre) if Rake::Task[pre].is_a?(Rake::FileTask)
-    '  ' + pre
-  end.join("\n")
-
-  meth << "\n\n" unless prereqs.empty? || actions.empty?
-
-  meth << actions.map do |act|
-    act = act.to_ruby
-    unless act.gsub!(/^proc \{ \|(\w+)\|\n/,
-                     "  \\1 = Struct.new(:name).new(#{name.inspect}) # A crude mock Rake::Task object\n")
-      act.gsub!(/^proc \{\n/, '')
-    end
-    act.gsub(/\n\}$/, '')
-  end.join("\n")
-
-  meth << "\nend"
-
-  if file_task
-    @private_methods << meth
-    return
-  end
-
-  meth
-end
-
-body = Rake::Task.tasks.map(&method(:method_for_task)).compact.map { |meth| meth.gsub(/^/, '  ') }.join("\n\n")
-
-unless @private_methods.empty?
-  body << "\n\n  private\n\n"
-  body << @private_methods.map { |meth| meth.gsub(/^/, '  ') }.join("\n\n")
-end
-
-requires = $requires.map { |r| "require #{r.inspect}" }.join("\n")
-
-File.open(output, 'w') { |f| f.write(<<END.lstrip) }
-#{requires}
-
-class Default < Thor
-#{body}
-end
-END

data/lib/thor/core_ext/file_binary_read.rb

@@ -1,9 +0,0 @@
-class File #:nodoc:
-
-  unless File.respond_to?(:binread)
-    def self.binread(file)
-      File.open(file, 'rb') { |f| f.read }
-    end
-  end
-
-end

data/lib/thor/core_ext/ordered_hash.rb

@@ -1,100 +0,0 @@
-class Thor
-  module CoreExt #:nodoc:
-
-    if RUBY_VERSION >= '1.9'
-      class OrderedHash < ::Hash
-      end
-    else
-      # This class is based on the Ruby 1.9 ordered hashes.
-      #
-      # It keeps the semantics and most of the efficiency of normal hashes
-      # while also keeping track of the order in which elements were set.
-      #
-      class OrderedHash #:nodoc:
-        include Enumerable
-
-        Node = Struct.new(:key, :value, :next, :prev)
-
-        def initialize
-          @hash = {}
-        end
-
-        def [](key)
-          @hash[key] && @hash[key].value
-        end
-
-        def []=(key, value)
-          if node = @hash[key]
-            node.value = value
-          else
-            node = Node.new(key, value)
-
-            if @first.nil?
-              @first = @last = node
-            else
-              node.prev = @last
-              @last.next = node
-              @last = node
-            end
-          end
-
-          @hash[key] = node
-          value
-        end
-
-        def delete(key)
-          if node = @hash[key]
-            prev_node = node.prev
-            next_node = node.next
-
-            next_node.prev = prev_node if next_node
-            prev_node.next = next_node if prev_node
-
-            @first = next_node if @first == node
-            @last = prev_node  if @last  == node
-
-            value = node.value
-          end
-
-          @hash.delete(key)
-          value
-        end
-
-        def keys
-          self.map { |k, v| k }
-        end
-
-        def values
-          self.map { |k, v| v }
-        end
-
-        def each
-          return unless @first
-          yield [@first.key, @first.value]
-          node = @first
-          yield [node.key, node.value] while node = node.next
-          self
-        end
-
-        def merge(other)
-          hash = self.class.new
-
-          self.each do |key, value|
-            hash[key] = value
-          end
-
-          other.each do |key, value|
-            hash[key] = value
-          end
-
-          hash
-        end
-
-        def empty?
-          @hash.empty?
-        end
-      end
-    end
-
-  end
-end

data/lib/thor/task.rb

@@ -1,132 +0,0 @@
-class Thor
-  class Task < Struct.new(:name, :description, :long_description, :usage, :options)
-    FILE_REGEXP = /^#{Regexp.escape(File.dirname(__FILE__))}/
-
-    def initialize(name, description, long_description, usage, options=nil)
-      super(name.to_s, description, long_description, usage, options || {})
-    end
-
-    def initialize_copy(other) #:nodoc:
-      super(other)
-      self.options = other.options.dup if other.options
-    end
-
-    def hidden?
-      false
-    end
-
-    # By default, a task invokes a method in the thor class. You can change this
-    # implementation to create custom tasks.
-    def run(instance, args=[])
-      arity = nil
-
-      if private_method?(instance)
-        instance.class.handle_no_task_error(name)
-      elsif public_method?(instance)
-        arity = instance.method(name).arity
-        instance.send(name, *args)
-      elsif local_method?(instance, :method_missing)
-        instance.send(:method_missing, name.to_sym, *args)
-      else
-        instance.class.handle_no_task_error(name)
-      end
-    rescue ArgumentError => e
-      handle_argument_error?(instance, e, caller) ?
-        instance.class.handle_argument_error(self, e, arity) : (raise e)
-    rescue NoMethodError => e
-      handle_no_method_error?(instance, e, caller) ?
-        instance.class.handle_no_task_error(name) : (raise e)
-    end
-
-    # Returns the formatted usage by injecting given required arguments
-    # and required options into the given usage.
-    def formatted_usage(klass, namespace = true, subcommand = false)
-      if namespace
-        namespace = klass.namespace
-        formatted = "#{namespace.gsub(/^(default)/,'')}:"
-      end
-      formatted = "#{klass.namespace.split(':').last} " if subcommand
-
-      formatted ||= ""
-
-      # Add usage with required arguments
-      formatted << if klass && !klass.arguments.empty?
-        usage.to_s.gsub(/^#{name}/) do |match|
-          match << " " << klass.arguments.map{ |a| a.usage }.compact.join(' ')
-        end
-      else
-        usage.to_s
-      end
-
-      # Add required options
-      formatted << " #{required_options}"
-
-      # Strip and go!
-      formatted.strip
-    end
-
-  protected
-
-    def not_debugging?(instance)
-      !(instance.class.respond_to?(:debugging) && instance.class.debugging)
-    end
-
-    def required_options
-      @required_options ||= options.map{ |_, o| o.usage if o.required? }.compact.sort.join(" ")
-    end
-
-    # Given a target, checks if this class name is a public method.
-    def public_method?(instance) #:nodoc:
-      !(instance.public_methods & [name.to_s, name.to_sym]).empty?
-    end
-
-    def private_method?(instance)
-      !(instance.private_methods & [name.to_s, name.to_sym]).empty?
-    end
-
-    def local_method?(instance, name)
-      methods = instance.public_methods(false) + instance.private_methods(false) + instance.protected_methods(false)
-      !(methods & [name.to_s, name.to_sym]).empty?
-    end
-
-    def sans_backtrace(backtrace, caller) #:nodoc:
-      saned  = backtrace.reject { |frame| frame =~ FILE_REGEXP || (frame =~ /\.java:/ && RUBY_PLATFORM =~ /java/) }
-      saned -= caller
-    end
-
-    def handle_argument_error?(instance, error, caller)
-      not_debugging?(instance) && error.message =~ /wrong number of arguments/ && begin
-        saned = sans_backtrace(error.backtrace, caller)
-        # Ruby 1.9 always include the called method in the backtrace
-        saned.empty? || (saned.size == 1 && RUBY_VERSION >= "1.9")
-      end
-    end
-
-    def handle_no_method_error?(instance, error, caller)
-      not_debugging?(instance) &&
-        error.message =~ /^undefined method `#{name}' for #{Regexp.escape(instance.to_s)}$/
-    end
-  end
-
-  # A task that is hidden in help messages but still invocable.
-  class HiddenTask < Task
-    def hidden?
-      true
-    end
-  end
-
-  # A dynamic task that handles method missing scenarios.
-  class DynamicTask < Task
-    def initialize(name, options=nil)
-      super(name.to_s, "A dynamically-generated task", name.to_s, name.to_s, options)
-    end
-
-    def run(instance, args=[])
-      if (instance.methods & [name.to_s, name.to_sym]).empty?
-        super
-      else
-        instance.class.handle_no_task_error(name)
-      end
-    end
-  end
-end

data/spec/actions/create_file_spec.rb

@@ -1,170 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-require 'thor/actions'
-
-describe Thor::Actions::CreateFile do
-  before 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 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 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/create_link_spec.rb

@@ -1,81 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-require 'thor/actions'
-require 'tempfile'
-
-describe Thor::Actions::CreateLink do
-  before do
-    @hardlink_to = File.join(Dir.tmpdir, 'linkdest.rb')
-    ::FileUtils.rm_rf(destination_root)
-    ::FileUtils.rm_rf(@hardlink_to)
-  end
-
-  def create_link(destination=nil, config={}, options={})
-    @base = MyCounter.new([1,2], options, { :destination_root => destination_root })
-    @base.stub!(:file_name).and_return('rdoc')
-
-    @tempfile = Tempfile.new("config.rb")
-
-    @action = Thor::Actions::CreateLink.new(@base, destination, @tempfile.path,
-                                            { :verbose => !@silence }.merge(config))
-  end
-
-  def invoke!
-    capture(:stdout){ @action.invoke! }
-  end
-
-  def silence!
-    @silence = true
-  end
-
-  describe "#invoke!" do
-    it "creates a symbolic link for :symbolic => true" do
-      create_link("doc/config.rb", :symbolic => true)
-      invoke!
-      destination_path = File.join(destination_root, "doc/config.rb")
-      File.exists?(destination_path).should be_true
-      File.symlink?(destination_path).should be_true
-    end
-
-    it "creates a hard link for :symbolic => false" do
-      create_link(@hardlink_to, :symbolic => false)
-      invoke!
-      destination_path = @hardlink_to
-      File.exists?(destination_path).should be_true
-      File.symlink?(destination_path).should be_false
-    end
-
-    it "creates a symbolic link by default" do
-      create_link("doc/config.rb")
-      invoke!
-      destination_path = File.join(destination_root, "doc/config.rb")
-      File.exists?(destination_path).should be_true
-      File.symlink?(destination_path).should be_true
-    end
-
-    it "does not create a link if pretending" do
-      create_link("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_link("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_link("doc/config.rb")
-      invoke!.should be_empty
-    end
-  end
-
-  describe "#identical?" do
-    it "returns true if the destination link exists and is identical" do
-      create_link("doc/config.rb")
-      @action.identical?.should be_false
-      invoke!
-      @action.identical?.should be_true
-    end
-  end
-end