millisami-thor 0.14.6

data/lib/thor/parser/arguments.rb

@@ -0,0 +1,165 @@
+class Thor
+  class Arguments #:nodoc:
+    NUMERIC = /(\d*\.\d+|\d+)/
+
+    # Receives an array of args and returns two arrays, one with arguments
+    # and one with switches.
+    #
+    def self.split(args)
+      arguments = []
+
+      args.each do |item|
+        break if item =~ /^-/
+        arguments << item
+      end
+
+      return arguments, args[Range.new(arguments.size, -1)]
+    end
+
+    def self.parse(*args)
+      to_parse = args.pop
+      new(*args).parse(to_parse)
+    end
+
+    # Takes an array of Thor::Argument objects.
+    #
+    def initialize(arguments=[])
+      @assigns, @non_assigned_required = {}, []
+      @switches = arguments
+
+      arguments.each do |argument|
+        if argument.default != nil
+          @assigns[argument.human_name] = argument.default
+        elsif argument.required?
+          @non_assigned_required << argument
+        end
+      end
+    end
+
+    def parse(args)
+      @pile = args.dup
+
+      @switches.each do |argument|
+        break unless peek
+        @non_assigned_required.delete(argument)
+        @assigns[argument.human_name] = send(:"parse_#{argument.type}", argument.human_name)
+      end
+
+      check_requirement!
+      @assigns
+    end
+
+    def remaining
+      @pile
+    end
+
+    private
+
+      def no_or_skip?(arg)
+        arg =~ /^--(no|skip)-([-\w]+)$/
+        $2
+      end
+
+      def last?
+        @pile.empty?
+      end
+
+      def peek
+        @pile.first
+      end
+
+      def shift
+        @pile.shift
+      end
+
+      def unshift(arg)
+        unless arg.kind_of?(Array)
+          @pile.unshift(arg)
+        else
+          @pile = arg + @pile
+        end
+      end
+
+      def current_is_value?
+        peek && peek.to_s !~ /^-/
+      end
+
+      # Runs through the argument array getting strings that contains ":" and
+      # mark it as a hash:
+      #
+      #   [ "name:string", "age:integer" ]
+      #
+      # Becomes:
+      #
+      #   { "name" => "string", "age" => "integer" }
+      #
+      def parse_hash(name)
+        return shift if peek.is_a?(Hash)
+        hash = {}
+
+        while current_is_value? && peek.include?(?:)
+          key, value = shift.split(':',2)
+          hash[key] = value
+        end
+        hash
+      end
+
+      # Runs through the argument array getting all strings until no string is
+      # found or a switch is found.
+      #
+      #   ["a", "b", "c"]
+      #
+      # And returns it as an array:
+      #
+      #   ["a", "b", "c"]
+      #
+      def parse_array(name)
+        return shift if peek.is_a?(Array)
+        array = []
+
+        while current_is_value?
+          array << shift
+        end
+        array
+      end
+
+      # Check if the peek is numeric format and return a Float or Integer.
+      # Otherwise raises an error.
+      #
+      def parse_numeric(name)
+        return shift if peek.is_a?(Numeric)
+
+        unless peek =~ NUMERIC && $& == peek
+          raise MalformattedArgumentError, "Expected numeric value for '#{name}'; got #{peek.inspect}"
+        end
+
+        $&.index('.') ? shift.to_f : shift.to_i
+      end
+
+      # Parse string:
+      # for --string-arg, just return the current value in the pile
+      # for --no-string-arg, nil
+      #
+      def parse_string(name)
+        if no_or_skip?(name)
+          nil
+        else
+          shift
+        end
+      end
+
+      # Raises an error if @non_assigned_required array is not empty.
+      #
+      def check_requirement!
+        unless @non_assigned_required.empty?
+          names = @non_assigned_required.map do |o|
+            o.respond_to?(:switch_name) ? o.switch_name : o.human_name
+          end.join("', '")
+
+          class_name = self.class.name.split('::').last.downcase
+          raise RequiredArgumentMissingError, "No value provided for required #{class_name} '#{names}'"
+        end
+      end
+
+  end
+end

data/lib/thor/parser/option.rb

