sexp_path 0.4.0

data/lib/sexp_path/traverse.rb

@@ -0,0 +1,72 @@
+module SexpPath
+  module Traverse
+    # Searches for the +pattern+ returning a SexpCollection containing 
+    # a SexpResult for each match.
+    #
+    # Example:
+    #   s(:a, s(:b)) / Q{ s(:b) } => [s(:b)]
+    def search(pattern, data={})
+      collection = SexpCollection.new
+      search_each(pattern,data){|match| collection << match}
+      collection
+    end
+    alias_method :/, :search
+    
+    # Searches for the +pattern+ yielding a SexpResult
+    # for each match.
+    #
+    def search_each(pattern, data={}, &block)
+      return false unless pattern.is_a? Sexp
+  
+      if pattern.satisfy?(self, data)
+        block.call(SexpResult.new(self, data))
+      end
+  
+      self.each do |subset|
+        case subset
+          when Sexp then subset.search_each(pattern, data, &block)
+        end
+      end
+    end
+    
+    # Searches for the +pattern+ yielding a SexpResult
+    # for each match, and replacing it with the result of
+    # the block. 
+    #
+    # There is no guarantee that the result will or will not 
+    # be the same object passed in, meaning this mutates, or replaces
+    # the original sexp.
+    def replace_sexp(pattern, data={}, &block)
+      return self unless pattern.is_a? Sexp
+  
+      if pattern.satisfy?(self, data)
+        return block.call(SexpResult.new(self, data))
+      end
+      
+      self.each_with_index do |subset, i|
+        case subset
+          when Sexp then self[i] = (subset.replace_sexp(pattern, data, &block))
+        end
+      end
+      
+      return self
+    end
+    
+    # Sets a named capture for the Matcher.  If a SexpResult is returned
+    # any named captures will be available it.
+    def capture_as(name)
+      @capture_name = name
+      self
+    end
+    alias_method :%, :capture_as
+
+    private  
+    def capture_match(matching_object, data)
+      if @capture_name
+        data[@capture_name] = matching_object
+      end
+
+      data
+    end
+  end
+end

data/test/line_numbering_processor_test.rb

@@ -0,0 +1,55 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/sexp_path'
+require 'parse_tree'
+
+class LineNumberingProcessorTest < Test::Unit::TestCase  
+  def setup
+    @path = File.dirname(__FILE__) + '/sample.rb'
+  end
+  
+  def test_processing_a_file_fills_in_all_the_line_numbers
+    sexp = LineNumberingProcessor.rewrite_file(@path)
+    assert !sexp.empty?
+    sexp.search_each(Q?{_}) do |s| 
+      assert !sexp.line.nil?, "Expected a line number for: #{s.sexp.inspect}"
+      assert !sexp.file.nil?, "Expected a file for: #{s.sexp.inspect}"
+    end
+  end
+  
+  # This test may break if sample.rb changes
+  def test_finding_known_lines
+    sexp = LineNumberingProcessor.rewrite_file(@path)
+    lines = open(@path,'r'){|io| io.readlines}
+    
+    assert_line_numbers_equal(
+      lines, 'def test_b()', 
+      sexp,  Q?{ s(:defn, :test_b, _) }
+    )
+    
+    assert_line_numbers_equal(
+      lines, '[apples, oranges, cakes]', 
+      sexp,  Q?{ s(:array, s(:lvar, :apples), s(:lvar, :oranges), s(:lvar, :cakes)) }
+    )
+    
+    assert_line_numbers_equal(
+      lines, "require 'test/unit'",
+      sexp, Q?{ s(:fcall, :require, s(:array, s(:str, "test/unit"))) }
+    )
+  end
+  
+  private
+  def assert_line_numbers_equal(lines, code, sexp, pattern)
+    string_line = find_line(lines, code)
+    sexp_line =   (sexp / pattern).first.sexp.line
+    
+    assert_equal string_line, sexp_line, "Expected to find #{code} at line #{string_line}"
+  end
+  
+  def find_line(lines, code)
+    
+    lines.each_with_index do |line,i|
+      return i+1 if line.index(code) # 1 based indexing
+    end
+    return nil
+  end
+end

data/test/sample.rb

