pry 0.10.2-i386-mingw32 → 1.0.0.pre1-i386-mingw32

data/lib/pry/code.rb

@@ -1,6 +1,5 @@
 require 'pry/code/loc'
 require 'pry/code/code_range'
-require 'pry/code/code_file'
 
 class Pry
   class << self
@@ -30,6 +29,26 @@ class Pry
   # arbitrary chaining of formatting methods without mutating the original
   # object.
   class Code
+
+    # List of all supported languages.
+    # @return [Hash]
+    EXTENSIONS = {
+      %w(.py)        => :python,
+      %w(.js)        => :javascript,
+      %w(.css)       => :css,
+      %w(.xml)       => :xml,
+      %w(.php)       => :php,
+      %w(.html)      => :html,
+      %w(.diff)      => :diff,
+      %w(.java)      => :java,
+      %w(.json)      => :json,
+      %w(.c .h)      => :c,
+      %w(.rhtml)     => :rhtml,
+      %w(.yaml .yml) => :yaml,
+      %w(.cpp .hpp .cc .h cxx) => :cpp,
+      %w(.rb .ru .irbrc .gemspec .pryrc) => :ruby,
+    }
+
     class << self
       include MethodSource::CodeHelpers
 
@@ -39,9 +58,13 @@ class Pry
       # @param [String] filename The name of a file, or "(pry)".
       # @param [Symbol] code_type The type of code the file contains.
       # @return [Code]
-      def from_file(filename, code_type = nil)
-        code_file = CodeFile.new(filename, code_type)
-        new(code_file.code, 1, code_file.code_type)
+      def from_file(filename, code_type = type_from_filename(filename))
+        code = if filename == Pry.eval_path
+                 Pry.line_buffer.drop(1)
+               else
+                 File.read(abs_path(filename))
+               end
+        new(code, 1, code_type)
       end
 
       # Instantiate a `Code` object containing code extracted from a
@@ -71,6 +94,35 @@ class Pry
         start_line ||= candidate.line
         new(candidate.source, start_line, :ruby)
       end
+
+      protected
+
+      # Guess the CodeRay type of a file from its extension, or nil if
+      # unknown.
+      #
+      # @param [String] filename
+      # @param [Symbol] default (:ruby) the file type to assume if none could be
+      #   detected.
+      # @return [Symbol, nil]
+      def type_from_filename(filename, default = :ruby)
+        _, type = Pry::Code::EXTENSIONS.find do |k, _|
+          k.any? { |ext| ext == File.extname(filename) }
+        end
+
+        type || default
+      end
+
+      # @param [String] filename
+      # @raise [MethodSource::SourceNotFoundError] if the +filename+ is not
+      #   readable for some reason.
+      # @return [String] absolute path for the given +filename+.
+      def abs_path(filename)
+        abs_path = [File.expand_path(filename, Dir.pwd),
+                    File.expand_path(filename, Pry::INITIAL_PWD)
+                   ].detect { |path| File.readable?(path) }
+        abs_path or raise MethodSource::SourceNotFoundError,
+                          "Cannot open #{filename.inspect} for reading."
+      end
     end
 
     # @return [Symbol] The type of code stored in this wrapper.
@@ -145,7 +197,7 @@ class Pry
         if start_line >= 0
           @lines.index { |loc| loc.lineno >= start_line } || @lines.length
         else
-          [@lines.length + start_line, 0].max
+          @lines.length + start_line
         end
 
       alter do
@@ -253,27 +305,14 @@ class Pry
     # @return [String] a formatted representation (based on the configuration of
     #   the object).
     def to_s
