shopify-bundler 1.10.7

data/lib/bundler/vendor/thor/lib/thor/command.rb

@@ -0,0 +1,133 @@
+class Bundler::Thor
+  class Command < 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 command invokes a method in the thor class. You can change this
+    # implementation to create custom commands.
+    def run(instance, args = [])
+      arity = nil
+
+      if private_method?(instance)
+        instance.class.handle_no_command_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_command_error(name)
+      end
+    rescue ArgumentError => e
+      handle_argument_error?(instance, e, caller) ? instance.class.handle_argument_error(self, e, args, arity) : (raise e)
+    rescue NoMethodError => e
+      handle_no_method_error?(instance, e, caller) ? instance.class.handle_no_command_error(name) : (fail 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/) || (frame =~ /^kernel\// && RUBY_ENGINE =~ /rbx/) }
+      saned - caller
+    end
+
+    def handle_argument_error?(instance, error, caller)
+      not_debugging?(instance) && (error.message =~ /wrong number of arguments/ || error.message =~ /given \d*, expected \d*/) && 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
+  Task = Command # rubocop:disable ConstantName
+
+  # A command that is hidden in help messages but still invocable.
+  class HiddenCommand < Command
+    def hidden?
+      true
+    end
+  end
+  HiddenTask = HiddenCommand # rubocop:disable ConstantName
+
+  # A dynamic command that handles method missing scenarios.
+  class DynamicCommand < Command
+    def initialize(name, options = nil)
+      super(name.to_s, "A dynamically-generated command", 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_command_error(name)
+      end
+    end
+  end
+  DynamicTask = DynamicCommand # rubocop:disable ConstantName
+end

data/lib/bundler/vendor/thor/lib/thor/core_ext/hash_with_indifferent_access.rb

@@ -0,0 +1,77 @@
+class Bundler::Thor
+  module CoreExt #:nodoc:
+    # A hash with indifferent access and magic predicates.
+    #
+    #   hash = Bundler::Thor::CoreExt::HashWithIndifferentAccess.new 'foo' => 'bar', 'baz' => 'bee', 'force' => true
+    #
+    #   hash[:foo]  #=> 'bar'
+    #   hash['foo'] #=> 'bar'
+    #   hash.foo?   #=> true
+    #
+    class HashWithIndifferentAccess < ::Hash #:nodoc:
+      def initialize(hash = {})
+        super()
+        hash.each do |key, value|
+          self[convert_key(key)] = value
+        end
+      end
+
+      def [](key)
+        super(convert_key(key))
+      end
+
+      def []=(key, value)
+        super(convert_key(key), value)
+      end
+
+      def delete(key)
+        super(convert_key(key))
+      end
+
+      def values_at(*indices)
+        indices.map { |key| self[convert_key(key)] }
+      end
+
+      def merge(other)
+        dup.merge!(other)
+      end
+
+      def merge!(other)
+        other.each do |key, value|
+          self[convert_key(key)] = value
+        end
+        self
+      end
+
+      # Convert to a Hash with String keys.
+      def to_hash
+        Hash.new(default).merge!(self)
+      end
+
+    protected
+
+      def convert_key(key)
+        key.is_a?(Symbol) ? key.to_s : key
+      end
+
+      # Magic predicates. For instance:
+      #
+      #   options.force?                  # => !!options['force']
+      #   options.shebang                 # => "/usr/lib/local/ruby"
+      #   options.test_framework?(:rspec) # => options[:test_framework] == :rspec
+      #
+      def method_missing(method, *args, &block)
+        method = method.to_s
+        if method =~ /^(\w+)\?$/
+          if args.empty?
+            !!self[$1]
+          else
+            self[$1] == args.first
+          end
+        else
+          self[method]
+        end
+      end
+    end
+  end
+end

data/lib/bundler/vendor/thor/lib/thor/core_ext/io_binary_read.rb

@@ -0,0 +1,10 @@
+class IO #:nodoc:
+  class << self
+    def binread(file, *args)
+      fail ArgumentError, "wrong number of arguments (#{1 + args.size} for 1..3)" unless args.size < 3
+      File.open(file, "rb") do |f|
+        f.read(*args)
+      end
+    end unless method_defined? :binread
+  end
+end

data/lib/bundler/vendor/thor/lib/thor/core_ext/ordered_hash.rb

@@ -0,0 +1,98 @@
+class Bundler::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] # rubocop:disable AssignmentInCondition
+            node.value = value
+          else
+            node = Node.new(key, value)
+
+            if !defined?(@first) || @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] # rubocop:disable AssignmentInCondition
+            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
+          map { |k, v| k }
+        end
+
+        def values
+          map { |k, v| v }
+        end
+
+        def each
+          return unless defined?(@first) && @first
+          yield [@first.key, @first.value]
+          node = @first
+          yield [node.key, node.value] while node = node.next # rubocop:disable AssignmentInCondition
+          self
+        end
+
+        def merge(other)
+          hash = self.class.new
+
+          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/bundler/vendor/thor/lib/thor/error.rb

