reg 0.4.6

data/reghash.rb

@@ -0,0 +1,318 @@
+
+=begin copyright
+    reg - the ruby extended grammar
+    Copyright (C) 2005  Caleb Clausen
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+=end
+
+
+require 'forward_to'
+
+
+
+module Reg
+
+  class Hash
+    include Reg
+    attr :others
+    
+    def initialize(hashdat=nil)
+      @matchers={}
+      @literals={}
+      @others=nil
+      hashdat or return 
+      hashdat.key?(OB) and @others=hashdat.delete(OB) 
+      hashdat.each {|key,val| 
+        if Reg.interesting_matcher? key
+          Fixed===key and key=key.unwrap
+          @matchers[key]=val
+        else
+          Equals===key and key=key.unwrap
+          @literals[key]=val
+        end
+      }    
+    end
+
+    def Hash.[](*args); new(*args); end
+
+    def matches_class; ::Hash end
+    
+    def ordered
+      pairs=[]
+      @literals.each{|k,v| pairs<< Pair[k,v] }
+      @matchers.each{|k,v| pairs<< Pair[k,v] }
+      pairs<<Pair[OB,@others] if @others
+      return +pairs
+    end
+
+    def subregs;
+      @literals.keys + @literals.values +
+      @matchers.keys + @matchers.values + 
+      (@others==nil ? [OB,@others] : [])
+    end
+    
+    def inspect
+      result=[]
+      result<<@literals.inspect.sub(/.(.*)./, "\\1") unless @literals.empty?
+      result<<@matchers.inspect.sub(/.(.*)./, "\\1") unless @matchers.empty?
+      result<<"OB=>#{@others.inspect}"  if defined? @others and @others!=nil
+      return "+{#{result.join(", ")}}"
+    end
+    
+    def -@ #make object matcher
+      Rob(@literals.merge(@matchers).merge(OB=>@others))
+    end
+    
+    def ===(other)
+      matchedliterals={}
+      matchedmatchers={}
+      other.each_pair{|key,val|
+        #literals get a chance first
+        @literals.key? key and 
+          if (@literals[key]===val)
+            matchedliterals[key]=true
+            next
+          else
+            return
+          end 
+        
+        #now try more general matchers
+        saw_matcher=nil
+        @matchers.each_pair{|mkey,mval|
+          if mkey===key
+            return unless (mval===val)
+            saw_matcher=matchedmatchers[mkey]=true
+            break 
+          end
+        }
+        
+        
+        #last of all, try the catchall
+        saw_matcher or @others===val or return
+      }
+      @literals.each_pair{|k,v| matchedliterals[k] or v==(other.default k) or return }
+      @matchers.each_pair{|k,v| matchedmatchers[k] or v===other.default or return }      
+      other.empty? and @literals.empty? and @matchers.empty? and return @others===other.default
+      return true
+    end
+
+ #tla of +{}
+assign_TLAs :Rah=>:Hash
+   
+  end
+  
+  #--------------------------
+  class OrderedHash
+    include Reg
+    def initialize(*args)
+      @keys=[]
+      @vals=[]
+      @others=nil
+      args.each{|a|
+        if Pair===a
+          l,r=a.left,a.right
+          Fixed===l and l=l.unwrap
+          if l==OB
+            @others=r
+          else
+            @keys<<l
+            @vals<<r
+          end
+        else
+          @keys<<a
+          @vals<<OB
+        end
+      }
+    end
+  
+    def ===(other)
+      matched=0
+      saw1=nil
+      other.each_pair do |ko,vo|
+        saw1=nil
+        @vals.each_index do|i| 
+            kr,vr=@keys[i],@vals[i]
+            if kr===ko 
+              vr===vo or return
+              saw1=matched |= 1<<i
+              break
+            end 
+        end
+        saw1 or (@others===vo or return)
+      end
+      @vals.each_index {|i|
+        unless (matched&(1<<i)).nonzero?
+          @vals[i]===other.default((@keys[i] unless Reg::interesting_matcher? @keys[i])) or return
+        end
+      }
+      other.empty? and @vals.empty? and  return @others===other.default
+#      @subhashes.each do|subhash|
+#        subhash===other or return false
+#      end
+      return other||true #huh need more complex result?      
+    end
+    
+    def self.[](*args); new(*args); end
+
+    def matches_class; ::Hash end
+    
+    def &; huh end
+    def inspect; 
+      "+[#{
+        map{|k,v| k.inspect+ ((Reg===k)? "" : ".reg") +
+                    "**"+v.inspect unless OB==k && nil==v
+        }.compact.join ", "
+      }]"
+    end
+    def subregs; huh end
+    
+    def each
+      @keys.each_index{|i|
+        yield @keys[i],@vals[i]
+      }
+      yield OB,@others
+    end
+    include Enumerable
+    
+    
+    def to_ruby
+      result= "def self.===(a_hash)\n"
+      result<<"  a_hash.each_pair{|k,v|\n"
+      result<<"    case k\n"
+      @keys.each_index{|i|
+        result<<"    when #{@keys[i]}: #{vals[i]}\n"
+      }
+      result<<"    else #{@other}\n" +
+              "    end===v or break\n" +
+              "  }\n" +
+              "end\n"
+      
+      return result
+    end
+  end
+
+  #--------------------------
+  class Object < Hash
+  #decending from Hash isn't particularly useful here
+  #it looks like everything (but &) is overridden, anyway
+
+    def initialize(*args)
+      hash= (::Hash===args.last ? args.pop : {})
+      @vars={}; @meths={}; @meth_matchers={}
+      hash.each_pair{|item,val|
+        if ::String===item or ::Symbol===item
+          item=item.to_s
+          (/^@@?/===item ? @vars : @meths)[item.to_sym]=val
+        else 
+          @meth_matchers[item]=val
+        end
+      }
+      @meths[:class]=args.shift if (Module===args.first)
+    end
+    def self.[](*args) new(*args); end
+
+
+    def inspect
+        "-{"+@vars.inspect.sub( /^.(.*).$/, '\\1') + 
+            @meths.inspect.sub(/^.(.*).$/, '\\1') + 
+            @meth_matchers.inspect.sub(/^.(.*).$/, '\\1') + "}"
+
+    end
+
+    def matches_class
+      @meths[:class] or Object
+    end
+
+    def -@ #make object matcher
+      self
+    end
+
+    def ===(other)
+      seenmeths=[];seenvars=[];seenmats=[]
+      @meths.each_pair{|name,val|
+        val===other.send(name) or return
+        seenmeths<<name
+      }
+      @vars.each_pair{|name,val|
+        val===other.instance_eval(name.to_s) or return
+        seenvars<<name
+      }
+      @meth_matchers.empty? or other.public_methods.each {|meth|
+        @meth_matchers.each_pair{|name, val| 
+          if name===meth 
+            val===other.send(meth) || return
+            seenmats<< name
+          end
+        }
+      }
+      @meths.keys.-(seenmeths).empty? or return
+      @vars.keys.-(seenvars).empty? or return
+      @meth_matchers.keys.-(seenmats).empty? or return
+      
+
+      return other || true
+      
+    rescue
+      return false
+    end
+
+  #tla of -{}
+  assign_TLAs :Rob=>:Object
+
+
+  end
+  
+  
+  #OrderedObject not even attempted yet
+  
+  module Reg
+    def **(other)
+      Pair[self,other]
+    end
+    alias has **
+  end
+
+  class Pair
+    include Reg
+    class<<self; alias [] new; end
+    
+    attr_reader :left,:right
+    
+    def initialize(l,r)
+      @left,@right=l,r
+    end
+
+if false    #not sure if i know what i want here...
+    def hash_cmp(hash,k,v)
+      @left
+    end
+    
+    def obj_cmp
+    end
+end  
+    #tla of **
+    assign_TLAs :Rap=>:Pair
+
+
+    
+  end
+
+
+
+end
+
+
+

