pry-coolline 0.1.5 → 0.2.0

data/.gitignore

@@ -1,7 +1,7 @@
-Makefile
-*.so
-*.o
-*.def
-doc/
-pkg/
-.yardoc/
+Makefile
+*.so
+*.o
+*.def
+doc/
+pkg/
+.yardoc/

data/.yardopts

@@ -1 +1 @@
---markup markdown
+--markup markdown

data/LICENSE

@@ -1,25 +1,25 @@
-License
--------
-
-(The MIT License) 
-
-Copyright (c) 2012 John Mair (banisterfiend)
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-'Software'), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+License
+-------
+
+(The MIT License) 
+
+Copyright (c) 2012 John Mair (banisterfiend)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -20,26 +20,33 @@ gem and the `io/console` library.
 After installing `pry-coolline` just start Pry as normal, the coolline
 plugin will be detected and used automatically.
 
-**Known Issues:**
-
-On some platforms the up and down cursor keys do not work properly; to
-get around this you can use the emacs keybindings.
+<center>
+![Alt text](http://dl.dropbox.com/u/26521875/coolline.png)
 
-These are:
+Features
+--------
 
+***Automatic Ruby syntax highlighting***
 
-`^p` equivalent to up-arrow
+This is the main feature. It is enabled by default, as long as
+`Pry.config.color` is true.
 
-`^n` equivalent to down-arrow
+***Matching of opening and closing parentheses and brackets***
 
-`^d` equivalent to delete
+`pry-coolline` allows to match parentheses and brackets automatically. This
+behavior can be configured and disabled altogether:
 
-`^e` navigate to end of line
+    # Whether or not to enable this feature. Defaults to true.
+    Pry.config.coolline_paren_matching = false
 
-`^a` navigate to start of line
+    # Change the color code inserted when paprens are (mis)matched.
+    Pry.config.coolline_matched_paren    = "\e[42m"
+    Pry.config.coolline_mismatched_paren = "\e[41m"
 
-<center>
-![Alt text](http://dl.dropbox.com/u/26521875/coolline.png)
+    # In case you can't remember ANSI color codes ;)
+    require 'term/ansicolor'
+    Pry.config.coolline_matched_paren    = Term::ANSIColor.on_green
+    Pry.config.coolline_mismatched_paren = Term::ANSIColor.on_red
 
 Limitations
 -----------

data/Rakefile

@@ -23,6 +23,7 @@ def apply_spec_defaults(s)
   s.description = s.summary
   s.add_dependency("coolline","~>0.3")
   s.add_dependency("io-console","~>0.3.0")
+  s.add_development_dependency("riot")
   s.required_ruby_version = '>= 1.9.2'
   s.require_path = 'lib'
   s.homepage = "https://github.com/pry/pry-coolline"
@@ -39,7 +40,7 @@ end
 
 desc "run tests"
 task :test do
-  sh "bacon -Itest -rubygems -a"
+  ruby "test/run_all.rb"
 end
 
 desc "Show version"

data/lib/pry-coolline/paren_match.rb

@@ -0,0 +1,278 @@
+# -*- coding: utf-8 -*-
+module PryCoolline
+  module ParenMatch
+    Pairs = {
+      "(" => ")",
+      "[" => "]",
+      "{" => "}",
+    }
+
+    AnsiCode = Coolline::AnsiCode
+
+    # A Token is a short chunk of code. This tokenizer only distinguishes three
+    # kinds of token:
+    #
+    #   1. Tokens that open a pair (OpenToken)
+    #   2. Tokens that close a pair (CloseToken)
+    #   3. The rest of the code (StrToken)
+    #
+    # @attr [String]  str String covered by the token
+    # @attr [Integer] pos Position in the initial code, character-wise,
+    #   disregarding ANSI codes.
+    # @attr [Integer] code_pos Position in the initial code, character-wise,
+    #   including ANSI codes.
+    Token = Struct.new(:str, :pos, :code_pos)
+
+    OpenToken  = Class.new(Token)
+    CloseToken = Class.new(Token)
+    StrToken   = Class.new(Token)
+
+    # Represents a pair that should be matched.
+    #
+    # @attr [OpenToken, nil]  open
+    # @attr [CloseToken, nil] close
+    Pair = Struct.new(:open, :close) do
+      # @return [Boolean] True if the opening character and the closing
+      #   characters are both present and match correctly.
+      def correctly_matched?(pairs = Pairs)
+        open and close and pairs[open.str] == close.str
+      end
+
+      # @return [Array<Array<Integer>>] Positions where the user can insert
+      #   color indicators, in descending order so that String#insert can be
+      #   used safely.
+      #
+      # @example
+      #   insertion_positions.each do |before, after|
+      #     string.insert after, clear_code
+      #     string.insert before, background_code
+      #   end
+      def insertion_positions
+        ary = []
+
+        if close
+          ary << [close.code_pos, close.code_pos + close.str.size]
+        end
+
+        if open
+          ary << [open.code_pos, open.code_pos + open.str.size]
+        end
+
+        ary
+      end
+    end
+
+    # This module contains the different kinds of AST nodes generated when
+    # trying to match pairs of opening and closing characters.
+    #
+    module AST
+      # The root of the AST tree.
+      # @attr [Array<Leaf, DanglingClose, Node>] elements All the top-level
+      #   nodes of the tree.
+      Root = Struct.new(:elements) do
+        # @param [Parser] parser Parser to get the tokens from
+        def initialize(parser)
+          self.elements = []
+
+          while tok = parser.next_token
+            case tok
+            when OpenToken  then elements << Node.new(parser, tok)
+            when StrToken   then elements << Leaf.new(tok)
+            when CloseToken then elements << DanglingClose.new(tok)
+            end
+          end
+        end
+
+        # Finds the opening and closing tokens that should be matched at a
+        # certain position in the string.
+        #
+        # It is assumed you can be looking for the closing parenthesis when on
+        # the opening one, or for the opening one when selecting the character
+        # that immediately follows it.
+        #
+        # @param [Integer] pos
+        #
+        # @return [Pair] An (open, close) pair. Notice both the opening and
+        #   closing tokens coud be nil.
+        def pair_at(pos)
+          elements.each do |el|
+            if pair = el.pair_at(pos)
+              return pair
+            end
+          end
+
+          Pair.new
+        end
+      end
+
+      # A sequence of text on its own, that contains no parts of a pair.
+      #
+      # @attr [StrToken] tok
+      Leaf = Struct.new(:tok) do
+        # (see Root#pair_at)
+        def pair_at(pos)
+          nil
+        end
+      end
+
+      # A top-level closing paren — meaning there's no matching opening
+      # character.
+      DanglingClose = Struct.new(:tok) do
+        # (see Root#pair_at)
+        def pair_at(pos)
+          if pos == tok.pos + tok.str.size
+            Pair.new(nil, tok)
+          end
+        end
+      end
+
+      # A block of code that was opened by a character, and may or may not (but
+      # should!) have been closed by another token.
+      #
+      # @attr [OpenToken]       open
+      # @attr [CloseToken, nil] close
+      #
+      # @attr [Array<Leaf, Node>] elements Other nodes within the opening and
+      #   the closing tokens.
+      Node = Struct.new(:open, :elements, :close) do
+        def initialize(parser, open)
+          self.elements = []
+          self.open     = open
+
+          while tok = parser.next_token and !tok.is_a?(CloseToken)
+            case tok
+            when OpenToken then elements << Node.new(parser, tok)
+            when StrToken  then elements << Leaf.new(tok)
+            end
+          end
+
+          self.close = tok # might be nil, which is okay
+        end
+
+        # (see Root#pair_at)
+        def pair_at(pos)
+          if pos == open.pos ||
+              (close && pos == close.pos + close.str.size)
+            Pair.new(open, close)
+          else
+            elements.each do |el|
+              if pair = el.pair_at(pos)
+                return pair
+              end
+            end
+
+            nil
+          end
+        end
+      end
+    end
+
+    class Parser
+      # @param (see ParenMatch#pair_at)
+      # @return [AST::Root]
+      def self.parse(code, pairs = Pairs)
+        new(code, pairs).parse
+      end
+
+      # @param (see ParenMatch#pair_at)
+      def initialize(code, pairs = Pairs)
+        @tokens = tokenize(code, pairs)
+      end
+
+      # @return [AST::Root]
+      def parse
+        AST::Root.new self
+      end
+
+      # Returns the next token found in the array and removes it.
+      #
+      # @return [Token] The next token, which will be removed from the queue.
+      def next_token
+        @tokens.shift
+      end
+
+      private
+
+      # Generates token from a given chunk of code.
+      #
+      # ANSI codes are ignored, as if they were comments.
+      #
+      # @param (see ParenMatch#pair_at)
+      # @return [Array<Token>]
+      def tokenize(code, pairs)
+        openers = Regexp.union(pairs.keys)
+        closers = Regexp.union(pairs.values)
+
+        token = Regexp.union(openers, closers, AnsiCode)
+
+        tokens = []
+
+        char_pos = pos = 0
+
+        until pos == code.size
+          old_pos = pos
+
+          if m = match_at(code, AnsiCode, pos)
+            pos = m.end(0)
+          elsif m = match_at(code, openers, pos)
+            tokens << OpenToken.new(m.to_s, char_pos, pos)
+            pos = m.end(0)
+            char_pos += pos - old_pos
+          elsif m = match_at(code, closers, pos)
+            tokens << CloseToken.new(m.to_s, char_pos, pos)
+            pos = m.end(0)
+            char_pos += pos - old_pos
+          elsif m = code.match(token, pos)
+            tokens << StrToken.new(code[pos...m.begin(0)], char_pos, pos)
+            pos = m.begin(0)
+            char_pos += pos - old_pos
+          else
+            tokens << StrToken.new(code[pos..-1], char_pos, pos)
+            pos = code.size
+          end
+        end
+
+        tokens
+      end
+
+      # @return [Matchdata, nil] Matchdata if the regexp matches the string at
+      #   the specifed position, nil otherwise.
+      def match_at(string, regexp, pos)
+        if m = string.match(regexp, pos) and m.begin(0) == pos
+          m
+        end
+      end
+    end
+
+    module_function
+    # @param [String]  code
+    # @param [Integer] pos Position of the selected character, disregarding ANSI
+    #   codes.
+    # @param [Hash<String, String>] pairs A hash mapping each opening character
+    #   to a closing one.
+    #
+    # @return (see AST::Root#pair_at)
+    def pair_at(code, pos, pairs = Pairs)
+      Parser.parse(code, pairs).pair_at pos
+    end
+  end
+
+  module_function
+
+  # Adds paren matching code for the parens that are matched at a given
+  # position. The color codes are determined using Pry.config.
+  #
+  # @param [String] code
+  # @param [Integer] pos
+  def apply_paren_matching(code, pos)
+    pair = ParenMatch.pair_at(code, pos)
+
+    color = pair.correctly_matched? ? Pry.config.coolline_matched_paren :
+      Pry.config.coolline_mismatched_paren
+
+    pair.insertion_positions.each do |before, after|
+      code.insert after, "\e[0m"
+      code.insert before, color
+    end
+  end
+end

data/lib/pry-coolline/version.rb

@@ -1,3 +1,3 @@
 module PryCoolline
-  VERSION = "0.1.5"
+  VERSION = "0.2.0"
 end

data/lib/pry-coolline.rb

@@ -2,26 +2,37 @@
 # (C) John Mair (banisterfiend); MIT license
 
 require 'pry'
-require "pry-coolline/version"
+require 'pry-coolline/version'
+
+Pry.config.coolline_paren_matching ||= true
+
+Pry.config.coolline_matched_paren    ||= "\e[42m"
+Pry.config.coolline_mismatched_paren ||= "\e[41m"
 
 begin
   require 'coolline'
+  require 'pry-coolline/paren_match'
 
   Pry.config.input = Coolline.new do |cool|
     cool.word_boundaries = [" ", "\t", ",", ";", '"', "'", "`", "<", ">",
                             "=", ";", "|", "{", "}", "(", ")", "-"]
 
     # bring saved history into coolline
-    cool.history_file = Pry.config.history.file
+    cool.history_file = File.expand_path(Pry.config.history.file)
 
     cool.transform_proc = proc do
       if Pry.color
-        CodeRay.scan(cool.line, :ruby).term
+        code = CodeRay.scan(cool.line, :ruby).term
+
+        if Pry.config.coolline_paren_matching
+          PryCoolline.apply_paren_matching(code, cool.pos)
+        end
+
+        code
       else
         cool.line
       end
     end
   end
-
 rescue LoadError
 end if ENV["TERM"] != "dumb"

data/test/helpers.rb

@@ -0,0 +1,6 @@
+$LOAD_PATH.unshift File.expand_path("../lib", File.dirname(__FILE__))
+
+require 'riot'
+require 'pry-coolline'
+
+Riot.reporter = Riot::PrettyDotMatrixReporter

data/test/paren_match_test.rb

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+require File.expand_path("helpers.rb", File.dirname(__FILE__))
+
+# This code allows to test paren matching against:
+#   - multibyte characters;
+#   - ANSI codes.
+code = <<eof
+)foo (bar) bat} [béz] () bat] ( 3} [bat {bar}\e[3m] [
+eof
+
+PM = PryCoolline::ParenMatch
+
+context PM do
+  setup { PM }
+
+  def pair(a = nil, b = nil)
+    PM::Pair.new(a ? PM::OpenToken.new(*a) : a,
+                 b ? PM::CloseToken.new(*b) : b)
+  end
+
+  asserts(:pair_at, code, 0).equals pair
+  asserts(:pair_at, code, 1).equals pair(nil, [")", 0, 0])
+  asserts(:pair_at, code, 3).equals pair
+  asserts(:pair_at, code, 5).equals pair(["(", 5, 5], [")", 9, 9])
+  asserts(:pair_at, code, 15).equals pair(nil, ["}", 14, 14])
+  asserts(:pair_at, code, 22).equals pair(["(", 22, 22], [")", 23, 23])
+  asserts(:pair_at, code, 23).equals pair
+  asserts(:pair_at, code, 24).equals pair(["(", 22, 22], [")", 23, 23])
+  asserts(:pair_at, code, 30).equals pair(["(", 30, 30], ["}", 33, 33])
+  asserts(:pair_at, code, 34).equals pair(["(", 30, 30], ["}", 33, 33])
+  asserts(:pair_at, code, 35).equals pair(["[", 35, 35], ["]", 45, 49])
+  asserts(:pair_at, code, 40).equals pair(["{", 40, 40], ["}", 44, 44])
+  asserts(:pair_at, code, 45).equals pair(["{", 40, 40], ["}", 44, 44])
+  asserts(:pair_at, code, 46).equals pair(["[", 35, 35], ["]", 45, 49])
+  asserts(:pair_at, code, 47).equals pair(["[", 47, 51])
+end
+
+context "a fully matched pair" do
+  setup do
+    PM::Pair.new(PM::OpenToken.new("abc", 3, 4),
+                 PM::CloseToken.new("ab", 10, 15))
+  end
+
+  denies(:correctly_matched?)
+  denies(:correctly_matched?, "abc" => "cba")
+  asserts "correctly matched if pairs are right" do
+    topic.correctly_matched? "abc" => "ab"
+  end
+
+  asserts(:insertion_positions).equals [[15, 17], [4, 7]]
+end
+
+context "a pair without closing token" do
+  setup do
+    PM::Pair.new(PM::OpenToken.new("abc", 3, 4))
+  end
+
+  denies(:correctly_matched?)
+  asserts(:insertion_positions).equals [[4, 7]]
+end
+
+context "a pair without opening token" do
+  setup do
+    PM::Pair.new(nil, PM::CloseToken.new("ab", 10, 15))
+  end
+
+  denies(:correctly_matched?)
+  asserts(:insertion_positions).equals [[15, 17]]
+end
+
+context "an empty pair" do
+  setup { PryCoolline::ParenMatch::Pair.new }
+
+  denies(:correctly_matched?)
+  asserts(:insertion_positions).empty
+end

data/test/run_all.rb

@@ -0,0 +1,5 @@
+require File.expand_path("helpers.rb", File.dirname(__FILE__))
+
+Dir.glob(File.join(File.dirname(__FILE__), "**/*_test.rb")) do |file|
+  load file
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pry-coolline
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-13 00:00:00.000000000 Z
+date: 2013-01-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: coolline
@@ -43,6 +43,22 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 0.3.0
+- !ruby/object:Gem::Dependency
+  name: riot
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Live syntax-highlighting for the Pry REPL
 email: jrmair@gmail.com
 executables: []
@@ -57,9 +73,12 @@ files:
 - README.md
 - Rakefile
 - lib/pry-coolline.rb
+- lib/pry-coolline/paren_match.rb
 - lib/pry-coolline/version.rb
 - pry-coolline.gemspec
-- test/test.rb
+- test/helpers.rb
+- test/paren_match_test.rb
+- test/run_all.rb
 homepage: https://github.com/pry/pry-coolline
 licenses: []
 post_install_message: 
@@ -80,9 +99,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Live syntax-highlighting for the Pry REPL
 test_files:
-- test/test.rb
+- test/helpers.rb
+- test/paren_match_test.rb
+- test/run_all.rb

data/test/test.rb

@@ -1,12 +0,0 @@
-direc = File.dirname(__FILE__)
-
-require 'rubygems'
-require "#{direc}/../lib/pry-coolline"
-require 'bacon'
-
-puts "Testing pry-coolline version #{PryCoolline::VERSION}..." 
-puts "Ruby version: #{RUBY_VERSION}"
-
-describe PryCoolline do
-end
-