gameboard 3.1.0 → 3.2.0

data/vendor/bundle/ruby/2.3.0/gems/pry-0.10.4/lib/pry/method/disowned.rb

@@ -1,53 +0,0 @@
-class Pry
-  class Method
-    # A Disowned Method is one that's been removed from the class on which it was defined.
-    #
-    # e.g.
-    # class C
-    #   def foo
-    #     C.send(:undefine_method, :foo)
-    #     Pry::Method.from_binding(binding)
-    #   end
-    # end
-    #
-    # In this case we assume that the "owner" is the singleton class of the receiver.
-    #
-    # This occurs mainly in Sinatra applications.
-    class Disowned < Method
-      attr_reader :receiver, :name
-
-      # Create a new Disowned method.
-      #
-      # @param [Object] receiver
-      # @param [String] method_name
-      def initialize(receiver, method_name, binding=nil)
-        @receiver, @name = receiver, method_name
-      end
-
-      # Is the method undefined? (aka `Disowned`)
-      # @return [Boolean] true
-      def undefined?
-        true
-      end
-
-      # Can we get the source for this method?
-      # @return [Boolean] false
-      def source?
-        false
-      end
-
-      # Get the hypothesized owner of the method.
-      #
-      # @return [Object]
-      def owner
-        class << receiver; self; end
-      end
-
-      # Raise a more useful error message instead of trying to forward to nil.
-      def method_missing(meth_name, *args, &block)
-        raise "Cannot call '#{meth_name}' on an undef'd method." if method(:name).respond_to?(meth_name)
-        Object.instance_method(:method_missing).bind(self).call(meth_name, *args, &block)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/pry-0.10.4/lib/pry/method/patcher.rb

@@ -1,125 +0,0 @@
-class Pry
-  class Method
-    class Patcher
-      attr_accessor :method
-
-      @@source_cache = {}
-
-      def initialize(method)
-        @method = method
-      end
-
-      def self.code_for(filename)
-        @@source_cache[filename]
-      end
-
-      # perform the patch
-      def patch_in_ram(source)
-        if method.alias?
-          with_method_transaction do
-            redefine source
-          end
-        else
-          redefine source
-        end
-      end
-
-      private
-
-      def redefine(source)
-        @@source_cache[cache_key] = source
-        TOPLEVEL_BINDING.eval wrap(source), cache_key
-      end
-
-      def cache_key
-        "pry-redefined(0x#{method.owner.object_id.to_s(16)}##{method.name})"
-      end
-
-      # Run some code ensuring that at the end target#meth_name will not have changed.
-      #
-      # When we're redefining aliased methods we will overwrite the method at the
-      # unaliased name (so that super continues to work). By wrapping that code in a
-      # transation we make that not happen, which means that alias_method_chains, etc.
-      # continue to work.
-      #
-      # @param [String] meth_name  The method name before aliasing
-      # @param [Module] target  The owner of the method
-
-      def with_method_transaction
-        temp_name = "__pry_#{method.original_name}__"
-        method = self.method
-        method.owner.class_eval do
-          alias_method temp_name, method.original_name
-          yield
-          alias_method method.name, method.original_name
-          alias_method method.original_name, temp_name
-        end
-
-      ensure
-        method.send(:remove_method, temp_name) rescue nil
-      end
-
-      # Update the definition line so that it can be eval'd directly on the Method's
-      # owner instead of from the original context.
-      #
-      # In particular this takes `def self.foo` and turns it into `def foo` so that we
-      # don't end up creating the method on the singleton class of the singleton class
-      # by accident.
-      #
-      # This is necessarily done by String manipulation because we can't find out what
-      # syntax is needed for the argument list by ruby-level introspection.
-      #
-      # @param [String] line The original definition line. e.g. def self.foo(bar, baz=1)
-      # @return [String]  The new definition line. e.g. def foo(bar, baz=1)
-      def definition_for_owner(line)
-        if line =~ /\Adef (?:.*?\.)?#{Regexp.escape(method.original_name)}(?=[\(\s;]|$)/
-          "def #{method.original_name}#{$'}"
-        else
-          raise CommandError, "Could not find original `def #{method.original_name}` line to patch."
-        end
-      end
-
-      # Apply wrap_for_owner and wrap_for_nesting successively to `source`
-      # @param [String] source
-      # @return [String] The wrapped source.
-      def wrap(source)
-        wrap_for_nesting(wrap_for_owner(source))
-      end
-
-      # Update the source code so that when it has the right owner when eval'd.
-      #
-      # This (combined with definition_for_owner) is backup for the case that
-      # wrap_for_nesting fails, to ensure that the method will stil be defined in
-      # the correct place.
-      #
-      # @param [String] source  The source to wrap
-      # @return [String]
-      def wrap_for_owner(source)
-        Pry.current[:pry_owner] = method.owner
-        owner_source = definition_for_owner(source)
-        visibility_fix = "#{method.visibility.to_s} #{method.name.to_sym.inspect}"
-        "Pry.current[:pry_owner].class_eval do; #{owner_source}\n#{visibility_fix}\nend"
-      end
-
-      # Update the new source code to have the correct Module.nesting.
-      #
-      # This method uses syntactic analysis of the original source file to determine
-      # the new nesting, so that we can tell the difference between:
-      #
-      #   class A; def self.b; end; end
-      #   class << A; def b; end; end
-      #
-      # The resulting code should be evaluated in the TOPLEVEL_BINDING.
-      #
-      # @param [String] source  The source to wrap.
-      # @return [String]
-      def wrap_for_nesting(source)
-        nesting = Pry::Code.from_file(method.source_file).nesting_at(method.source_line)
-
-        (nesting + [source] + nesting.map{ "end" } + [""]).join(";")
-      rescue Pry::Indent::UnparseableNestingError
-        source
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/pry-0.10.4/lib/pry/method/weird_method_locator.rb