@@ -0,0 +1,120 @@
+class Thor
+  class Option < Argument #:nodoc:
+    attr_reader :aliases, :group, :lazy_default
+
+    VALID_TYPES = [:boolean, :numeric, :hash, :array, :string]
+
+    def initialize(name, description=nil, required=nil, type=nil, default=nil, banner=nil, lazy_default=nil, group=nil, aliases=nil)
+      super(name, description, required, type, default, banner)
+      @lazy_default = lazy_default
+      @group        = group.to_s.capitalize if group
+      @aliases      = [*aliases].compact
+    end
+
+    # This parse quick options given as method_options. It makes several
+    # assumptions, but you can be more specific using the option method.
+    #
+    #   parse :foo => "bar"
+    #   #=> Option foo with default value bar
+    #
+    #   parse [:foo, :baz] => "bar"
+    #   #=> Option foo with default value bar and alias :baz
+    #
+    #   parse :foo => :required
+    #   #=> Required option foo without default value
+    #
+    #   parse :foo => 2
+    #   #=> Option foo with default value 2 and type numeric
+    #
+    #   parse :foo => :numeric
+    #   #=> Option foo without default value and type numeric
+    #
+    #   parse :foo => true
+    #   #=> Option foo with default value true and type boolean
+    #
+    # The valid types are :boolean, :numeric, :hash, :array and :string. If none
+    # is given a default type is assumed. This default type accepts arguments as
+    # string (--foo=value) or booleans (just --foo).
+    #
+    # By default all options are optional, unless :required is given.
+    #
+    def self.parse(key, value)
+      if key.is_a?(Array)
+        name, *aliases = key
+      else
+        name, aliases = key, []
+      end
+
+      name    = name.to_s
+      default = value
+
+      type = case value
+      when Symbol
+        default = nil
+        if VALID_TYPES.include?(value)
+          value
+        elsif required = (value == :required)
+          :string
+        end
+      when TrueClass, FalseClass
+        :boolean
+      when Numeric
+        :numeric
+      when Hash, Array, String
+        value.class.name.downcase.to_sym
+      end
+
+      self.new(name.to_s, nil, required, type, default, nil, nil, nil, aliases)
+    end
+
+    def switch_name
+      @switch_name ||= dasherized? ? name : dasherize(name)
+    end
+
+    def human_name
+      @human_name ||= dasherized? ? undasherize(name) : name
+    end
+
+    def usage(padding=0)
+      sample = if banner && !banner.to_s.empty?
+        "#{switch_name}=#{banner}"
+      else
+        switch_name
+      end
+
+      sample = "[#{sample}]" unless required?
+
+      if aliases.empty?
+        (" " * padding) << sample
+      else
+        "#{aliases.join(', ')}, #{sample}"
+      end
+    end
+
+    VALID_TYPES.each do |type|
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{type}?
+          self.type == #{type.inspect}
+        end
+      RUBY
+    end
+
+  protected
+
+    def validate!
+      raise ArgumentError, "An option cannot be boolean and required." if boolean? && required?
+    end
+
+    def dasherized?
+      name.index('-') == 0
+    end
+
+    def undasherize(str)
+      str.sub(/^-{1,2}/, '')
+    end
+
+    def dasherize(str)
+      (str.length > 1 ? "--" : "-") + str.gsub('_', '-')
+    end
+  end
+end

data/lib/thor/parser/options.rb

@@ -0,0 +1,181 @@
+class Thor
+  # This is a modified version of Daniel Berger's Getopt::Long class, licensed
+  # under Ruby's license.
+  #
+  class Options < Arguments #:nodoc:
+    LONG_RE     = /^(--\w+(?:-\w+)*)$/
+    SHORT_RE    = /^(-[a-z])$/i
+    EQ_RE       = /^(--\w+(?:-\w+)*|-[a-z])=(.*)$/i
+    SHORT_SQ_RE = /^-([a-z]{2,})$/i # Allow either -x -v or -xv style for single char args
+    SHORT_NUM   = /^(-[a-z])#{NUMERIC}$/i
+
+    # Receives a hash and makes it switches.
+    def self.to_switches(options)
+      options.map do |key, value|
+        case value
+          when true
+            "--#{key}"
+          when Array
+            "--#{key} #{value.map{ |v| v.inspect }.join(' ')}"
+          when Hash
+            "--#{key} #{value.map{ |k,v| "#{k}:#{v}" }.join(' ')}"
+          when nil, false
+            ""
+          else
+            "--#{key} #{value.inspect}"
+        end
+      end.join(" ")
+    end
+
+    # Takes a hash of Thor::Option and a hash with defaults.
+    def initialize(hash_options={}, defaults={})
+      options = hash_options.values
+      super(options)
+
+      # Add defaults
+      defaults.each do |key, value|
+        @assigns[key.to_s] = value
+        @non_assigned_required.delete(hash_options[key])
+      end
+
+      @shorts, @switches, @extra = {}, {}, []
+
+      options.each do |option|
+        @switches[option.switch_name] = option
+
+        option.aliases.each do |short|
+          @shorts[short.to_s] ||= option.switch_name
+        end
+      end
+    end
+
+    def remaining
+      @extra
+    end
+
+    def parse(args)
+      @pile = args.dup
+
+      while peek
+        match, is_switch = current_is_switch?
+        shifted = shift
+
+        if is_switch
+          case shifted
+            when SHORT_SQ_RE
+              unshift($1.split('').map { |f| "-#{f}" })
+              next
+            when EQ_RE, SHORT_NUM
+              unshift($2)
+              switch = $1
+            when LONG_RE, SHORT_RE
+              switch = $1
+          end
+
+          switch = normalize_switch(switch)
+          option = switch_option(switch)
+          @assigns[option.human_name] = parse_peek(switch, option)
+        elsif match
+          @extra << shifted
+          @extra << shift while peek && peek !~ /^-/
+        else
+          @extra << shifted
+        end
+      end
+
+      check_requirement!
+
+      assigns = Thor::CoreExt::HashWithIndifferentAccess.new(@assigns)
+      assigns.freeze
+      assigns
+    end
+
+    def check_unknown!
+      # an unknown option starts with - or -- and has no more -'s afterward.
+      unknown = @extra.select { |str| str =~ /^--?[^-]*$/ }
+      raise UnknownArgumentError, "Unknown switches '#{unknown.join(', ')}'" unless unknown.empty?
+    end
+
+    protected
+
+      # Returns true if the current value in peek is a registered switch.
+      #
+      def current_is_switch?
+        case peek
+        when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM
+          [true, switch?($1)]
+        when SHORT_SQ_RE
+          [true, $1.split('').any? { |f| switch?("-#{f}") }]
+        else
+          [false, false]
+        end
+      end
+
+      def current_is_switch_formatted?
+        case peek
+        when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM, SHORT_SQ_RE
+          true
+        else
+          false
+        end
+      end
+
+      def switch?(arg)
+        switch_option(normalize_switch(arg))
+      end
+
+      def switch_option(arg)
+        if match = no_or_skip?(arg)
+          @switches[arg] || @switches["--#{match}"]
+        else
+          @switches[arg]
+        end
+      end
+
+      # Check if the given argument is actually a shortcut.
+      #
+      def normalize_switch(arg)
+        (@shorts[arg] || arg).tr('_', '-')
+      end
+
+      # Parse boolean values which can be given as --foo=true, --foo or --no-foo.
+      #
+      def parse_boolean(switch)
+        if current_is_value?
+          if ["true", "TRUE", "t", "T", true].include?(peek)
+            shift
+            true
+          elsif ["false", "FALSE", "f", "F", false].include?(peek)
+            shift
+            false
+          else
+            true
+          end
+        else
+          @switches.key?(switch) || !no_or_skip?(switch)
+        end
+      end
+
+      # Parse the value at the peek analyzing if it requires an input or not.
+      #
+      def parse_peek(switch, option)
+        if current_is_switch_formatted? || last?
+          if option.boolean?
+            # No problem for boolean types
+          elsif no_or_skip?(switch)
+            return nil # User set value to nil
+          elsif option.string? && !option.required?
+            # Return the default if there is one, else the human name
+            return option.lazy_default || option.default || option.human_name
+          elsif option.lazy_default
+            return option.lazy_default
+          else
+            raise MalformattedArgumentError, "No value provided for option '#{switch}'"
+          end
+        end
+
+        @non_assigned_required.delete(option)
+        send(:"parse_#{option.type}", switch)
+      end
+  end
+end

