rewrite 0.2.0 → 0.3.0

data/lib/rewrite/by_example/object_to_matcher.rb

@@ -0,0 +1,221 @@
+$:.unshift File.dirname(__FILE__)
+
+require File.expand_path(File.dirname(__FILE__) +'/union_of_entities_sequence.rb')
+require File.expand_path(File.dirname(__FILE__) +'/symbol_entity.rb')
+require File.expand_path(File.dirname(__FILE__) +'/sexp_entity.rb')
+require File.expand_path(File.dirname(__FILE__) +'/returning.rb')
+
+module Rewrite
+  
+  module ByExample
+    
+    class ObjectToMatcher
+      
+      include Returning
+      
+      attr_reader :binders, :bind_arguments
+      
+      class << self
+        attr_accessor :debug
+        debug = false
+      end
+      
+      def self.binding (*bind_arguments)
+        if bind_arguments.empty?
+          @base_object_to_sequence ||= self.new()
+        else
+          self.new(*bind_arguments)
+        end
+      end
+      
+      def self.noisily
+        was = self.debug
+        begin
+          self.debug = true
+          yield
+        ensure
+          self.debug = was
+        end
+      end
+      
+      def self.quietly
+        was = self.debug
+        begin
+          self.debug = false
+          yield
+        ensure
+          self.debug = was
+        end
+      end
+      
+      def self.symbol_like_expression_matcher
+          @symbol_like_expression_matcher ||= 
+            returning(
+              quietly do
+                self.from_object(
+                  s(
+                    UnionOfEntitiesSequence.new(:gvar, :dvar, :vcall, :lcall, :lit),
+                    Bind.new(:variable_symbol, AnyEntity.new)
+                  )
+                ) 
+              end
+            ) do |slem|
+              p slem.to_s if self.debug
+            end
+      end
+      
+      def self.proc_capturer
+        @@proc_capturer ||= self.from_object(
+          s(:proc, nil,  Bind.new(:sexp, AnyEntity.new))
+        )
+      end
+      
+      def initialize (*bind_arguments)
+        @bind_arguments = bind_arguments
+        @binders = bind_arguments.map { |arg| bind_arg_to_binder(arg) }
+      end
+      
+      def from_example(&proc)
+        if unfolded = self.class.proc_capturer.unfold(proc.to_sexp)
+          self.from_object(unfolded[:sexp])
+        end
+      end
+      
+      def from_object o
+        matcher = convert(o)
+        raise "#{o.to_s} => #{matcher.to_s} does not describe a matcher" unless matcher.kind_of? EntityMatcher
+        matcher
+      end
+      
+      def self.from_example(&proc)
+        (@o2s_from_object ||= self.new).from_example(&proc)
+      end
+      
+      def self.from_object o
+        (@o2s_from_object ||= self.new).from_object(o)
+      end
+      
+      def self.from_sexp(*elements)
+        from_object(elements)
+      end
+      
+      protected
+      
+      def convert(o)
+        p "***** #{o.to_s}" if self.class.debug
+        matcher = if o.kind_of? Sequence
+          o
+        elsif o.kind_of? EntityMatcher
+          o
+        elsif o.kind_of? Symbol
+          from_symbol(o)
+        elsif o.nil?
+          NilEntity.new
+        elsif o.kind_of? Array
+          p "#{o.inspect}.kind_of? Array" if self.class.debug
+          from_sexp(o)
+        else
+          raise "Don't know how to handle #{o.inspect}"
+        end
+        p "returning #{matcher.to_s} given #{o.to_s}" if self.class.debug
+        matcher
+      end
+      
+      private
+      
+      #--
+      #
+      # Changed this to avoid matching... but do we need it?
+      # When would we match this and not match sexp?
+      def from_symbol(sym)
+        self.binders.each do |binder|
+          if bound_object = binder.call(sym)
+            p "handling symbol #{sym.inspect} as bound match #{bound_object.to_s}" if self.class.debug
+            return bound_object
+          end
+        end
+        p "handling symbol #{sym.inspect} as itself" if self.class.debug
+        SymbolEntity.new(sym)
+      end
+      
+      def from_sexp(sexp)
+        self.binders.each do |binder|
+          if bound_object = binder.call(sexp)
+            p "handling sexp #{sexp.to_s} as bound match #{sexp.to_s}" if self.class.debug
+            return bound_object
+          end
+        end
+        p "decomposing sexp #{sexp.to_s}" if self.class.debug
+        SexpEntity.for_sequence(
+          Composition.new(
+            *(sexp.map { |sub_sexp| 
+                obj = ObjectToMatcher.binding(*bind_arguments).convert(sub_sexp)
+                if obj.kind_of? Sequence
+                  obj
+                else
+                  LengthOne.new(obj)
+                end
+              }
+            )
+          )
+        )
+      end
+      
+      def bind_arg_to_binder(bind_arg)
+        p "trying to make a binder for #{bind_arg.inspect}" if self.class.debug
+        if bind_arg.is_a?(Array) && bind_arg.length == 1 && pattern = object_to_pattern(bind_arg.first)
+          p "binding sequence pattern #{pattern} for #{bind_arg.inspect}" if self.class.debug
+          lambda { |sexp_or_symbol|
+            p "trying to match #{sexp_or_symbol} against #{pattern.source}" if self.class.debug
+            unfolded = ObjectToMatcher.symbol_like_expression_matcher.unfold(sexp_or_symbol)
+            p "unfolded is #{unfolded.inspect}" if self.class.debug
+            symbol = unfolded[:variable_symbol] if unfolded
+            p "symbol is #{symbol.inspect}" if self.class.debug
+            name = symbol.to_s[pattern,1] if symbol
+            p "name is #{name.inspect}" if self.class.debug
+            if name
+              BindSequence.new(name)
+            elsif sexp_or_symbol.is_a?(Symbol) && name = sexp_or_symbol.to_s[pattern,1]
+              BindSequence.new(name)
+            end
+          }
+        elsif pattern = object_to_pattern(bind_arg)
+          p "binding entity pattern #{pattern.source} to #{bind_arg.inspect}" if self.class.debug
+          lambda { |sexp_or_symbol|  
+            p "trying to match #{sexp_or_symbol} against #{pattern.source}" if self.class.debug
+            unfolded = ObjectToMatcher.symbol_like_expression_matcher.unfold(sexp_or_symbol)
+            p "unfolded is #{unfolded.inspect}" if self.class.debug
+            symbol = unfolded[:variable_symbol] if unfolded
+            p "symbol is #{symbol.inspect}" if self.class.debug
+            name = symbol.to_s[pattern,1] if symbol
+            p "name is #{name.inspect}" if self.class.debug
+            if name
+              Bind.new(name, AnyEntity.new)
+            elsif sexp_or_symbol.is_a?(Symbol) && name = sexp_or_symbol.to_s[pattern,1]
+              Bind.new(name, AnyEntity.new)
+            end
+          }
+        else
+          raise "unable to make a binder for #{bind_arg.inspect}"
+        end
+      end
+      
+      def self.object_to_pattern(pattern_string_or_symbol)
+        if pattern_string_or_symbol.is_a?(Regexp)
+          pattern_string_or_symbol
+        elsif pattern_string_or_symbol.is_a?(String) || pattern_string_or_symbol.is_a?(Symbol)
+          Regexp.new("^(#{pattern_string_or_symbol.to_s})$")
+        else
+          nil
+        end
+      end
+      
+      def object_to_pattern(arg)
+        self.class.object_to_pattern(arg)
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/rewrite/by_example/returning.rb