-      print_to_output("", false)
-    end
-
-    # @return [String] a (possibly highlighted) copy of the source code.
-    def highlighted
-      print_to_output("", true)
-    end
-
-    # Writes a formatted representation (based on the configuration of the
-    # object) to the given output, which must respond to `#<<`.
-    def print_to_output(output, color=false)
-      @lines.each do |loc|
+      @lines.map { |loc|
         loc = loc.dup
-        loc.colorize(@code_type)              if color
-        loc.add_line_number(max_lineno_width, color) if @with_line_numbers
+        loc.colorize(@code_type)              if Pry.color
+        loc.add_line_number(max_lineno_width) if @with_line_numbers
         loc.add_marker(@marker_lineno)        if @with_marker
         loc.indent(@indentation_num)          if @with_indentation
-        output << loc.line
-        output << "\n"
-      end
-      output
+        loc.line
+      }.join("\n") + "\n"
     end
 
     # Get the comment that describes the expression on the given line number.
@@ -305,7 +344,7 @@ class Pry
     #
     # @return [String]
     def raw
-      @lines.map(&:line).join("\n") << "\n"
+      @lines.map(&:line).join("\n") + "\n"
     end
 
     # Return the number of lines stored.

data/lib/pry/code/loc.rb

@@ -59,9 +59,9 @@ class Pry
       #
       # @param [Integer] max_width
       # @return [void]
-      def add_line_number(max_width = 0, color = false)
+      def add_line_number(max_width = 0)
         padded = lineno.to_s.rjust(max_width)
-        colorized_lineno = color ? Pry::Helpers::BaseHelpers.colorize_code(padded) : padded
+        colorized_lineno = Pry::Helpers::BaseHelpers.colorize_code(padded)
         tuple[0] = "#{ colorized_lineno }: #{ line }"
       end
 

data/lib/pry/code_object.rb

@@ -1,23 +1,4 @@
 class Pry
-
-  # This class is responsible for taking a string (identifying a
-  # command/class/method/etc) and returning the relevant type of object.
-  # For example, if the user looks up "show-source" then  a
-  # `Pry::Command` will be returned. Alternatively, if the user passes in "Pry#repl" then
-  # a `Pry::Method` object will be returned.
-  #
-  # The `CodeObject.lookup` method is responsible for 1. figuring out what kind of
-  # object the user wants (applying precedence rules in doing so -- i.e methods
-  # get precedence over commands with the same name) and 2. Returning
-  # the appropriate object. If the user fails to provide a string
-  # identifer for the object (i.e they pass in `nil` or "") then the
-  # object looked up will be the 'current method' or 'current class'
-  # associated with the Binding.
-  #
-  # TODO: This class is a clusterfuck. We need a much more robust
-  # concept of what a "Code Object" really is. Currently
-  # commands/classes/candidates/methods and so on just share a very
-  # ill-defined interface.
   class CodeObject
     module Helpers
       # we need this helper as some Pry::Method objects can wrap Procs
@@ -52,7 +33,7 @@ class Pry
 
     attr_accessor :str
     attr_accessor :target
-    attr_accessor :_pry_
+    attr_accessor :pry
     attr_accessor :super_level
 
     def initialize(str, _pry_, options={})
@@ -61,7 +42,7 @@ class Pry
       }.merge!(options)
 
       @str = str
-      @_pry_ = _pry_
+      @pry = _pry_
       @target = _pry_.current_context
       @super_level = options[:super]
     end
@@ -69,24 +50,18 @@ class Pry
     def command_lookup
       # TODO: just make it so find_command_by_match_or_listing doesn't
       # raise?
-      _pry_.commands.find_command_by_match_or_listing(str) rescue nil
+      pry.commands.find_command_by_match_or_listing(str) rescue nil
     end
 
-    # when no paramter is given (i.e CodeObject.lookup(nil)), then we
-    # lookup the 'current object' from the binding.
     def empty_lookup
       return nil if str && !str.empty?
 