data/lib/thor/parser.rb

@@ -0,0 +1,4 @@
+require 'thor/parser/argument'
+require 'thor/parser/arguments'
+require 'thor/parser/option'
+require 'thor/parser/options'

data/lib/thor/rake_compat.rb

@@ -0,0 +1,70 @@
+require 'rake'
+require 'rake/dsl_definition'
+
+class Thor
+  # Adds a compatibility layer to your Thor classes which allows you to use
+  # rake package tasks. For example, to use rspec rake tasks, one can do:
+  #
+  #   require 'thor/rake_compat'
+  #
+  #   class Default < Thor
+  #     include Thor::RakeCompat
+  #
+  #     Spec::Rake::SpecTask.new(:spec) do |t|
+  #       t.spec_opts = ['--options', "spec/spec.opts"]
+  #       t.spec_files = FileList['spec/**/*_spec.rb']
+  #     end
+  #   end
+  #
+  module RakeCompat
+    include Rake::DSL if defined?(Rake::DSL)
+
+    def self.rake_classes
+      @rake_classes ||= []
+    end
+
+    def self.included(base)
+      # Hack. Make rakefile point to invoker, so rdoc task is generated properly.
+      rakefile = File.basename(caller[0].match(/(.*):\d+/)[1])
+      Rake.application.instance_variable_set(:@rakefile, rakefile)
+      self.rake_classes << base
+    end
+  end
+end
+
+# override task on (main), for compatibility with Rake 0.9
+self.instance_eval do
+  alias rake_namespace namespace
+
+  def task(*)
+    task = super
+
+    if klass = Thor::RakeCompat.rake_classes.last
+      non_namespaced_name = task.name.split(':').last
+
+      description = non_namespaced_name
+      description << task.arg_names.map{ |n| n.to_s.upcase }.join(' ')
+      description.strip!
+
+      klass.desc description, task.comment || non_namespaced_name
+      klass.send :define_method, non_namespaced_name do |*args|
+        Rake::Task[task.name.to_sym].invoke(*args)
+      end
+    end
+
+    task
+  end
+
+  def namespace(name)
+    if klass = Thor::RakeCompat.rake_classes.last
+      const_name = Thor::Util.camel_case(name.to_s).to_sym
+      klass.const_set(const_name, Class.new(Thor))
+      new_klass = klass.const_get(const_name)
+      Thor::RakeCompat.rake_classes << new_klass
+    end
+
+    super
+    Thor::RakeCompat.rake_classes.pop
+  end
+end
+