@@ -0,0 +1,32 @@
+class Bundler::Thor
+  # Bundler::Thor::Error is raised when it's caused by wrong usage of thor classes. Those
+  # errors have their backtrace suppressed and are nicely shown to the user.
+  #
+  # Errors that are caused by the developer, like declaring a method which
+  # overwrites a thor keyword, it SHOULD NOT raise a Bundler::Thor::Error. This way, we
+  # ensure that developer errors are shown with full backtrace.
+  class Error < StandardError
+  end
+
+  # Raised when a command was not found.
+  class UndefinedCommandError < Error
+  end
+  UndefinedTaskError = UndefinedCommandError # rubocop:disable ConstantName
+
+  class AmbiguousCommandError < Error
+  end
+  AmbiguousTaskError = AmbiguousCommandError # rubocop:disable ConstantName
+
+  # Raised when a command was found, but not invoked properly.
+  class InvocationError < Error
+  end
+
+  class UnknownArgumentError < Error
+  end
+
+  class RequiredArgumentMissingError < InvocationError
+  end
+
+  class MalformattedArgumentError < InvocationError
+  end
+end

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

@@ -0,0 +1,281 @@
+require "bundler/vendor/thor/lib/thor/base"
+
+# Bundler::Thor has a special class called Bundler::Thor::Group. The main difference to Bundler::Thor class
+# 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 Bundler::Thor
+# commands.
+class Bundler::Thor::Group # rubocop:disable ClassLength
+  class << self
+    # The description for this Bundler::Thor::Group. If none is provided, but a source root
+    # exists, tries to find the USAGE one folder above it, otherwise searches
+    # in the superclass.
+    #
+    # ==== Parameters
+    # description<String>:: The description for this Bundler::Thor::Group.
+    #
+    def desc(description = nil)
+      if description
+        @desc = description
+      else
+        @desc ||= from_superclass(:desc, nil)
+      end
+    end
+
+    # Prints help information.
+    #
+    # ==== Options
+    # short:: When true, shows only usage.
+    #
+    def help(shell)
+      shell.say "Usage:"
+      shell.say "  #{banner}\n"
+      shell.say
+      class_options_help(shell)
+      shell.say desc if desc
+    end
+
+    # Stores invocations for this class merging with superclass values.
+    #
+    def invocations #:nodoc:
+      @invocations ||= from_superclass(:invocations, {})
+    end
+
+    # Stores invocation blocks used on invoke_from_option.
+    #
+    def invocation_blocks #:nodoc:
+      @invocation_blocks ||= from_superclass(:invocation_blocks, {})
+    end
+
+    # Invoke the given namespace or class given. It adds an instance
+    # 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
+    # usage. Check invoke_from_option for more information.
+    #
+    def invoke(*names, &block) # rubocop:disable MethodLength
+      options = names.last.is_a?(Hash) ? names.pop : {}
+      verbose = options.fetch(:verbose, true)
+
+      names.each do |name|
+        invocations[name] = false
+        invocation_blocks[name] = block if block_given?
+
+        class_eval <<-METHOD, __FILE__, __LINE__
+          def _invoke_#{name.to_s.gsub(/\W/, "_")}
+            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, command, &block
+            else
+              say_status :error, %(#{name.inspect} [not found]), :red
+            end
+          end
+        METHOD
+      end
+    end
+
+    # Invoke a thor class based on the value supplied by the user to the
+    # given option named "name". A class option must be created before this
+    # method is invoked for each name given.
+    #
+    # ==== Examples
+    #
+    #   class GemGenerator < Bundler::Thor::Group
+    #     class_option :test_framework, :type => :string
+    #     invoke_from_option :test_framework
+    #   end
+    #
+    # ==== Boolean options
+    #
+    # In some cases, you want to invoke a thor class if some option is true or
+    # false. This is automatically handled by invoke_from_option. Then the
+    # option name is used to invoke the generator.
+    #
+    # ==== Preparing for invocation
+    #
+    # 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 command.
+    #
+    # ==== Custom invocations
+    #
+    # You can also supply a block to customize how the option is going to be
+    # invoked. The block receives two parameters, an instance of the current
+    # class and the klass to be invoked.
+    #
+    def invoke_from_option(*names, &block) # rubocop:disable MethodLength
+      options = names.last.is_a?(Hash) ? names.pop : {}
+      verbose = options.fetch(:verbose, :white)
+
+      names.each do |name|
+        unless class_options.key?(name)
+          fail ArgumentError, "You have to define the option #{name.inspect} " <<
+                               "before setting invoke_from_option."
+        end
+
+        invocations[name] = true
+        invocation_blocks[name] = block if block_given?
+
+        class_eval <<-METHOD, __FILE__, __LINE__
+          def _invoke_from_option_#{name.to_s.gsub(/\W/, "_")}
+            return unless options[#{name.inspect}]
+
+            value = options[#{name.inspect}]
+            value = #{name.inspect} if TrueClass === 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, command, &block
+            else
+              say_status :error, %(\#{value} [not found]), :red
+            end
+          end
+        METHOD
+      end
+    end
+
+    # Remove a previously added invocation.
+    #
+    # ==== Examples
+    #
+    #   remove_invocation :test_framework
+    #
+    def remove_invocation(*names)
+      names.each do |name|
+        remove_command(name)
+        remove_class_option(name)
+        invocations.delete(name)
+        invocation_blocks.delete(name)
+      end
+    end
+
+    # Overwrite class options help to allow invoked generators options to be
+    # shown recursively when invoking a generator.
+    #
+    def class_options_help(shell, groups = {}) #:nodoc:
+      get_options_from_invocations(groups, class_options) do |klass|
+        klass.send(:get_options_from_invocations, groups, class_options)
+      end
+      super(shell, groups)
+    end
+
+    # Get invocations array and merge options from invocations. Those
+    # options are added to group_options hash. Options that already exists
+    # in base_options are not added twice.
+    #
+    def get_options_from_invocations(group_options, base_options) #:nodoc: # rubocop:disable MethodLength
+      invocations.each do |name, from_option|
+        value = if from_option
+          option = class_options[name]
+          option.type == :boolean ? name : option.default
+        else
+          name
+        end
+        next unless value
+
+        klass, _ = prepare_for_invocation(name, value)
+        next unless klass && klass.respond_to?(:class_options)
+
+        value = value.to_s
+        human_name = value.respond_to?(:classify) ? value.classify : value
+
+        group_options[human_name] ||= []
+        group_options[human_name] += klass.class_options.values.select do |class_option|
+          base_options[class_option.name.to_sym].nil? && class_option.group.nil? &&
+          !group_options.values.flatten.any? { |i| i.name == class_option.name }
+        end
+
+        yield klass if block_given?
+      end
+    end
+
+    # Returns commands ready to be printed.
+    def printable_commands(*)
+      item = []
+      item << banner
+      item << (desc ? "# #{desc.gsub(/\s+/m, ' ')}" : "")
+      [item]
+    end
+    alias_method :printable_tasks, :printable_commands
+
+    def handle_argument_error(command, error, args, arity) #:nodoc:
+      msg = "#{basename} #{command.name} takes #{arity} argument"
+      msg << "s" if arity > 1
+      msg << ", but it should not."
+      fail error, msg
+    end
+
+  protected
+
+    # The method responsible for dispatching given the args.
+    def dispatch(command, given_args, given_opts, config) #:nodoc:
+      if Bundler::Thor::HELP_MAPPINGS.include?(given_args.first)
+        help(config[:shell])
+        return
+      end
+
+      args, opts = Bundler::Thor::Options.split(given_args)
+      opts = given_opts || opts
+
+      instance = new(args, opts, config)
+      yield instance if block_given?
+
+      if command
+        instance.invoke_command(all_commands[command])
+      else
+        instance.invoke_all
+      end
+    end
+
+    # The banner for this class. You can customize it if you are invoking the
+    # thor class by another ways which is not the Bundler::Thor::Runner.
+    def banner
+      "#{basename} #{self_command.formatted_usage(self, false)}"
+    end
+
+    # Represents the whole class as a command.
+    def self_command #:nodoc:
+      Bundler::Thor::DynamicCommand.new(namespace, class_options)
+    end
+    alias_method :self_task, :self_command
+
+    def baseclass #:nodoc:
+      Bundler::Thor::Group
+    end
+
+    def create_command(meth) #:nodoc:
+      commands[meth.to_s] = Bundler::Thor::Command.new(meth, nil, nil, nil, nil)
+      true
+    end
+    alias_method :create_task, :create_command
+  end
+
+  include Bundler::Thor::Base
+
+protected
+
+  # Shortcut to invoke with padding and block handling. Use internally by
+  # invoke and invoke_from_option class methods.
+  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, command)
+        when 2
+          block.call(self, klass)
+        when 1
+          instance_exec(klass, &block)
+        end
+      else
+        invoke klass, command, *args
+      end
+    end
+  end
+end