@@ -0,0 +1,29 @@
+$:.unshift File.dirname(__FILE__)
+
+module Rewrite
+  
+  module ByExample
+    
+    module Returning
+      module ClassMethods
+        def returning(something)
+          yield something if block_given?
+          something
+        end
+      end
+      
+      module InstanceMethods
+        def returning(something)
+          ClassMethods.returning(something)
+        end
+      end
+      
+      def self.included(receiver)
+        receiver.extend         ClassMethods
+        receiver.send :include, InstanceMethods
+      end
+    end
+    
+  end
+  
+end

data/lib/rewrite/by_example/sequence.rb

@@ -0,0 +1,57 @@
+$:.unshift File.dirname(__FILE__)
+
+module Rewrite
+  
+  module ByExample
+    
+    # Base class fo all classes that match one or more entities within a list.
+    #
+    # Includes some backtracking magic to handle cases isomorphic to /.*foo/
+    class Sequence
+      
+      # unfolders takes a length and answers a (possible empty) Enumerable of lambdas, 
+      # each of which has the method #call(array) and returning an unfold.
+      #
+      # Now obviously this means that there are three different ways to represent alternation.
+      # First, if a sequence matches two things of different lengths, like A | AA, it returns
+      # A for unfolders_by_length(1) and AA for unfolders_by_length(2). However, if a sequence
+      # matches two things of the same length, tehre are two different ways to represent that.
+      #
+      # For example, if a sequence matches A | B, it can do either of:
+      # 
+      # unfolders_by_length(1) =>
+      #   [ lambda { |arr| A =~ arr.first }, lambda { |arr| B =~ arr.first } ]
+      #
+      # or:
+      #
+      # unfolders_by_length(1) =>
+      #   [ lambda { |arr| A =~ arr.first || B =~ arr.first } ]
+      #
+      # Note the difference: The first example returns two lambdas, one matching A and the
+      # other matching B. the second example returns a single lambda matching A or B.
+      #
+      # When would you use one over the other? The first example is to be used when you wish
+      # to support backtracking. The second example is to be used when you do not wish to
+      # support backtracking.
+      # 
+      def unfolders_by_length(length)
+        raise 'implemented by subclass'
+      end
+      remove_method :unfolders_by_length
+      
+      # Answer a range of possible lengths
+      def length_range
+        raise 'implemented by subclass'
+      end
+      remove_method :length_range
+      
+      def fold(enum_of_bindings)
+        raise "Subclass #{self.class} should implement fold"
+      end
+      remove_method :fold
+      
+    end
+    
+  end
+  
+end