@@ -0,0 +1,25 @@
+require 'test/unit'
+require 'test/unit/testcase'
+
+class ExampleTest < Test::Unit::TestCase  
+  def setup
+    1 + 2
+  end
+  
+  def test_a
+    assert_equal 1+2, 4
+  end
+  
+  def test_b()
+    # assert 1+1
+  end
+  
+  def test_a
+    assert_equal 1+2, 3
+  end
+  
+  private 
+  def helper_method apples, oranges, cakes=nil
+    [apples, oranges, cakes].compact.map{|food| food.to_s.upcase}
+  end
+end

data/test/sexp_path_capture_test.rb

@@ -0,0 +1,131 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/sexp_path'
+
+class SexpPathCaptureTest < Test::Unit::TestCase  
+  def setup
+    @ast_sexp = # Imagine it looks like a ruby AST
+      s(:class, :cake, 
+        s(
+          s(:defn, :foo, 
+            s(:add, :a, :b)
+          ),
+          s(:defn, :bar, 
+            s(:sub, :a, :b)
+          )
+        )
+      )
+  end
+  
+  def test_match_with_no_capture_defined_should_not_capture
+    sexp = s(:a, :b, :c)
+    assert_equal({}, Q?{ sexp }.satisfy?(sexp))
+  end
+  
+  def test_match_with_capture_defined_should_capture
+    sexp = s(:a, :b, :c)
+    assert res = Q?{ sexp % 'cake' }.satisfy?(sexp)
+    assert_equal(sexp, res['cake'])
+  end
+  
+  def test_match_with_multiple_captures
+    assert res = Q?{ s(:add, atom % 'A', atom % 'B') }.satisfy?( s(:add, :a, :b) )
+    assert_equal(:a, res['A'])
+    assert_equal(:b, res['B'])
+  end
+  
+  def test_deep_matches
+    assert res = Q?{ s(:class, atom % 'name', s( _ % 'def1', _ % 'def2')) }.satisfy?( @ast_sexp )
+    assert_equal(:cake, res['name'])
+    assert_equal(s(:defn, :foo, s(:add, :a, :b)), res['def1'])
+    assert_equal(s(:defn, :bar, s(:sub, :a, :b)), res['def2'])
+  end
+  
+  def test_simple_searching
+    res = @ast_sexp / Q?{ s(:class, atom % 'name', _) }
+    assert_equal 1, res.length
+    assert_equal :cake, res.first['name']
+  end
+  
+  def test_iterative_searching
+    result = @ast_sexp / Q?{ s(:class, atom % 'class', _) } / Q?{ s(:defn, atom % 'method', _) }
+    assert_equal 2, result.length, "Should have matched both defn nodes"
+    
+    result.each do |match_data|
+      assert match_data['method'], "Should have captured to 'method'"
+      assert match_data['class'], "Should have propogated 'class' capture"
+    end
+  end
+  
+  def test_capturing_any_matchers
+    sexp = s(:add, :a, :b)
+    assert res = Q?{ any(s(:add, :a, :b), s(:sub, :a, :b)) % 'match' }.satisfy?( sexp )
+    assert_equal sexp, res['match']
+    
+    assert res = Q?{ any(s(atom % 'name', :a, :b), s(:sub, :a, :b)) % 'match' }.satisfy?( sexp )
+    assert_equal sexp, res['match']
+    assert_equal :add, res['name']
+  end
+  
+  def test_capturing_all_matchers
+    sexp = s(:add, :a, :b)
+    assert res = Q?{ all(s(_, :a, :b), s(atom, :a, :b)) % 'match' }.satisfy?( sexp )
+    assert_equal sexp, res['match']
+    
+    assert res = Q?{ all(s(_ % 'wild', :a, :b), s(atom % 'atom', :a, :b)) % 'match' }.satisfy?( sexp )
+    assert_equal sexp, res['match']
+    assert_equal :add, res['wild']
+    assert_equal :add, res['atom']
+  end
+  
+  def test_capturing_type_matches
+    sexp = s(:add, :a, :b)
+    assert res = Q?{ t(:add) % 'match' }.satisfy?( sexp )
+    assert_equal sexp, res['match']
+  end
+  
+  def test_capturing_child_matches
+    sexp = s(:a, s(:b, s(:c)))
+    assert res = Q?{ s(:a, child( s(atom % 'atom') ) % 'child' ) }.satisfy?( sexp )
+    assert_equal s(:b, s(:c)), res['child']
+    assert_equal :c, res['atom']
+  end
+  
+  def test_catpuring_pattern_matches
+    sexp = s(:add, :a, :b)
+    assert res = Q?{ s(m(/a../) % 'regexp', :a, :b) }.satisfy?( sexp )
+    assert_equal :add, res['regexp']
+  end
+  
+  def test_catpuring_include_matches
+    sexp = s(:add, :a, :b)
+    assert res = Q?{ include(:a) % 'include' }.satisfy?( sexp )
+    assert_equal sexp, res['include']
+  end
+  
+  def test_catpuring_nested_include_matches
+    sexp = s(:add, s(:a), :b)
+    assert res = Q?{ include(s(atom % 'atom' )) % 'include' }.satisfy?( sexp )
+    assert_equal sexp, res['include']
+    assert_equal :a, res['atom']
+  end
+  
+  def test_capturing_negations
+    sexp = s(:b)
+    assert res = Q?{ (-s(:a)) % 'not' }.satisfy?( sexp )
+    assert_equal s(:b), res['not']
+  end
+  
+  def test_capturing_negation_contents
+    sexp = s(:a, :b)
+    assert res = Q?{ -((include(:b) % 'b') & t(:c)) }.satisfy?( sexp )
+    assert !res['b'], 'b should not be included'
+  end
+  
+  def test_capturing_siblings
+    sexp = s(s(:a), s(s(:b)), s(:c))
+    assert res = Q?{ (s(atom) % 'a') >> (s(atom) % 'c') }.satisfy?( sexp )
+    assert_equal s(:a), res['a']
+    assert_equal s(:c), res['c']
+  end
+  
+end

