thor 0.9.9 → 0.11.5

data/lib/thor/ordered_hash.rb

@@ -1,64 +0,0 @@
-class Thor
-  # 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
-    Node = Struct.new(:key, :value, :next, :prev)
-    include Enumerable
-
-    def initialize
-      @hash = {}
-    end
-
-    def initialize_copy(other)
-      @hash = other.instance_variable_get('@hash').clone
-    end
-
-    def [](key)
-      @hash[key] && @hash[key].value
-    end
-
-    def []=(key, value)
-      node = Node.new(key, value)
-
-      if old = @hash[key]
-        if old.prev
-          old.prev.next = old.next
-        else # old is @first and @last
-          @first = @last = nil
-        end
-      end
-
-      if @first.nil?
-        @first = @last = node
-      else
-        node.prev = @last
-        @last.next = node
-        @last = node
-      end
-
-      @hash[key] = node
-      value
-    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 values
-      self.map { |k, v| v }
-    end
-
-    def +(other)
-      new = clone
-      other.each do |key, value|
-        new[key] = value unless self[key]
-      end
-      new
-    end
-  end
-end

data/lib/thor/task_hash.rb

@@ -1,22 +0,0 @@
-require 'thor/ordered_hash'
-require 'thor/task'
-
-class Thor::TaskHash < Thor::OrderedHash
-  def initialize(klass)
-    super()
-    @klass = klass
-  end
-
-  def each(local = false, &block)
-    super() { |k, t| yield k, t.with_klass(@klass) }
-    @klass.superclass.tasks.each { |k, t| yield k, t.with_klass(@klass) } unless local || @klass == Thor
-  end
-
-  def [](name)
-    if task = super(name) || (@klass == Thor && @klass.superclass.tasks[name])
-      return task.with_klass(@klass)
-    end
-
-    Thor::Task.dynamic(name, @klass)
-  end
-end

data/lib/thor/tasks.rb

@@ -1,77 +0,0 @@
-require "thor"
-require "fileutils"
-
-class Thor
-  def self.package_task(spec)
-    desc "package", "package up the gem"
-    define_method :package do
-      FileUtils.mkdir_p(File.join(Dir.pwd, "pkg"))
-      Gem::Builder.new(spec).build
-      FileUtils.mv(spec.file_name, File.join(Dir.pwd, "pkg", spec.file_name))
-    end
-  end
-  
-  def self.install_task(spec)
-    package_task spec
-
-    null, sudo, gem = RUBY_PLATFORM =~ /w(in)?32$/ ? ['NUL', '', 'gem.bat'] :
-                                                     ['/dev/null', 'sudo', 'gem']
-    
-    desc "install", "install the gem"
-    define_method :install do
-      old_stderr, $stderr = $stderr.dup, File.open(null, "w")
-      package
-      $stderr = old_stderr
-      system %{#{sudo} #{Gem.ruby} -S #{gem} install pkg/#{spec.name}-#{spec.version} --no-rdoc --no-ri --no-update-sources}
-    end
-  end
-  
-  def self.spec_task(file_list, opts = {})
-    name = opts.delete(:name) || "spec"
-    rcov_dir = opts.delete(:rcov_dir) || "coverage"
-    file_list = file_list.map {|f| %["#{f}"]}.join(" ")
-    verbose = opts.delete(:verbose)
-    opts = {:format => "specdoc", :color => true}.merge(opts)
-    
-    rcov_opts = convert_task_options(opts.delete(:rcov) || {})
-    rcov = !rcov_opts.empty?
-    options = convert_task_options(opts)
-    
-    if rcov
-      FileUtils.rm_rf(File.join(Dir.pwd, rcov_dir))
-    end
-    
-    desc(name, "spec task")
-    define_method(name) do
-      cmd = "ruby "
-      if rcov
-        cmd << "-S rcov -o #{rcov_dir} #{rcov_opts} "
-      end
-      cmd << `which spec`.chomp
-      cmd << " -- " if rcov
-      cmd << " "
-      cmd << file_list
-      cmd << " "
-      cmd << options
-      puts cmd if verbose
-      system(cmd)
-      exit($?.exitstatus)
-    end
-  end
-  
-  private
-  def self.convert_task_options(opts)
-    opts.map do |key, value|
-      case value
-      when true
-        "--#{key}"
-      when Array
-        value.map {|v| "--#{key} #{v.inspect}"}.join(" ")
-      when nil, false
-        ""
-      else
-        "--#{key} #{value.inspect}"
-      end
-    end.join(" ")    
-  end  
-end

data/lib/thor/tasks/package.rb

@@ -1,18 +0,0 @@
-require "thor/task"
-
-class Thor::PackageTask < Thor::Task
-  attr_accessor :spec
-  attr_accessor :opts
-
-  def initialize(gemspec, opts = {})
-    super(:package, "build a gem package")
-    @spec = gemspec
-    @opts = {:dir => File.join(Dir.pwd, "pkg")}.merge(opts)
-  end
-
-  def run
-    FileUtils.mkdir_p(@opts[:dir])
-    Gem::Builder.new(spec).build
-    FileUtils.mv(spec.file_name, File.join(@opts[:dir], spec.file_name))
-  end
-end