github_cli 0.5.3 → 0.5.4

data/lib/github_cli/vendor/thor/group.rb

@@ -1,9 +1,9 @@
 require 'thor/base'
 
 # Thor has a special class called Thor::Group. The main difference to Thor class
-# is that it invokes all tasks at once. It also include some methods that allows
+# is that it invokes all commands at once. It also include some methods that allows
 # invocations to be done at the class method, which are not available to Thor
-# tasks.
+# commands.
 class Thor::Group
   class << self
     # The description for this Thor::Group. If none is provided, but a source root
@@ -14,11 +14,11 @@ class Thor::Group
     # description<String>:: The description for this Thor::Group.
     #
     def desc(description=nil)
-      case description
-        when nil
-          @desc ||= from_superclass(:desc, nil)
-        else
-          @desc = description
+      @desc = case description
+      when nil
+        @desc || from_superclass(:desc, nil)
+      else
+        description
       end
     end
 
@@ -48,7 +48,7 @@ class Thor::Group
     end
 
     # Invoke the given namespace or class given. It adds an instance
-    # method that will invoke the klass and task. You can give a block to
+    # method that will invoke the klass and command. You can give a block to
     # configure how it will be invoked.
     #
     # The namespace/class given will have its options showed on the help
@@ -64,12 +64,12 @@ class Thor::Group
 
         class_eval <<-METHOD, __FILE__, __LINE__
           def _invoke_#{name.to_s.gsub(/\W/, '_')}