@@ -1,188 +0,0 @@
-class Pry
-  class Method
-
-    # This class is responsible for locating the *real* `Pry::Method`
-    # object captured by a binding.
-    #
-    # Given a `Binding` from inside a method and a 'seed' Pry::Method object,
-    # there are primarily two situations where the seed method doesn't match
-    # the Binding:
-    # 1. The Pry::Method is from a subclass 2. The Pry::Method represents a method of the same name
-    # while the original was renamed to something else. For 1. we
-    # search vertically up the inheritance chain,
-    # and for 2. we search laterally along the object's method table.
-    #
-    # When we locate the method that matches the Binding we wrap it in
-    # Pry::Method and return it, or return nil if we fail.
-    class WeirdMethodLocator
-      class << self
-
-        # Whether the given method object matches the associated binding.
-        # If the method object does not match the binding, then it's
-        # most likely not the method captured by the binding, and we
-        # must commence a search.
-        #
-        # @param [Pry::Method] method
-        # @param [Binding] b
-        # @return [Boolean]
-        def normal_method?(method, b)
-          method && (method.source_file && method.source_range rescue false) &&
-          File.expand_path(method.source_file) == File.expand_path(b.eval('__FILE__')) &&
-          method.source_range.include?(b.eval('__LINE__'))
-        end
-
-        def weird_method?(method, b)
-          !normal_method?(method, b)
-        end
-      end
-
-      attr_accessor :method
-      attr_accessor :target
-
-      # @param [Pry::Method] method The seed method.
-      # @param [Binding] target The Binding that captures the method
-      #   we want to locate.
-      def initialize(method, target)
-        @method, @target = method, target
-      end
-
-      # @return [Pry::Method, nil] The Pry::Method that matches the
-      #   given binding.
-      def get_method
-        find_method_in_superclass || find_renamed_method
-      end
-
-      # @return [Boolean] Whether the Pry::Method is unrecoverable
-      #   This usually happens when the method captured by the Binding
-      #   has been subsequently deleted.
-      def lost_method?
-        !!(get_method.nil? && renamed_method_source_location)
-      end
-
-      private
-
-      def normal_method?(method)
-        self.class.normal_method?(method, target)
-      end
-
-      def target_self
-        target.eval('self')
-      end
-
-      def target_file
-        pry_file? ? target.eval('__FILE__') : File.expand_path(target.eval('__FILE__'))
-      end
-
-      def target_line
-        target.eval('__LINE__')
-      end
-
-      def pry_file?
-        Pry.eval_path == target.eval('__FILE__')
-      end
-
-      # it's possible in some cases that the method we find by this approach is a sub-method of
-      # the one we're currently in, consider:
-      #
-      # class A; def b; binding.pry; end; end
-      # class B < A; def b; super; end; end
-      #
-      # Given that we can normally find the source_range of methods, and that we know which
-      # __FILE__ and __LINE__ the binding is at, we can hope to disambiguate these cases.
-      #
-      # This obviously won't work if the source is unavaiable for some reason, or if both
-      # methods have the same __FILE__ and __LINE__, or if we're in rbx where b.eval('__LINE__')
-      # is broken.
-      #
-      # @return [Pry::Method, nil] The Pry::Method representing the
-      #   superclass method.
-      def find_method_in_superclass
-        guess = method
-
-        while guess
-          # needs rescue if this is a Disowned method or a C method or something...
-          # TODO: Fix up the exception handling so we don't need a bare rescue
-          if normal_method?(guess)
-            return guess
-          elsif guess != guess.super
-            guess = guess.super
-          else
-            break
-          end
-        end
-
-        # Uhoh... none of the methods in the chain had the right __FILE__ and __LINE__
-        # This may be caused by rbx https://github.com/rubinius/rubinius/issues/953,
-        # or other unknown circumstances (TODO: we should warn the user when this happens)
-        nil
-      end
-
-      # This is the case where the name of a method has changed
-      # (via alias_method) so we locate the Method object for the
-      # renamed method.
-      #
-      # @return [Pry::Method, nil] The Pry::Method representing the
-      #   renamed method
-      def find_renamed_method
-        return if !valid_file?(target_file)
-        alias_name = all_methods_for(target_self).find do |v|
-          expanded_source_location(target_self.method(v).source_location) == renamed_method_source_location
-        end
-
-        alias_name && Pry::Method(target_self.method(alias_name))
-      end
-
-      def expanded_source_location(sl)
-        return if !sl
-
-        if pry_file?
-          sl
-        else
-          [File.expand_path(sl.first), sl.last]
-        end
-      end
-
-      # Use static analysis to locate the start of the method definition.
-      # We have the `__FILE__` and `__LINE__` from the binding and the
-      # original name of the method so we search up until we find a
-      # def/define_method, etc defining a method of the appropriate name.
-      #
-      # @return [Array<String, Fixnum>] The `source_location` of the
-      #   renamed method
-      def renamed_method_source_location
-        return @original_method_source_location if defined?(@original_method_source_location)
-
-        source_index = lines_for_file(target_file)[0..(target_line - 1)].rindex do |v|
-          Pry::Method.method_definition?(method.name, v)
-        end
-
-        @original_method_source_location = source_index &&
-          [target_file, index_to_line_number(source_index)]
-      end
-
-      def index_to_line_number(index)
-        # Pry.line_buffer is 0-indexed
-        pry_file? ? index : index + 1
-      end
-
-      def valid_file?(file)
-        (File.exist?(file) && !File.directory?(file)) || Pry.eval_path == file
-      end
-
-      def lines_for_file(file)
-        @lines_for_file ||= {}
-        @lines_for_file[file] ||= if Pry.eval_path == file
-                                    Pry.line_buffer
-                                  else
-                                    File.readlines(file)
-                                  end
-      end
-
-      def all_methods_for(obj)
-        obj.public_methods(false) +
-          obj.private_methods(false) +
-          obj.protected_methods(false)
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.3.0/gems/pry-0.10.4/lib/pry/module_candidate.rb

