furnace 0.0.3 → 0.0.4

data/lib/furnace/ast/matcher.rb

@@ -1,37 +1,71 @@
 module Furnace::AST
-  class Matcher
-    SpecialAny    = MatcherSpecial.new(:any)
-    SpecialSubset = MatcherSpecial.define(:subset)
+  class MatcherError < StandardError; end
 
+  class Matcher
     def initialize(&block)
       @pattern = self.class.class_exec(&block)
     end
 
-    def match(object)
-      genmatch(object.to_astlet, @pattern)
+    def match(object, captures={})
+      if genmatch(object.to_astlet, @pattern, captures)
+        captures
+      else
+        nil
+      end
     end
 
-    def find_one(collection)
+    def find_one(collection, initial_captures={})
       collection.find do |elem|
-        result = match elem
-        yield elem, result if block_given? && result
-        result
+        result = match elem, initial_captures.dup
+
+        if block_given? && result
+          yield elem, result
+        else
+          result
+        end
+      end
+    end
+
+    def find_one!(collection, initial_captures={})
+      found = nil
+
+      collection.each do |elem|
+        result = match elem, initial_captures.dup
+
+        if result
+          raise MatcherError, "already matched" if found
+
+          found = elem
+          yield elem, result if block_given?
+        end
       end
+
+      raise MatcherError, "no match found" unless found
+
+      found
     end
 
-    def find_all(collection)
+    def find_all(collection, initial_captures={})
       collection.select do |elem|
-        result = match elem
+        result = match elem, initial_captures.dup
         yield elem, result if block_given? && result
         result
       end
     end
 
+    SpecialAny    = MatcherSpecial.new(:any)
+    SpecialSkip   = MatcherSpecial.new(:skip)
+    SpecialSubset = MatcherSpecial.define(:subset)
+
     class << self
       def any
         SpecialAny
       end
 
+      def skip
+        SpecialSkip
+      end
+
       def subset
         SpecialSubset
       end
@@ -39,56 +73,76 @@ module Furnace::AST
       def capture(name)
         MatcherSpecial.new(:capture, name)
       end
+
+      def backref(name)
+        MatcherSpecial.new(:backref, name)
+      end
     end
 
     protected
 
-    def submatch(array, pattern)
+    def submatch(array, pattern, captures)
       matches = true
+      nested_captures = captures.dup
 
-      pattern.each_with_index do |subpattern, index|
-        if array[index].nil?
-          return false
-        end
+      pattern.each_with_index do |nested_pattern, index|
+        return false if index > array.length
 
-        case subpattern
+        case nested_pattern
+        when Array
+          matches &&= genmatch(array[index], nested_pattern, nested_captures)
         when SpecialAny
           # it matches
-        when MatcherSpecial
-          if subpattern.type == :subset
-            all_submatches = true
-
-            subpattern.params.each do |pattern_case|
-              submatches = false
-              array[index..-1].each do |subset_elem|
-                submatches ||= genmatch(subset_elem, pattern_case)
-                break if submatches
+        when SpecialSkip
+          # it matches all remaining elements
+          break
+        when MatcherSpecial.kind(:capture)
+          # it matches and captures
+          nested_captures[nested_pattern.param] = array[index]
+        when MatcherSpecial.kind(:backref)
+          matches &&= (nested_captures[nested_pattern.param] == array[index])
+        when MatcherSpecial.kind(:subset)
+          all_submatches = true
+
+          workset = Set.new array[index..-1]
+
+          nested_pattern.param.each do |subset_pattern|
+            sub_matches  = false
+
+            workset.each do |subset_elem|
+              sub_matches ||= genmatch(subset_elem, subset_pattern, nested_captures)
+
+              if sub_matches
+                workset.delete subset_elem
+                break
               end
-
-              all_submatches &&= submatches
-              break unless all_submatches
             end
 
-            matches &&= all_submatches
+            all_submatches &&= sub_matches
+            break unless all_submatches
           end
-        when Array
-          matches &&= genmatch(array[index], subpattern)
+
+          matches &&= all_submatches
         else
-          matches &&= array[index] == subpattern
+          matches &&= (array[index] == nested_pattern)
         end
 
         break unless matches
       end
 
+      captures.replace(nested_captures) if matches
+
       matches
     end
 
-    def genmatch(astlet, pattern)
-#       if astlet.respond_to? :to_sexp
-#         puts "match #{astlet.to_sexp} of #{pattern}"
-#       else
-#         puts "match #{astlet} of #{pattern}"
-#       end
+    def genmatch(astlet, pattern, captures)
+      if $DEBUG
+        if astlet.respond_to? :to_sexp
+          puts "match #{astlet.to_sexp} of #{pattern}"
+        else
+          puts "match #{astlet} of #{pattern}"
+        end
+      end
 
       if pattern.first.is_a?(Symbol)
         # Match an astlet
@@ -96,7 +150,7 @@ module Furnace::AST
 
         if astlet.is_a? Node
           if astlet.type == type
-            submatch(astlet.children, rest)
+            submatch(astlet.children, rest, captures)
           else
             false
           end
@@ -106,7 +160,7 @@ module Furnace::AST
       else
         # Match an array
         if astlet.is_a? Array
-          submatch(astlet, pattern)
+          submatch(astlet, pattern, captures)
         else
           false
         end

data/lib/furnace/ast/matcher_special.rb

@@ -1,13 +1,20 @@
 module Furnace::AST
   class MatcherSpecial
-    attr_reader :type, :params
+    attr_reader :type, :param
 
-    def initialize(type, params=nil)
-      @type, @params = type, params
+    def initialize(type, param=nil)
+      @type, @param = type, param
     end
 
-    def self.define(type)
-      lambda { |*args| new(type, args) }
+    class << self
+      def define(type)
+        lambda { |*args| new(type, args) }
+      end
+
+      def kind(type)
+        @kind_lambdas       ||= {}
+        @kind_lambdas[type] ||= lambda { |m| m.is_a?(MatcherSpecial) && m.type == type }
+      end
     end
   end
 end

data/lib/furnace/ast/node.rb

@@ -42,6 +42,16 @@ module Furnace::AST
       node
     end
 
+    def ==(other)
+      if other.respond_to? :to_astlet
+        other = other.to_astlet
+        other.type == self.type &&
+          other.children == self.children
+      else
+        false
+      end
+    end
+
     def index
       parent.children.find_index(self)
     end

data/lib/furnace/version.rb

@@ -1,3 +1,3 @@
 module Furnace
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: furnace
 version: !ruby/object:Gem::Version 
-  hash: 148493004
+  hash: 246344429
   prerelease: 
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Peter Zotov
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-01-26 00:00:00 Z
+date: 2012-01-28 00:00:00 Z
 dependencies: []
 
 description: Furnace is a static code analysis framework for dynamic languages, aimed at efficient type and behavior inference.