-      obj = if internal_binding?(target)
-              mod = target_self.is_a?(Module) ? target_self : target_self.class
-              Pry::WrappedModule(mod)
-            else
-              Pry::Method.from_binding(target)
-            end
-
-      # respect the super level (i.e user might have specified a
-      # --super flag to show-source)
-      lookup_super(obj, super_level)
+      if internal_binding?(target)
+        mod = target_self.is_a?(Module) ? target_self : target_self.class
+        Pry::WrappedModule(mod)
+      else
+        Pry::Method.from_binding(target)
+      end
     end
 
     # lookup variables and constants and `self` that are not modules
@@ -112,12 +87,17 @@ class Pry
     end
 
     def method_or_class_lookup
-      obj = case str
-            when /\S+\(\)\z/
-              Pry::Method.from_str(str.sub(/\(\)\z/, ''),target) || Pry::WrappedModule.from_str(str, target)
-            else
-              Pry::WrappedModule.from_str(str,target) || Pry::Method.from_str(str, target)
-            end
+      # we need this here because stupid Pry::Method.from_str() does a
+      # Pry::Method.from_binding when str is nil.
+      # Once we refactor Pry::Method.from_str() so it doesnt lookup
+      # from bindings, we can get rid of this check
+      return nil if str.to_s.empty?
+
+      obj = if str =~ /::(?:\S+)\Z/
+        Pry::WrappedModule.from_str(str,target) || Pry::Method.from_str(str, target)
+      else
+        Pry::Method.from_str(str,target) || Pry::WrappedModule.from_str(str, target)
+      end
 
       lookup_super(obj, super_level)
     end
@@ -128,6 +108,7 @@ class Pry
       [::Proc, ::Method, ::UnboundMethod].any? { |o| obj.is_a?(o) }
     end
 
+
     # Returns true if `str` looks like a method, i.e Klass#method
     # We need to consider this case because method lookups should fall
     # through to the `method_or_class_lookup()` method but a

data/lib/pry/command.rb

@@ -175,7 +175,7 @@ class Pry
       end
 
       def command_regex
-        pr = Pry.respond_to?(:config) ? Pry.config.command_prefix : ""
+        pr = defined?(Pry.config.command_prefix) ? Pry.config.command_prefix : ""
         prefix = convert_to_regex(pr)
         prefix = "(?:#{prefix})?" unless options[:use_prefix]
 
@@ -194,7 +194,6 @@ class Pry
       # The group in which the command should be displayed in "help" output.
       # This is usually auto-generated from directory naming, but it can be
       # manually overridden if necessary.
-      # Group should not be changed once it is initialized.
       def group(name=nil)
         @group ||= if name
                      name
@@ -243,13 +242,12 @@ class Pry
     # @example
     #   run "amend-line",  "5", 'puts "hello world"'
     def run(command_string, *args)
-      command_string = _pry_.config.command_prefix.to_s + command_string
       complete_string = "#{command_string} #{args.join(" ")}".rstrip
       command_set.process_line(complete_string, context)
     end
 
     def commands
-      command_set.to_hash
+      command_set.commands
     end
 
     def text
@@ -285,7 +283,7 @@ class Pry
     #   state.my_state = "my state"  # this will not conflict with any
     #                                # `state.my_state` used in another command.
     def state
-      _pry_.command_state[match] ||= Pry::Config.from_hash({})
+      _pry_.command_state[match] ||= OpenStruct.new
     end
 
     # Revaluate the string (str) and perform interpolation.
@@ -309,7 +307,8 @@ class Pry
       collision_type ||= 'local-variable' if arg_string.match(%r{\A\s*[-+*/%&|^]*=})
 
       if collision_type
-        output.puts "#{text.bold('WARNING:')} Calling Pry command '#{command_match}', which conflicts with a #{collision_type}.\n\n"
+        output.puts "#{text.bold('WARNING:')} Calling Pry command '#{command_match}'," +
+                                                          "which conflicts with a #{collision_type}.\n\n"
       end
     rescue Pry::RescuableException
     end
@@ -439,9 +438,7 @@ class Pry
     #
     # @param [String] search  The line typed so far
     # @return [Array<String>]  Completion words