@@ -1,137 +0,0 @@
-require 'pry/helpers/documentation_helpers'
-require 'forwardable'
-
-class Pry
-  class WrappedModule
-
-    # This class represents a single candidate for a module/class definition.
-    # It provides access to the source, documentation, line and file
-    # for a monkeypatch (reopening) of a class/module.
-    class Candidate
-      include Pry::Helpers::DocumentationHelpers
-      include Pry::CodeObject::Helpers
-      extend Forwardable
-
-      # @return [String] The file where the module definition is located.
-      attr_reader :file
-      alias_method :source_file, :file
-
-      # @return [Fixnum] The line where the module definition is located.
-      attr_reader :line
-      alias_method :source_line, :line
-
-      # Methods to delegate to associated `Pry::WrappedModule
-      # instance`.
-      private_delegates = [:lines_for_file, :method_candidates,
-                           :yard_docs?]
-
-      public_delegates = [:wrapped, :module?, :class?, :name, :nonblank_name,
-                          :number_of_candidates]
-
-      def_delegators :@wrapper, *(private_delegates + public_delegates)
-      private(*private_delegates)
-      public(*public_delegates)
-
-      # @raise [Pry::CommandError] If `rank` is out of bounds.
-      # @param [Pry::WrappedModule] wrapper The associated
-      #   `Pry::WrappedModule` instance that owns the candidates.
-      # @param [Fixnum] rank The rank of the candidate to
-      #   retrieve. Passing 0 returns 'primary candidate' (the candidate with largest
-      #   number of methods), passing 1 retrieves candidate with
-      #   second largest number of methods, and so on, up to
-      #   `Pry::WrappedModule#number_of_candidates() - 1`
-      def initialize(wrapper, rank)
-        @wrapper = wrapper
-
-        if number_of_candidates <= 0
-          raise CommandError, "Cannot find a definition for #{name} module!"
-        elsif rank > (number_of_candidates - 1)
-          raise CommandError, "No such module candidate. Allowed candidates range is from 0 to #{number_of_candidates - 1}"
-        end
-
-        @source = @source_location = nil
-        @rank = rank
-        @file, @line = source_location
-      end
-
-      # @raise [Pry::CommandError] If source code cannot be found.
-      # @return [String] The source for the candidate, i.e the
-      #   complete module/class definition.
-      def source
-        return nil if file.nil?
-        return @source if @source
-
-        @source = strip_leading_whitespace(Pry::Code.from_file(file).expression_at(line, number_of_lines_in_first_chunk))
-      end
-
-      # @raise [Pry::CommandError] If documentation cannot be found.
-      # @return [String] The documentation for the candidate.
-      def doc
-        return nil if file.nil?
-        return @doc if @doc
-
-        @doc = get_comment_content(Pry::Code.from_file(file).comment_describing(line))
-      end
-
-      # @return [Array, nil] A `[String, Fixnum]` pair representing the
-      #   source location (file and line) for the candidate or `nil`
-      #   if no source location found.
-      def source_location
-        return @source_location if @source_location
-
-        file, line = first_method_source_location
-        return nil if !file.is_a?(String)
-
-        @source_location = [file,  first_line_of_module_definition(file, line)]
-      rescue Pry::RescuableException
-        nil
-      end
-
-      private
-
-      # Locate the first line of the module definition.
-      # @param [String] file The file that contains the module
-      #   definition (somewhere).
-      # @param [Fixnum] line The module definition should appear
-      #   before this line (if it exists).
-      # @return [Fixnum] The line where the module is defined. This
-      #   line number is one-indexed.
-      def first_line_of_module_definition(file, line)
-        searchable_lines = lines_for_file(file)[0..(line - 2)]
-        searchable_lines.rindex { |v| class_regexes.any? { |r| r =~ v } } + 1
-      end
-
-      def class_regexes
-        mod_type_string = wrapped.class.to_s.downcase
-        [/^\s*#{mod_type_string}\s+(?:(?:\w*)::)*?#{wrapped.name.split(/::/).last}/,
-         /^\s*(::)?#{wrapped.name.split(/::/).last}\s*?=\s*?#{wrapped.class}/,
-         /^\s*(::)?#{wrapped.name.split(/::/).last}\.(class|instance)_eval/]
-      end
-
-      # This method is used by `Candidate#source_location` as a
-      # starting point for the search for the candidate's definition.
-      # @return [Array] The source location of the base method used to
-      #   calculate the source location of the candidate.
-      def first_method_source_location
-        @first_method_source_location ||= method_candidates[@rank].first.source_location
-      end
-
-      # @return [Array] The source location of the last method in this
-      #   candidate's module definition.
-      def last_method_source_location
-        @end_method_source_location ||= method_candidates[@rank].last.source_location
-      end
-
-      # Return the number of lines between the start of the class definition
-      # and the start of the last method. We use this value so we can
-      # quickly grab these lines from the file (without having to
-      # check each intervening line for validity, which is expensive) speeding up source extraction.
-      # @return [Fixum] Number of lines.
-      def number_of_lines_in_first_chunk
-        end_method_line = last_method_source_location.last
-
-        end_method_line - line
-      end
-    end
-  end
-end