-            klass, task = self.class.prepare_for_invocation(nil, #{name.inspect})
+            klass, command = self.class.prepare_for_invocation(nil, #{name.inspect})
 
             if klass
               say_status :invoke, #{name.inspect}, #{verbose.inspect}
               block = self.class.invocation_blocks[#{name.inspect}]
-              _invoke_for_class_method klass, task, &block
+              _invoke_for_class_method klass, command, &block
             else
               say_status :error, %(#{name.inspect} [not found]), :red
             end
@@ -100,7 +100,7 @@ class Thor::Group
     # In some cases you want to customize how a specified hook is going to be
     # invoked. You can do that by overwriting the class method
     # prepare_for_invocation. The class method must necessarily return a klass
-    # and an optional task.
+    # and an optional command.
     #
     # ==== Custom invocations
     #
@@ -127,12 +127,12 @@ class Thor::Group
 
             value = options[#{name.inspect}]
             value = #{name.inspect} if TrueClass === value
-            klass, task = self.class.prepare_for_invocation(#{name.inspect}, value)
+            klass, command = self.class.prepare_for_invocation(#{name.inspect}, value)
 
             if klass
               say_status :invoke, value, #{verbose.inspect}
               block = self.class.invocation_blocks[#{name.inspect}]
-              _invoke_for_class_method klass, task, &block
+              _invoke_for_class_method klass, command, &block
             else
               say_status :error, %(\#{value} [not found]), :red
             end
@@ -149,7 +149,7 @@ class Thor::Group
     #
     def remove_invocation(*names)
       names.each do |name|
-        remove_task(name)
+        remove_command(name)
         remove_class_option(name)
         invocations.delete(name)
         invocation_blocks.delete(name)
@@ -196,21 +196,22 @@ class Thor::Group
       end
     end
 
-    # Returns tasks ready to be printed.
-    def printable_tasks(*)
+    # Returns commands ready to be printed.
+    def printable_commands(*)
       item = []
       item << banner
       item << (desc ? "# #{desc.gsub(/\s+/m,' ')}" : "")
       [item]
     end
+    alias printable_tasks printable_commands
 
-    def handle_argument_error(task, error, arity=nil) #:nodoc:
+    def handle_argument_error(command, error, arity=nil) #:nodoc:
       if arity > 0
-        msg = "#{basename} #{task.name} takes #{arity} argument"
+        msg = "#{basename} #{command.name} takes #{arity} argument"
         msg << "s" if arity > 1
         msg << ", but it should not."
       else
-        msg = "You should not pass arguments to #{basename} #{task.name}."
+        msg = "You should not pass arguments to #{basename} #{command.name}."
       end
 
       raise error, msg
@@ -219,7 +220,7 @@ class Thor::Group
     protected
 
       # The method responsible for dispatching given the args.
-      def dispatch(task, given_args, given_opts, config) #:nodoc:
+      def dispatch(command, given_args, given_opts, config) #:nodoc:
         if Thor::HELP_MAPPINGS.include?(given_args.first)
           help(config[:shell])
           return
@@ -230,10 +231,9 @@ class Thor::Group
 
         instance = new(args, opts, config)
         yield instance if block_given?
-        args = instance.args
 
-        if task
-          instance.invoke_task(all_tasks[task])
+        if command
+          instance.invoke_command(all_commands[command])
         else
           instance.invoke_all
         end
@@ -242,22 +242,24 @@ class Thor::Group
       # 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.
       def banner
-        "#{basename} #{self_task.formatted_usage(self, false)}"
+        "#{basename} #{self_command.formatted_usage(self, false)}"
       end
 
-      # Represents the whole class as a task.
-      def self_task #:nodoc:
-        Thor::DynamicTask.new(self.namespace, class_options)
+      # Represents the whole class as a command.
+      def self_command #:nodoc:
+        Thor::DynamicCommand.new(self.namespace, class_options)
       end
+      alias self_task self_command
 
       def baseclass #:nodoc:
         Thor::Group
       end
 
-      def create_task(meth) #:nodoc:
-        tasks[meth.to_s] = Thor::Task.new(meth, nil, nil, nil, nil)
+      def create_command(meth) #:nodoc:
+        commands[meth.to_s] = Thor::Command.new(meth, nil, nil, nil, nil)
         true
       end
+      alias create_task create_command
   end
 
   include Thor::Base
@@ -266,19 +268,19 @@ class Thor::Group
 
   # Shortcut to invoke with padding and block handling. Use internally by
   # invoke and invoke_from_option class methods.
-  def _invoke_for_class_method(klass, task=nil, *args, &block) #:nodoc:
+  def _invoke_for_class_method(klass, command=nil, *args, &block) #:nodoc:
     with_padding do
       if block
         case block.arity
         when 3
-          block.call(self, klass, task)
+          block.call(self, klass, command)
         when 2
           block.call(self, klass)
         when 1
           instance_exec(klass, &block)
         end
       else
-        invoke klass, task, *args
+        invoke klass, command, *args
       end
     end
   end

data/lib/github_cli/vendor/thor/invocation.rb

@@ -6,12 +6,12 @@ class Thor
 
     module ClassMethods
       # This method is responsible for receiving a name and find the proper
-      # class and task for it. The key is an optional parameter which is
+      # class and command for it. The key is an optional parameter which is
       # available only in class methods invocations (i.e. in Thor::Group).
       def prepare_for_invocation(key, name) #:nodoc:
         case name
         when Symbol, String
-          Thor::Util.find_class_and_task_by_namespace(name.to_s, !key)
+          Thor::Util.find_class_and_command_by_namespace(name.to_s, !key)
         else
           name
         end
@@ -25,15 +25,15 @@ class Thor
       super
     end
 
-    # Receives a name and invokes it. The name can be a string (either "task" or
-    # "namespace:task"), a Thor::Task, a Class or a Thor instance. If the task
-    # cannot be guessed by name, it can also be supplied as second argument.
+    # Receives a name and invokes it. The name can be a string (either "command" or
+    # "namespace:command"), a Thor::Command, a Class or a Thor instance. If the
+    # command cannot be guessed by name, it can also be supplied as second argument.
     #
     # You can also supply the arguments, options and configuration values for
-    # the task to be invoked, if none is given, the same values used to
+    # the command to be invoked, if none is given, the same values used to
     # initialize the invoker are used to initialize the invoked.
     #
-    # When no name is given, it will invoke the default task of the current class.
+    # When no name is given, it will invoke the default command of the current class.
     #
     # ==== Examples
     #
@@ -54,16 +54,16 @@ class Thor
     #     end
     #   end
     #
-    # You can notice that the method "foo" above invokes two tasks: "bar",
+    # You can notice that the method "foo" above invokes two commands: "bar",
     # which belongs to the same class and "hello" which belongs to the class B.
     #
-    # By using an invocation system you ensure that a task is invoked only once.
+    # By using an invocation system you ensure that a command is invoked only once.
     # In the example above, invoking "foo" will invoke "b:hello" just once, even
     # if it's invoked later by "bar" method.
     #
     # When class A invokes class B, all arguments used on A initialization are
     # supplied to B. This allows lazy parse of options. Let's suppose you have
-    # some rspec tasks:
+    # some rspec commands:
     #
     #   class Rspec < Thor::Group
     #     class_option :mock_framework, :type => :string, :default => :rr
@@ -100,30 +100,31 @@ class Thor
       end
 
       args.unshift(nil) if Array === args.first || NilClass === args.first
-      task, args, opts, config = args
+      command, args, opts, config = args
 
-      klass, task = _retrieve_class_and_task(name, task)
+      klass, command = _retrieve_class_and_command(name, command)
       raise "Expected Thor class, got #{klass}" unless klass <= Thor::Base
 
       args, opts, config = _parse_initialization_options(args, opts, config)
-      klass.send(:dispatch, task, args, opts, config) do |instance|
+      klass.send(:dispatch, command, args, opts, config) do |instance|
         instance.parent_options = options
       end
     end
 
-    # Invoke the given task if the given args.
-    def invoke_task(task, *args) #:nodoc:
+    # Invoke the given command if the given args.
+    def invoke_command(command, *args) #:nodoc:
       current = @_invocations[self.class]
 
-      unless current.include?(task.name)
-        current << task.name
-        task.run(self, *args)
+      unless current.include?(command.name)
+        current << command.name
+        command.run(self, *args)
       end
     end
+    alias invoke_task invoke_command
 
-    # Invoke all tasks for the current instance.
+    # Invoke all commands for the current instance.
     def invoke_all #:nodoc:
-      self.class.all_tasks.map { |_, task| invoke_task(task) }
+      self.class.all_commands.map { |_, command| invoke_command(command) }
     end
 
     # Invokes using shell padding.
@@ -138,21 +139,22 @@ class Thor
         { :invocations => @_invocations }
       end
 
-      # This method simply retrieves the class and task to be invoked.
-      # If the name is nil or the given name is a task in the current class,
+      # This method simply retrieves the class and command to be invoked.
+      # If the name is nil or the given name is a command in the current class,
       # use the given name and return self as class. Otherwise, call
       # prepare_for_invocation in the current class.
-      def _retrieve_class_and_task(name, sent_task=nil) #:nodoc:
+      def _retrieve_class_and_command(name, sent_command=nil) #:nodoc:
         case
         when name.nil?
           [self.class, nil]
-        when self.class.all_tasks[name.to_s]
+        when self.class.all_commands[name.to_s]
           [self.class, name.to_s]
         else
-          klass, task = self.class.prepare_for_invocation(nil, name)
-          [klass, task || sent_task]
+          klass, command = self.class.prepare_for_invocation(nil, name)
+          [klass, command || sent_command]
         end
       end
+      alias _retrieve_class_and_task _retrieve_class_and_command
 
       # Initialize klass using values stored in the @_initializer.
       def _parse_initialization_options(args, opts, config) #:nodoc:

data/lib/github_cli/vendor/thor/parser/options.rb

@@ -5,27 +5,32 @@ class Thor
     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
+    OPTS_END    = '--'.freeze
 
     # 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}"
+        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={})
+    #
+    # If +stop_on_unknown+ is true, #parse will stop as soon as it encounters
+    # an unknown option or a regular argument.
+    def initialize(hash_options={}, defaults={}, stop_on_unknown=false)
+      @stop_on_unknown = stop_on_unknown
       options = hash_options.values
       super(options)
 
@@ -41,7 +46,8 @@ class Thor
         @switches[option.switch_name] = option
 
         option.aliases.each do |short|
-          @shorts[short.to_s] ||= option.switch_name
+          name = short.to_s.sub(/^(?!\-)/, '-')
+          @shorts[name] ||= option.switch_name
         end
       end
     end
@@ -50,15 +56,30 @@ class Thor
       @extra
     end
 
+    def peek
+      return super unless @parsing_options
+
+      result = super
+      if result == OPTS_END
+        shift
+        @parsing_options = false
+        super
+      else
+        result
+      end
+    end
+
     def parse(args)
       @pile = args.dup
+      @parsing_options = true
 
       while peek
-        match, is_switch = current_is_switch?
-        shifted = shift
+        if parsing_options?
+          match, is_switch = current_is_switch?
+          shifted = shift
 
-        if is_switch
-          case shifted
+          if is_switch
+            case shifted
             when SHORT_SQ_RE
               unshift($1.split('').map { |f| "-#{f}" })
               next
@@ -67,16 +88,24 @@ class Thor
               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 @stop_on_unknown
+            @parsing_options = false
+            @extra << shifted
+            @extra << shift while peek
+            break
+          elsif match
+            @extra << shifted
+            @extra << shift while peek && peek !~ /^-/
+          else
+            @extra << shifted
           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
+          @extra << shift
         end
       end
 
@@ -95,8 +124,10 @@ class Thor
 
     protected
 
-      # Returns true if the current value in peek is a registered switch.
+      # Check if the current value in peek is a registered switch.
       #
+      # Two booleans are returned.  The first is true if the current value
+      # starts with a hyphen; the second is true if it is a registered switch.
       def current_is_switch?
         case peek
         when LONG_RE, SHORT_RE, EQ_RE, SHORT_NUM
@@ -117,6 +148,10 @@ class Thor
         end
       end
 
+      def current_is_value?
+        peek && (!parsing_options? || super)
+      end
+
       def switch?(arg)
         switch_option(normalize_switch(arg))
       end
@@ -135,6 +170,11 @@ class Thor
         (@shorts[arg] || arg).tr('_', '-')
       end
 
+      def parsing_options?
+        peek
+        @parsing_options
+      end
+
       # Parse boolean values which can be given as --foo=true, --foo or --no-foo.
       #
       def parse_boolean(switch)
@@ -156,7 +196,7 @@ class Thor
       # 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 parsing_options? && (current_is_switch_formatted? || last?)
           if option.boolean?
             # No problem for boolean types
           elsif no_or_skip?(switch)

data/lib/github_cli/vendor/thor/rake_compat.rb

@@ -6,12 +6,13 @@ class Thor
   # rake package tasks. For example, to use rspec rake tasks, one can do:
   #
   #   require 'thor/rake_compat'
+  #   require 'rspec/core/rake_task'
   #
   #   class Default < Thor
   #     include Thor::RakeCompat
   #
-  #     Spec::Rake::SpecTask.new(:spec) do |t|
-  #       t.spec_opts = ['--options', "spec/spec.opts"]
+  #     RSpec::Core::RakeTask.new(:spec) do |t|
+  #       t.spec_opts = ['--options', "./.rspec"]
   #       t.spec_files = FileList['spec/**/*_spec.rb']
   #     end
   #   end

data/lib/github_cli/vendor/thor/runner.rb

@@ -1,6 +1,6 @@
 require 'thor'
 require 'thor/group'
-require 'thor/core_ext/file_binary_read'
+require 'thor/core_ext/io_binary_read'
 
 require 'fileutils'
 require 'open-uri'
@@ -16,33 +16,33 @@ class Thor::Runner < Thor #:nodoc:
   def help(meth = nil)
     if meth && !self.respond_to?(meth)
       initialize_thorfiles(meth)
-      klass, task = Thor::Util.find_class_and_task_by_namespace(meth)
-      self.class.handle_no_task_error(task, false) if klass.nil?
-      klass.start(["-h", task].compact, :shell => self.shell)
+      klass, command = Thor::Util.find_class_and_command_by_namespace(meth)
+      self.class.handle_no_command_error(command, false) if klass.nil?
+      klass.start(["-h", command].compact, :shell => self.shell)
     else
       super
     end
   end
 
-  # If a task is not found on Thor::Runner, method missing is invoked and
-  # Thor::Runner is then responsable for finding the task in all classes.
+  # If a command is not found on Thor::Runner, method missing is invoked and
+  # Thor::Runner is then responsible for finding the command in all classes.
   #
   def method_missing(meth, *args)
     meth = meth.to_s
     initialize_thorfiles(meth)
-    klass, task = Thor::Util.find_class_and_task_by_namespace(meth)
-    self.class.handle_no_task_error(task, false) if klass.nil?
-    args.unshift(task) if task
+    klass, command = Thor::Util.find_class_and_command_by_namespace(meth)
+    self.class.handle_no_command_error(command, false) if klass.nil?
+    args.unshift(command) if command
     klass.start(args, :shell => self.shell)
   end
 
-  desc "install NAME", "Install an optionally named Thor file into your system tasks"
+  desc "install NAME", "Install an optionally named Thor file into your system commands"
   method_options :as => :string, :relative => :boolean, :force => :boolean
   def install(name)
     initialize_thorfiles
 
     # If a directory name is provided as the argument, look for a 'main.thor'
-    # task in said directory.
+    # command in said directory.
     begin
       if File.directory?(File.expand_path(name))
         base, package = File.join(name, "main.thor"), :directory
@@ -143,14 +143,14 @@ class Thor::Runner < Thor #:nodoc:
     end
   end
 
-  desc "installed", "List the installed Thor modules and tasks"
+  desc "installed", "List the installed Thor modules and commands"
   method_options :internal => :boolean
   def installed
     initialize_thorfiles(nil, true)
     display_klasses(true, options["internal"])
   end
 
-  desc "list [SEARCH]", "List the available thor tasks (--substring means .*SEARCH)"
+  desc "list [SEARCH]", "List the available thor commands (--substring means .*SEARCH)"
   method_options :substring => :boolean, :group => :string, :all => :boolean, :debug => :boolean
   def list(search="")
     initialize_thorfiles
@@ -168,8 +168,8 @@ class Thor::Runner < Thor #:nodoc:
 
   private
 
-    def self.banner(task, all = false, subcommand = false)
-      "thor " + task.formatted_usage(self, all, subcommand)
+    def self.banner(command, all = false, subcommand = false)
+      "thor " + command.formatted_usage(self, all, subcommand)
     end
 
     def thor_root
@@ -276,25 +276,25 @@ class Thor::Runner < Thor #:nodoc:
     def display_klasses(with_modules=false, show_internal=false, klasses=Thor::Base.subclasses)
       klasses -= [Thor, Thor::Runner, Thor::Group] unless show_internal
 
-      raise Error, "No Thor tasks available" if klasses.empty?
+      raise Error, "No Thor commands available" if klasses.empty?
       show_modules if with_modules && !thor_yaml.empty?
 
       list = Hash.new { |h,k| h[k] = [] }
       groups = klasses.select { |k| k.ancestors.include?(Thor::Group) }
 
       # Get classes which inherit from Thor
-      (klasses - groups).each { |k| list[k.namespace.split(":").first] += k.printable_tasks(false) }
+      (klasses - groups).each { |k| list[k.namespace.split(":").first] += k.printable_commands(false) }
 
       # Get classes which inherit from Thor::Base
-      groups.map! { |k| k.printable_tasks(false).first }
+      groups.map! { |k| k.printable_commands(false).first }
       list["root"] = groups
 
       # Order namespaces with default coming first
       list = list.sort{ |a,b| a[0].sub(/^default/, '') <=> b[0].sub(/^default/, '') }
-      list.each { |n, tasks| display_tasks(n, tasks) unless tasks.empty? }
+      list.each { |n, commands| display_commands(n, commands) unless commands.empty? }
     end
 
-    def display_tasks(namespace, list) #:nodoc:
+    def display_commands(namespace, list) #:nodoc:
       list.sort!{ |a,b| a[0] <=> b[0] }
 
       say shell.set_color(namespace, :blue, true)
@@ -303,6 +303,7 @@ class Thor::Runner < Thor #:nodoc:
       print_table(list, :truncate => true)
       say
     end
+    alias display_tasks display_commands
 
     def show_modules #:nodoc:
       info  = []

data/lib/github_cli/vendor/thor/shell/basic.rb

@@ -58,10 +58,10 @@ class Thor
       # ==== Example
       # say("I know you knew that.")
       #
-      def say(message="", color=nil, force_new_line=(message.to_s !~ /( |\t)$/))
+      def say(message="", color=nil, force_new_line=(message.to_s !~ /( |\t)\Z/))
         message = message.to_s
 
-        message = set_color(message, *color) if color
+        message = set_color(message, *color) if color && can_display_colors?
 
         spaces = "  " * padding
 
@@ -226,20 +226,20 @@ class Thor
           answer = ask %[Overwrite #{destination}? (enter "h" for help) #{options}]
 
           case answer
-            when is?(:yes), is?(:force), ""
-              return true
-            when is?(:no), is?(:skip)
-              return false
-            when is?(:always)
-              return @always_force = true
-            when is?(:quit)
-              say 'Aborting...'
-              raise SystemExit
-            when is?(:diff)
-              show_diff(destination, yield) if block_given?
-              say 'Retrying...'
-            else
-              say file_collision_help
+          when is?(:yes), is?(:force), ""
+            return true
+          when is?(:no), is?(:skip)
+            return false
+          when is?(:always)
+            return @always_force = true
+          when is?(:quit)
+            say 'Aborting...'
+            raise SystemExit
+          when is?(:diff)
+            show_diff(destination, yield) if block_given?
+            say 'Retrying...'
+          else
+            say file_collision_help
           end
         end
       end
@@ -275,6 +275,10 @@ class Thor
 
     protected
 
+      def can_display_colors?
+        false
+      end
+
       def lookup_color(color)
         return color unless color.is_a?(Symbol)
         self.class.const_get(color.to_s.upcase)