-    def complete(search)
-      []
-    end
+    def complete(search); Bond::DefaultMission.completions; end
 
     private
 

data/lib/pry/command_set.rb

@@ -10,15 +10,19 @@ class Pry
   class CommandSet
     include Enumerable
     include Pry::Helpers::BaseHelpers
+
+    attr_reader :commands
     attr_reader :helper_module
 
-    # @param [Array<Commandset>] imported_sets
-    #   Sets which will be imported automatically
+    # @param [Array<CommandSet>] imported_sets Sets which will be imported
+    #   automatically
     # @yield Optional block run to define commands
     def initialize(*imported_sets, &block)
       @commands      = {}
       @helper_module = Module.new
+
       import(*imported_sets)
+
       instance_eval(&block) if block
     end
 
@@ -79,7 +83,7 @@ class Pry
       description, options = ["No description.", description] if description.is_a?(Hash)
       options = Pry::Command.default_options(match).merge!(options)
 
-      @commands[match] = Pry::BlockCommand.subclass(match, description, options, helper_module, &block)
+      commands[match] = Pry::BlockCommand.subclass(match, description, options, helper_module, &block)
     end
     alias_method :command, :block_command
 
@@ -111,9 +115,9 @@ class Pry
       description, options = ["No description.", description] if description.is_a?(Hash)
       options = Pry::Command.default_options(match).merge!(options)
 
-      @commands[match] = Pry::ClassCommand.subclass(match, description, options, helper_module, &block)
-      @commands[match].class_eval(&block)
-      @commands[match]
+      commands[match] = Pry::ClassCommand.subclass(match, description, options, helper_module, &block)
+      commands[match].class_eval(&block)
+      commands[match]
     end
 
     # Execute a block of code before a command is invoked. The block also
@@ -122,7 +126,7 @@ class Pry
     # @param [String, Regexp] search The match or listing of the command.
     # @yield The block to be run before the command.
     # @example Display parameter before invoking command
-    #   Pry.config.commands.before_command("whereami") do |n|
+    #   Pry.commands.before_command("whereami") do |n|
     #     output.puts "parameter passed was #{n}"
     #   end
     def before_command(search, &block)
@@ -136,7 +140,7 @@ class Pry
     # @param [String, Regexp] search The match or listing of the command.
     # @yield The block to be run after the command.
     # @example Display text 'command complete' after invoking command
-    #   Pry.config.commands.after_command("whereami") do |n|
+    #   Pry.commands.after_command("whereami") do |n|
     #     output.puts "command complete!"
     #   end
     def after_command(search, &block)
@@ -148,12 +152,18 @@ class Pry
       @commands.each(&block)
     end
 
+    # Add a given command object to this set.
+    # @param [Command] command The subclass of Pry::Command you wish to add.
+    def add_command(command)
+      commands[command.match] = command
+    end
+
     # Removes some commands from the set
     # @param [Array<String>] searches the matches or listings of the commands to remove
     def delete(*searches)
       searches.each do |search|
         cmd = find_command_by_match_or_listing(search)
-        @commands.delete cmd.match
+        commands.delete cmd.match
       end
     end
 
@@ -163,7 +173,7 @@ class Pry
     # @return [Pry::CommandSet] Returns the reciever (a command set).
     def import(*sets)
       sets.each do |set|
-        @commands.merge! set.to_hash
+        commands.merge! set.commands
         helper_module.send :include, set.helper_module
       end
       self
@@ -177,7 +187,7 @@ class Pry
       helper_module.send :include, set.helper_module
       matches.each do |match|
         cmd = set.find_command_by_match_or_listing(match)
-        @commands[cmd.match] = cmd
+        commands[cmd.match] = cmd
       end
       self
     end
@@ -186,8 +196,8 @@ class Pry
     #   of the command to retrieve.
     # @return [Command] The command object matched.
     def find_command_by_match_or_listing(match_or_listing)