data/test/sexp_path_matching_test.rb

@@ -0,0 +1,211 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../lib/sexp_path'
+
+class SexpMatchingPathTest < Test::Unit::TestCase  
+  def setup
+    @ast_sexp = # Imagine it looks like a ruby AST
+      s(:class, :cake, 
+        s(
+          s(:defn, :foo, 
+            s(:add, :a, :b)
+          ),
+          s(:defn, :bar, 
+            s(:sub, :a, :b)
+          )
+        )
+      )
+  end
+  
+  def test_searching_simple_examples
+    assert_search_count @ast_sexp, :class, 0, 
+      "Literal should match nothing"
+    
+    assert_search_count @ast_sexp, Q?{s(:class)}, 0, 
+      "Should not exactly match anything"
+      
+    assert_search_count @ast_sexp, Q?{s(:add, :a, :b)}, 1, 
+      "Should exactly match once"
+      
+    assert_search_count s(:a, s(:b, s(:c))), Q?{s(:b, s(:c))}, 1, 
+      "Should match an exact subset"
+    
+    assert_search_count s(:a, s(:b, s(:c))), Q?{s(:a, s(:c))}, 0, 
+      "Should not match the child s(:c)"
+      
+    assert_search_count @ast_sexp, Q?{s(:defn, :bar, s(:sub, :a, :b))}, 1, 
+      "Nested sexp should exactly match once"
+  end
+  
+  def test_equality_of_atom
+    a = SexpPath::Matcher::Atom.new
+    assert a.satisfy?(:a),  "Should match a symbol"
+    assert a.satisfy?(1),   "Should match a number"
+    assert a.satisfy?(nil), "Should match nil"
+    assert !a.satisfy?(s()), "Should not match an sexp"
+  end
+  
+  def test_searching_with_atom    
+    assert_search_count s(:add, :a, :b), Q?{s(:add, atom, :b)} , 1, 
+      "atom should match :a"
+      
+    assert_search_count @ast_sexp, Q?{s(:defn, atom, s(atom, :a, :b) )}, 2, 
+      "atoms should match :foo/:bar and :add/:sub"
+      
+    assert_search_count s(:a, s()), Q?{s(:a, atom)}, 0, 
+      "atom should not match s()"
+  end
+  
+  def test_searching_with_any
+    assert_search_count s(:foo, s(:a), s(:b)), Q?{s(any(:a,:b))}, 2, 
+      "should not match either :a or :b"
+      
+    assert_search_count s(:foo, s(:a), s(:b)), Q?{any( s(:a) ,s(:c))}, 1, 
+      "sexp should not match s(:a)"
+  end
+  
+  def test_equality_of_wildacard
+    w = SexpPath::Matcher::Wild.new
+    assert w.satisfy?(:a  ),  "Should match a symbol"
+    assert w.satisfy?(1   ),   "Should match a number"
+    assert w.satisfy?(nil ), "Should match nil"
+    assert w.satisfy?([]  ),  "Should match an array"
+    assert w.satisfy?(s() ), "Should match an sexp"
+  end
+  
+  def test_searching_with_wildcard
+    assert_search_count s(:add, :a, :b), Q?{s(:add, wild, :b)} , 1, 
+      "wild should match :a"
+    
+    assert_search_count @ast_sexp, Q?{s(:defn, :bar, _)}, 1,
+      "should match s(:defn, :bar, s(..))"
+      
+    assert_search_count @ast_sexp, Q?{s(:defn, _, s(_, :a, :b) )}, 2, 
+      "wilds should match :foo/:bar and :add/:sub"
+      
+    assert_search_count s(:a, s()), Q?{s(:a, _)}, 1, 
+      "wild should match s()"
+    
+    assert_search_count s(:a, :b, :c), Q?{s(_,_,_)}, 1, 
+      "multiple wilds should work"
+    
+    assert_search_count @ast_sexp, Q?{wild}, 6, 
+      "wild should match every sub expression"
+  end
+  
+  def test_searching_with_include
+    assert_search_count s(:add, :a, :b), Q?{include(:a)} , 1, 
+      "Sexp should include atom :a"
+      
+    assert_search_count @ast_sexp, Q?{include(:bar)}, 1, 
+      "Sexp should include atom :bar"
+      
+    assert_search_count @ast_sexp, Q?{s(:defn, atom, include(:a))}, 2, 
+      "Sexp should match :defn with an sexp including :a"
+    
+    assert_search_count @ast_sexp, Q?{include(:a)}, 2, 
+      "Sexp should match an sexp including :a"
+    
+    assert_search_count s(:a, s(:b, s(:c))), Q?{s(:a, include(:c))}, 0, 
+      "Include should not descend"
+  end
+  
+  def test_or_matcher
+    assert  Q?{s(:a) | s(:b)}.satisfy?( s(:a) ), "q(:a) should match s(:a)"
+    assert !Q?{s(:a) | s(:b)}.satisfy?( s(:c) ), "Should not match s(:c)"
+    
+    assert_search_count s(:a, s(:b, :c), s(:b, :d)), Q?{s(:b, :c) | s(:b, :d)}, 2, 
+      "Should match both (:b, :c) and (:b, :d)"
+      
+    assert_search_count @ast_sexp, Q?{s(:add, :a, :b) | s(:defn, :bar, _)}, 2, 
+      "Should match at any level" 
+  end
+  
+  # For symetry, kind of silly examples
+  def test_and_matcher
+    assert !Q?{s(:a) & s(:b)}.satisfy?(s(:a)), "s(:a) is not both s(:a) and s(:b)"
+    assert  Q?{s(:a) & s(atom)}.satisfy?(s(:a)), "s(:a) matches both criteria"
+  end
+  
+  def test_child_matcher    
+    assert_search_count @ast_sexp, Q?{s(:class, :cake, child( s(:add, :a, :b) ) )}, 1,
+      "Should match s(:class, :cake ...) and descend to find s(:add, :a, :b)"
+        
+    assert_search_count @ast_sexp, Q?{s(:class, :cake, child(include(:a)))}, 1,
+      "Should match once since there exists a child which includes :a"
+  end
+  
+  def test_not_matcher
+    assert !Q?{-wild}.satisfy?(s(:a)),        "wild should match s(:a)"
+    assert  Q?{-(s(:b))}.satisfy?(s(:a)),     "s(:b) should not match s(:b)"
+    assert  Q?{is_not(s(:b))}.satisfy?(s(:a)),"should behave the same as unary minus"
+    assert !Q?{-(s(atom))}.satisfy?(s(:a)),   "should not match, :a is an atom"
+    assert  Q?{s(is_not(:b))}.satisfy?(s(:a)), "should match s(:a) since the atom is not :b"
+  end
+  
+  def test_sibling_matcher
+    assert_equal SexpPath::Matcher::Sibling, Q?{(s(:a) >> s(:b))}.class 
+    
+    assert  Q?{s(:a) >> s(:b)}.satisfy?( s(s(:a), s(:b)) ),        "should match s(:a) has an immediate sibling s(:b)"
+    assert  Q?{s(:a) >> s(:b)}.satisfy?( s(s(:a), s(:b), s(:c)) ), "should match s(:a) has an immediate sibling s(:b)"
+    assert  Q?{s(:a) >> s(:c)}.satisfy?( s(s(:a), s(:b), s(:c)) ), "should match s(:a) a sibling s(:b)"
+    assert !Q?{s(:c) >> s(:a)}.satisfy?( s(s(:a), s(:b), s(:c)) ), "should not match s(:a) does not follow s(:c)"
+    assert !Q?{s(:a) >> s(:a)}.satisfy?( s(s(:a)) ),               "should not match s(:a) has no siblings"
+    assert  Q?{s(:a) >> s(:a)}.satisfy?( s(s(:a), s(:b), s(:a)) ), "should match s(:a) has another sibling s(:a)"
+    
+    assert_search_count @ast_sexp, Q?{t(:defn) >> t(:defn)}, 1,
+      "Should match s(:add, :a, :b) followed by s(:sub, :a, :b)"
+  end
+  
+  def test_pattern_matcher
+    assert  Q?{m(/a/)}.satisfy?(:a),             "Should match :a"
+    assert  Q?{m(/^test/)}.satisfy?(:test_case), "Should match :test_case"
+    assert  Q?{m('test')}.satisfy?(:test),       "Should match :test #{Q?{m('test')}.inspect}"
+    assert !Q?{m('test')}.satisfy?(:test_case), "Should only match whole word 'test'"
+    assert !Q?{m(/a/)}.satisfy?(s(:a)),         "Should not match s(:a)"
+    
+    assert_search_count @ast_sexp, Q?{s(m(/\w{3}/), :a, :b)}, 2,
+      "Should match s(:add, :a, :b) and s(:sub, :a, :b)"
+  end
+  
+  def test_search_method
+    assert_equal 1, @ast_sexp.search( s(:sub, :a, :b)).length
+    assert_equal 2, @ast_sexp.search( Q?{s(:defn, atom, wild)} ).length
+  end
+  
+  def test_search_collection
+    # test method
+    assert_equal SexpPath::SexpCollection, @ast_sexp.search( s(:sub, :a, :b)).class
+    # test binary operator
+    assert_equal SexpPath::SexpCollection, (@ast_sexp / s(:sub, :a, :b)).class
+    # test sub searches
+    collection = @ast_sexp / Q?{s(:defn, atom, _)} / Q?{s(atom, :a, :b)}
+    assert_equal SexpPath::SexpCollection, collection.class
+    assert_equal 2, collection.length
+    assert_equal [s(:add, :a, :b), s(:sub, :a, :b)], collection.map{|m| m.sexp}
+  end
+  
+  def test_sexp_type_matching
+    assert Q?{t(:a)}.satisfy?( s(:a) )
+    assert Q?{t(:a)}.satisfy?( s(:a, :b, s(:oh_hai), :d) )
+    assert_search_count @ast_sexp, Q?{t(:defn)}, 2,
+      "Should match s(:defn, _, _)"
+  end
+  
+  # Still not sure if I like this
+  def test_block_matching
+    sb = SexpPath::Matcher::Block
+    
+    assert sb.new{|o| o == s(:a)}.satisfy?(s(:a)), "Should match simple equality"
+    assert sb.new{|o| o.length == 1}.satisfy?(s(:a)), "Should match length check"
+    
+    assert_search_count s(:a, s(:b), s(:c), s(:d,:t) ), sb.new{|o| o.length == 2 }, 1, 
+      "Should match s(:d, :t)"
+  end
+  
+  private
+  def assert_search_count(sexp, example, count, message)
+    i = 0
+    sexp.search_each(example){|match| i += 1}
+    assert_equal count, i, message + "\nSearching for: #{example.inspect}\nIn: #{sexp.inspect}"
+  end
+end