reg 0.4.8 → 0.5.0a0

data/lib/regxform.rb

@@ -0,0 +1,212 @@
+=begin copyright
+    reg - the ruby extended grammar
+    Copyright (C) 2016  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 'reg'
+require 'regcompiler' #but then breaks it!
+
+#use of this file breaks the compiler.
+#only trees are supported. maybe dags if you're lucky.
+#not full graphs.
+#array matchers are not supported currently.
+
+module Reg
+  module Reg
+    def xform!(datum,changed={})
+      datum or fail
+      Thread.current[:Reg_xform_session]=session={}
+      changed.merge!(session) if self===datum
+    ensure
+      Thread.current[:Reg_xform_session]=nil
+    end
+  end
+
+  class Bound
+    def === other #this is a hack
+      result= @reg===other
+      session=Thread.current[:Reg_xform_session]
+      if result and session and !session.has_key? @name
+        session[@name]=other
+      end
+      return result
+    end
+
+    def formula_value other,session #another hack...
+      result= @reg.formula_value other,session
+      
+      if session and !session.has_key? @name
+        session[@name]=result
+      end
+      return result
+    end
+  end
+
+  class BoundRef
+    def inspect
+      "~:#{name}"
+    end
+    def === other #this is a hack
+      session=Thread.current[:Reg_xform_session]
+      if session and session.has_key? @name
+        session[@name]==other
+      else raise NameNotBound #name not bound yet? that's an error
+      end
+    end
+
+    def formula_value(other,session)
+      warn "warning: BoundRef #{inspect} value missing" if !session.has_key?(name) and session["final"] 
+      session.fetch(name,session["final"] ? nil : self)
+    end
+  end
+
+  module Formula  #more hackery
+    def % other
+      if Symbol===other
+        Reg::Bound.new(self,other)
+      else
+        super
+      end
+    end
+  end
+
+  module Composite
+    def at_construct_time(*args)
+      #do nothing, no infections at all are appropriate when using this file
+    end
+  end
+
+  class NameNotBound<RuntimeError; end
+  class ReplacingNilError<RuntimeError; end
+
+  class Transform
+    def inspect
+      from.inspect+" >> "+to.inspect
+    end
+    def === other #this is a hack
+      result= from===other
+      session=Thread.current[:Reg_xform_session]
+      if result and session
+        raise ReplacingNilError,"replaces of nil or false are not allowed" unless other
+        locals={:self=>other}
+        if $&
+          locals[:$&]=$&
+          locals[:$`]=$`
+          locals[:$']=$'
+          $&.to_a.each_with_index{|br,i| locals[:"$#{i}"]=br }
+        end
+        session.each_pair{|name,val| locals[name]=val if ::Symbol===name } #hacky... names shouldn't need to be frozen here
+        session[other.__id__]=WithBoundRefValues.new(to,locals)
+
+=begin
+          case to
+          when Replace::Form; to.fill_out_simple(locals,other) #should handle Literals as well...
+          when BoundRef; to.formula_value(other,locals) #must be eval'd early...?
+          when Formula; WithBoundRefValues.new(to,locals)
+          else to
+          end
+=end
+      end
+      return result
+    end
+  end
+
+  class Replace::Form
+    def formula_value other,session
+      fill_out_simple session,other
+    end
+  end
+ 
+  class And
+    def === other  #hack around bugs in AndMachine
+      @regs.each{|reg| return unless reg===other }
+      return other||true
+    end
+    def multiple_infection(*args) end #hacky, never do anything for Reg::And
+  end
+
+  class Or
+    def multiple_infection(*args) end #hacky, never do anything for Reg::Or
+  end
+  class Hash
+    def multiple_infection(*args) end #hacky, never do anything for Reg::Hash
+  end
+  class Object
+    def multiple_infection(*args) end #hacky, never do anything for Reg::Object
+  end
+  class Trace
+    def multiple_infection(*args) end #hacky, never do anything for Reg::Trace
+  end
+  class BP
+    def multiple_infection(*args) end #hacky, never do anything for Reg::BreakPoint
+  end
+
+  class Finally
+    def ===(other)
+      result= @reg===other
+      session=Thread.current[:Reg_xform_session]
+      if result and session
+        session["finally"]||=[]
+        session["finally"]<<[@block,other]
+      end
+      result
+    end
+  end
+
+  class<<Object
+    alias new__without_nested_nil_replacer_fix new
+    IMMEDIATES=[nil,false,true,0,:symbol,Class]
+    def new *args
+      hash= (::Hash===args.last ? args.pop : {})
+      replacing_immediate,normal={},{}
+      hash.each_pair{|keymtr,valmtr| 
+        if ::Reg::Transform===valmtr and !IMMEDIATES.grep(valmtr).empty? and ::Symbol===keymtr
+          transform=valmtr
+          normal[keymtr]=transform.from
+          replacing_immediate[keymtr]=transform.to
+        else
+          normal[keymtr]=valmtr
+        end
+      }
+      args.push normal
+      result=new__without_nested_nil_replacer_fix(*args)
+      unless replacing_immediate.empty?
+        result=result.finally{|x,session|
+          replacing_immediate.each_pair{|key,to|
+            x.send "#{key}=",to.formula_value(x.send(key),session)
+          }
+        }
+      end
+      return result
+    end
+  end
+end
+
+tests=proc{
+  require 'test/unit'
+  class XformTests<Test::Unit::TestCase
+    alias assert_op assert_operator
+    def test_and_with_bound_and_replace
+      assert_op String>>"bop", :===, "sdfsdf"
+      assert String>>"bop" === "sdfsdf"
+      assert_op +{ :body=>String >> 'bop' }, :===, {:body => "23423"}
+      assert_op (/sdfgdf/ | Hash )%:top & +{ :body=>String >> 'bop' }, :===, {:body => "23423"}
+      assert_op( (((/7869/ | Hash )%:top) & +{ :body=>String >> 'sdf' }) | Symbol, :===, Hash[:body, "4564563"] )
+      assert_op( ((((/7869/ | Hash )%:top) & +{ :body=>String >> 'sdf' }) | Symbol).trace, :===, Hash[:body, "4564563"] )
+    end
+  end
+}
+tests[] if __FILE__==$0

data/{trace.rb → lib/trace_during.rb}

@@ -1,6 +1,6 @@
 =begin copyright
     reg - the ruby extended grammar
-    Copyright (C) 2005  Caleb Clausen
+    Copyright (C) 2005, 2016  Caleb Clausen
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Lesser General Public
@@ -20,7 +20,7 @@
 
 module Kernel
 private
-  def trace(traces)
+  def trace_during(traces)
     if Proc===traces 
       handler=traces
       traces=nil
@@ -38,8 +38,10 @@ private
       result=yield
     ensure
       #attempt to remain debuggable while restoring the old trace func
-      set_trace_func((defined? DEBUGGER__ and (DEBUGGER__.context.method:trace_func).to_proc))
+      set_trace_func(
+        (defined? DEBUGGER__ and (DEBUGGER__.context.method:trace_func).to_proc)
+      )
     end
     result
   end
-end
+end

data/lib/warning.rb

@@ -0,0 +1,37 @@
+=begin copyright
+    reg - the ruby extended grammar
+    Copyright (C) 2016  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
+module Kernel
+  def warning(msg)
+    (
+     (defined? $Debug) && $Debug or 
+     (defined? $DEBUG) && $DEBUG or 
+     (defined? $VERBOSE) && $VERBOSE
+    ) or return
+
+    #emit each warning only once
+    @@seenit__||={}
+    clr=caller[0]
+    callerid,mname=clr.match(/^(.*:[0-9]+)(?::in (.*))?$/)[1..2]
+    mname=mname[1..-2] if /^`.*'$/===mname
+    @@seenit__[callerid] and return
+    @@seenit__[callerid]=1
+  
+    warn [callerid,": warning: (",mname,") ",msg].join
+  end  
+end

data/parser.txt

@@ -1,3 +1,21 @@
+=begin copyright
+    reg - the ruby extended grammar
+    Copyright (C) 2016  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
 Lalr(n) parsing with reg
 
 Yesterday, I introduced my the Ruby Extended Grammar, a pattern matching 
@@ -48,11 +66,11 @@ The heart of the parser are its grammar rules, reproduced here:
 
 #last element is always lookahead
 Reduce=
-  -[ -[:p, '(', exp, ')'].sub {PrintExp.new BR[2]},  OB ] |                # p(exp)
-  -[ -['(', exp, ')']    .sub {BR[1]},               OB ] |                # (exp)
-  -[ -[exp, leftop, exp] .sub {OpExp.new *BR[0..2]}, regproc{lowerop(BR[1])} ] |    # exp+exp
+  -[ -[:p, '(', exp, ')'].sub {PrintExp.new BR(2)},  OB ] |                # p(exp)
+  -[ -['(', exp, ')']    .sub {BR(1)},               OB ] |                # (exp)
+  -[ -[exp, leftop, exp] .sub {OpExp.new *BR(0..2)}, regproc{lowerop(BR(1))} ] |    # exp+exp
   -[ exp, -[';']         .sub [],                    :EOI ] |              #elide final trailing ;
-  -[ -[name, '=', exp]   .sub {AssignExp.new BR[0],BR[2]}, lowerop('=') ]  #name=exp
+  -[ -[name, '=', exp]   .sub {AssignExp.new BR(0),BR(2)}, lowerop('=') ]  #name=exp
 
 Precedence is handled by the middle rule. This rule reduces infix operator 
 expressions (except =). It only matches if the lookahead does not contain a 
@@ -157,11 +175,11 @@ end
 
 #last element is always lookahead
 Reduce=
-  -[ -[:p, '(', exp, ')'].sub {PrintExp.new BR[2]},  OB ] |                # p(exp)
-  -[ -['(', exp, ')']    .sub {BR[1]},               OB ] |                # (exp)
-  -[ -[exp, leftop, exp] .sub {OpExp.new *BR[0..2]}, regproc{lowerop(BR[1])} ] |    # exp+exp
+  -[ -[:p, '(', exp, ')'].sub {PrintExp.new BR(2)},  OB ] |                # p(exp)
+  -[ -['(', exp, ')']    .sub {BR(1)},               OB ] |                # (exp)
+  -[ -[exp, leftop, exp] .sub {OpExp.new *BR(0..2)}, regproc{lowerop(BR[1])} ] |    # exp+exp
   -[ exp, -[';']         .sub [],                    :EOI ] |              #elide final trailing ;
-  -[ -[name, '=', exp]   .sub {AssignExp.new BR[0],BR[2]}, lowerop('=') ]  #name=exp
+  -[ -[name, '=', exp]   .sub {AssignExp.new BR(0),BR(2)}, lowerop('=') ]  #name=exp
 
 #last element of stack is always lookahead
 def reduceloop(stack)

data/philosophy.txt

@@ -1,3 +1,21 @@
+=begin copyright
+    reg - the ruby extended grammar
+    Copyright (C) 2016  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
 
 
 That's a long story, and well worth telling. 

data/reg.gemspec

@@ -1,29 +1,62 @@
-require 'rubygems'
+# -*- encoding: utf-8 -*-
+=begin copyright
+    reg - the ruby extended grammar
+    Copyright (C) 2016  Caleb Clausen
 
-spec = Gem::Specification.new do |s|
-    s.name = 'reg'
-    s.rubyforge_project = 'reg'
-    s.version = '0.4.8'
-    s.summary = 'The reg pattern matching/replacement language'
-    s.files = %w[item_thattest.rb regbackref.rb regknows.rb regtest.rb
-                 numberset.rb regbind.rb reglogic.rb regvar.rb
-                 COPYING parser.txt regcase.rb reglookab.rb           
-                 README regcore.rb regold.rb reg.gemspec reggrid.csv            
-                 assert.rb philosophy.txt regdeferred.rb regpath.rb 
-                 regposition.rb trace.rb calc.reg reg.rb   
-                 regguide.txt regprogress.rb reghash.rb regreplace.rb
-                 forward_to.rb regarray.rb regarrayold.rb regitem_that.rb regsugar.rb]
-    s.require_path = '.'
-    s.has_rdoc = false
-    s.requirements=["none"]
-    s.add_dependency("sequence", [">= 0.2.3"])
-    s.author = 'Caleb Clausen'
-    s.email = 'caleb @at@ inforadical.net'
-    s.homepage = 'http://github.com/coatl/reg'
-end
+    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
+dir=File.dirname(__FILE__)
+require "#{dir}/lib/reg/version"
+Reg::Description=open("#{dir}/README"){|f| f.read[/\A.*?\n\n.*?\n\n/m] } #customized
+Reg::Latest_changes="###"+open("#{dir}/History.txt"){|f| f.read[/\A===(.*?)(?====)/m,1] }
+
+Gem::Specification.new do |s|
+  s.name = "reg"
+  s.version = Reg::VERSION
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Caleb Clausen"]
+  s.date = Time.now.strftime("%Y-%m-%d")
+  s.email = %q{caleb (at) inforadical (dot) net}
+  s.extra_rdoc_files = ["README", "COPYING"]
+  s.files = `git ls-files`.split-['Rakefile']
+  s.files.reject!{|fn| %r{^ramblings/}===fn }
+  s.has_rdoc = true
+  s.homepage = %{http://github.com/coatl/reg}
+  s.rdoc_options = %w[--main README]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{reg}
+  s.rubygems_version = %q{1.3.0}
+  s.test_files = %w[test/test_all.rb]
+  s.summary = "Reg is a library for pattern matching in ruby data structures."
+  s.description = Reg::Description
+  s.license = 'LGPL-2.1'
 
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
 
-if $0==__FILE__
-#  Gem::manage_gems
-  Gem::Builder.new(spec).build
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<sequence>, [">= 0.2.4"])
+      s.add_runtime_dependency(%q<Ron>, [">= 0.1.2"])
+    else
+      s.add_dependency(%q<sequence>, [">= 0.2.4"])
+      s.add_dependency(%q<Ron>, [">= 0.1.2"])
+    end
+  else
+    s.add_dependency(%q<sequence>, [">= 0.2.4"])
+    s.add_dependency(%q<Ron>, [">= 0.1.2"])
+  end
 end

data/regguide.txt

@@ -1,3 +1,21 @@
+=begin copyright
+    reg - the ruby extended grammar
+    Copyright (C) 2016  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
 Note: this document is half skeleton right now. Eventually, I'll
 flesh this out into a more user-accessable description of Reg.