data/lib/rewrite/by_example/sexp_entity.rb

@@ -0,0 +1,51 @@
+$:.unshift File.dirname(__FILE__)
+
+module Rewrite
+  
+  module ByExample
+    
+    # A SexpEntity is a matcher that is initialized with example sexps,
+    # so it matches a literal tree. I think SexpEntity is right, however
+    # not all things you build with ObjectToSequence are Sexps?
+    class SexpEntity < EntityMatcher
+      
+      attr_accessor :sequence
+      
+      def initialize(*foo)
+        raise "refactor to ObjectToMatcher" unless foo.empty?
+        raise "refactor to ObjectToMatcher" if block_given?
+      end
+      
+      def self.for_sequence(sequence)
+        s = SexpEntity.new
+        s.sequence = sequence
+        return s
+      end
+      
+      def unfold (sexp)
+        if sexp.kind_of? Array
+          self.sequence.unfolders_by_length(sexp.length).each { |unfolder|
+            unfolded = unfolder.call(sexp)
+            return unfolded if unfolded && (predicate.nil? || predicate.call(unfolded))
+          }
+          nil
+        end
+      end
+      
+      def fold (enum_of_bindings)
+        self.sequence.fold(enum_of_bindings)
+      end
+      
+      def to_s
+        "s( #{sequence.to_s} )"
+      end
+      
+      def self.proc_capturer
+        SexpEntity.new(:proc, nil,  Bind.new(:sexp, AnyEntity.new))
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/rewrite/by_example/symbol_entity.rb

@@ -0,0 +1,37 @@
+$:.unshift File.dirname(__FILE__)
+
+module Rewrite
+  
+  module ByExample
+    
+    # Matches a specific symbol: SymbolEntity.new(:foo) matches :foo.
+    #
+    # Note that this is not the same thing as matching the use of a symbol in Ruby
+    # code, because a literal symbol in Ruby is actually represented as:
+    #
+    #   s(:lit, :foo)
+    class SymbolEntity < EntityMatcher
+      
+      attr_accessor :symbol
+      
+      def initialize(symbol)
+        self.symbol = symbol
+      end
+      
+      def unfold (sexp)
+        {} if self.symbol == sexp
+      end
+      
+      def fold (enum_of_bindings)
+        self.symbol
+      end
+      
+      def to_s
+        ":#{self.symbol.to_s}"
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/rewrite/by_example/unhygienic.rb

@@ -0,0 +1,57 @@
+$:.unshift File.dirname(__FILE__)
+
+require 'rubygems'
+require 'sexp_processor'
+
+module Rewrite
+  
+  module ByExample
+    
+    #--
+    #
+    # TODO: 'mixed modes' such that we can write string_to_proc as an unhygienic
+    # TODO: composable unhygienics (entity matchers are already composable)
+    # TODO: how would we rename variable references safely with unhygienics?
+    #       CSS model (heterogeneous patterns)? Combinatoral?
+    class Unhygienic < SexpProcessor
+      
+      attr_accessor :from_unfolder, :to_folder, :bind_arguments
+      
+      def from(*bind_arguments, &proc)
+        self.bind_arguments = bind_arguments
+        self.from_unfolder = ObjectToMatcher.binding(*self.bind_arguments).from_example(&proc)
+        self
+      end
+      
+      def to(&proc)
+        self.to_folder = ObjectToMatcher.binding(*self.bind_arguments).from_example(&proc)
+        self
+      end
+      
+      def self.from(*bind_arguments, &proc)
+        self.new.from(*bind_arguments, &proc)
+      end
+      
+      def process(exp)
+        raise "Need a from unfolder" unless from_unfolder
+        raise "Need a to folder" unless to_folder
+        Rewrite.recursive_s(process_inner(exp))
+      end
+      
+      def process_inner(exp)
+        if exp.is_a? Array
+          exp = exp.map { |sub_exp| process_inner(sub_exp) }
+        end
+        if unfolded = from_unfolder.unfold(exp) 
+          if refolded = to_folder.fold(unfolded)
+            exp = refolded
+          end
+        end
+        exp
+      end
+      
+    end
+    
+  end
+  
+end