data/regitem_that.rb

@@ -0,0 +1,146 @@
+=begin copyright
+    reg - the ruby extended grammar
+    Copyright (C) 2005  Caleb Clausen
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+=end
+require 'regdeferred.rb'
+
+module Reg
+  class <<self
+    #sugar forwards this from Kernel
+    def item_that(klass=nil,&block)
+      return ItemThat.new(klass) unless block
+       
+      class <<block
+          #include arguments to include appear to be processed in a strange order... this is 
+          #significant if order is important to you
+          #the #included methods are perhaps not called when i think they should be....
+          #(DON'T simplify the next line; it'll break.)
+        [BlankSlate ,Formula, BlockLike].each{|mod| include mod}
+        restore :inspect,:extend,:call
+
+        alias === eeee #workaround-- shouldn't be needed
+        alias formula_value call
+  #      undef eeee
+      end
+      block.klass=klass
+      block
+    end
+    alias item_is item_that
+  end
+
+ #----------------------------------
+  module BlockLike
+#    include Formula
+
+    attr_writer :klass #for internal use only
+
+    def eeee(val)
+      @klass and @klass===val || return
+      begin call(val)
+      rescue: false
+      end
+    end
+    alias === eeee #does nothing in includers.... why?
+    def formula_value *a,&b; call( *a,&b) end
+
+    
+    def mixmod; ItemThatLike end
+    def reg; dup.extend Reg end
+  end
+  
+ #----------------------------------
+  module DeferredQuery
+  #just an ancestor for ItemThat and RegThat
+    def eee(item)
+      begin formula_value item
+      rescue: false
+      end
+    end
+    alias === eee #this doesn't work!!! WHY????
+    #there's no way to define the method === in this
+    #module and have it be defined in class ItemThat.
+    #mixmod and reg don't have this problem. this must
+    #be a bug. for now, I work around it with clever 
+    #alias/undefing in places that include/extend ItemThatLike
+    #(seemingly, this is only a problem when including, not extending... dunno why)
+    #this bug may be gone now; need to try to get rid of weird eee stuff.
+  
+  end
+  
+  #----------------------------------
+  module ItemThatLike
+    include DeferredQuery
+    
+    def mixmod; ItemThatLike end
+    def reg; dup.extend RegThatLike end
+  end
+  
+  #----------------------------------
+  class ItemThat 
+    include BlankSlate
+    restore :inspect,:extend
+    include Formula
+    include ItemThatLike
+    alias === eee
+    undef eee
+    def initialize(klass=nil)
+      @klass=klass
+    end
+    
+    def formula_value(val,*rest)
+      #the exception raised here should be (eventually) caught by 
+      #the handler in ItemThatLike#eee. calling ItemThat#formula_value isn't
+      #really legitimate otherwise.
+      @klass and @klass===val || fail("item_that constraint mismatch")
+    
+      val
+    end
+    
+  end
+
+  #----------------------------------
+  module RegThatLike
+    include DeferredQuery
+    include Reg
+    
+    def mixmod; RegThatLike end
+  end
+  
+  #----------------------------------
+  class RegThat
+    include BlankSlate
+    restore :inspect,:extend
+    include Formula
+    include RegThatLike
+    alias === eee
+    undef eee
+    def initialize(klass=nil)
+      @klass=klass
+    end
+    
+    def formula_value(val,*rest)
+      #the exception raised here should be (eventually) caught by 
+      #the handler in RegThatLike#eee. calling RegThat#formula_value isn't
+      #really legitimate otherwise.
+      @klass and @klass===val || fail("item_that constraint mismatch")
+    
+      val
+    end
+    
+  end
+
+end