-      cmd = (@commands[match_or_listing] ||
-        Pry::Helpers::BaseHelpers.find_command(match_or_listing, @commands))
+      cmd = (commands[match_or_listing] ||
+        Pry::Helpers::BaseHelpers.find_command(match_or_listing, commands))
       cmd or raise ArgumentError, "Cannot find a command: '#{match_or_listing}'!"
     end
 
@@ -246,11 +256,11 @@ class Pry
         :description => cmd.description
       }.merge!(options)
 
-      @commands[new_match] = cmd.dup
-      @commands[new_match].match = new_match
-      @commands[new_match].description = options.delete(:description)
-      @commands[new_match].options.merge!(options)
-      @commands.delete(cmd.match)
+      commands[new_match] = cmd.dup
+      commands[new_match].match = new_match
+      commands[new_match].description = options.delete(:description)
+      commands[new_match].options.merge!(options)
+      commands.delete(cmd.match)
     end
 
     def disabled_command(name_of_disabled_command, message, matcher=name_of_disabled_command)
@@ -299,71 +309,18 @@ class Pry
     end
 
 
-    # @return [Array]
-    #   The list of commands provided by the command set.
+    # @return [Array] The list of commands provided by the command set.
     def list_commands
-      @commands.keys
-    end
-    alias_method :keys, :list_commands
-
-    def to_hash
-      @commands.dup
+      commands.keys
     end
-    alias_method :to_h, :to_hash
 
     # Find a command that matches the given line
-    # @param [String] pattern The line that might be a command invocation
+    # @param [String] val The line that might be a command invocation
     # @return [Pry::Command, nil]
-    def [](pattern)
-      @commands.values.select do |command|
-        command.matches?(pattern)
-      end.sort_by do |command|
-        command.match_score(pattern)
-      end.last
-    end
-    alias_method :find_command, :[]
-
-    #
-    # Re-assign the command found at _pattern_ with _command_.
-    #
-    # @param [Regexp, String] pattern
-    #   The command to add or replace(found at _pattern_).
-    #
-    # @param [Pry::Command] command
-    #   The command to add.
-    #
-    # @return [Pry::Command]
-    #   Returns the new command (matched with "pattern".)
-    #
-    # @example
-    #   Pry.config.commands["help"] = MyHelpCommand
-    #
-    def []=(pattern, command)
-      if command.equal?(nil)
-        return @commands.delete(pattern)
-      end
-      unless Class === command && command < Pry::Command
-        raise TypeError, "command is not a subclass of Pry::Command"
-      end
-      bind_command_to_pattern = pattern != command.match
-      if bind_command_to_pattern
-        command_copy = command.dup
-        command_copy.match = pattern
-        @commands[pattern] = command_copy
-      else
-        @commands[pattern] = command
-      end
-    end
-
-    #
-    # Add a command to set.
-    #
-    # @param [Command] command
-    #   a subclass of Pry::Command.
-    #
-    def add_command(command)
-      self[command.match] = command
+    def find_command(val)
+      commands.values.select{ |c| c.matches?(val) }.sort_by{ |c| c.match_score(val) }.last
     end
+    alias_method :[], :find_command
 
     # Find the command that the user might be trying to refer to.
     # @param [String] search The user's search.
@@ -399,7 +356,7 @@ class Pry
 
     # @private (used for testing)
     def run_command(context, match, *args)
-      command = @commands[match] or raise NoCommandError.new(match, self)
+      command = commands[match] or raise NoCommandError.new(match, self)
       command.new(context).call_safely(*args)
     end
 
@@ -411,9 +368,9 @@ class Pry
       if command = find_command(search)
         command.new(context).complete(search)
       else
-        @commands.keys.select do |key|
+        commands.keys.select do |key|
           String === key && key.start_with?(search)
-        end.map{ |key| key + " " }
+        end.map{ |key| key + " " } + Bond::DefaultMission.completions
       end
     end
   end