reference 0.5

data/reference.rb

@@ -0,0 +1,210 @@
+#!/bin/env ruby
+# Author::   Eric Mahurin
+# License::  Ruby license
+
+# These base references are defined simply by get and set procs.  The
+# dereferencing methods [] (get) and []= (set) will just call these procs.
+#  
+#  require 'reference'
+#  
+#  # multiple ways to make a reference to lines in stdin/stdout
+#  lineref = Reference.new(method(:gets),method(:puts))
+#  lineref = Reference.new(proc{gets},proc{|v|puts(v)})
+#  line = lineref[] # line = gets
+#  lineref[]="hello world!" # puts("hello world!")
+class Reference
+    
+    # Create a reference given get and set procs.
+    def initialize(getter,setter)
+        @getter = getter
+        @setter = setter
+    end
+    # Get the value of the referenced thing.  Optional arguments may modify
+    # the meaning of what is referenced.
+    # Will simply call the get proc for the base class.
+    def [](*args)
+        @getter[*args]
+    end
+    # Set the value of the referenced thing.  The last argument (required)
+    # is taken as the value.  Optional preceding arguments may modify the
+    # meaning of what is referenced.
+    # Will simply call the set proc for the base class.
+    def []=(*args)
+        @setter[*args]
+    end
+    
+end
+
+class Binding
+
+    # Do an eval in the binding context
+    def eval(s,*file_line)
+        Kernel.eval(s,self,*file_line)
+    end
+    # Get a variable/expression (Symbol or String) in the binding context.
+    def variable_get(var)
+        eval(var.to_s)
+    end
+    # Set a variable/expression (Symbol or String) in the binding context.
+    def variable_set(var,value)
+        eval("proc{|_v| #{var} = _v}")[value]
+    end
+    # Create a reference to an assignable variable or expression that is
+    # accessible within the binding context.
+    def variable_reference(var)
+        Reference.new(
+            eval("proc { #{var} }"),
+            eval("proc {|_v| #{var} = _v }")
+        );
+    end
+    # Provide access to the object of the binding context.
+    def self()
+        eval("self")
+    end
+    # Return a Proc for the given method (Symbol or String) of the binding
+    # context.
+    def method(meth)
+        eval("proc{|*_a,&_b| #{meth}(*_a,&_b)}")
+    end
+    # Call the method in the binding context for anything else.
+    def method_missing(meth,*args,&block)
+        eval("proc{|*_a,&_b| #{meth}(*_a,&_b)}").call(*args,&block)
+    end
+
+end
+
+class Object
+
+    # This class serves dual purposes.  It can act as an object Reference or
+    # a Reference maker (for attribute like methods of this object)
+    class ObjectReference < Reference
+        
+        # Create an ObjectReference
+        def initialize(obj)
+            @obj = obj
+        end
+        # With no arguments, this will dereference returning the object.  With
+        # arguments, it will create a Reference using method_missing.
+        def [](*args)
+            if args.size==0
+                @obj
+            else
+                method_missing(:"[]",*args)
+            end
+        end
+        # Deferencing set.  To set the object it will use the <tt>replace</tt>
+        # method of the object if available or try the <tt>become</tt> method
+        # (see evil.rb).  This will not work on immediate objects.
+        def []=(obj)
+            if @obj.respond_to?:replace
+                @obj.replace(obj)
+            else
+                @obj.become(obj) # need evil.rb
+            end
+            @obj
+        end
+        # Create a reference from this method (get) and this method + "=" (set).
+        # <i>args</i> will start the argument list.  [] and []= calls from the
+        # reference will fill out the remainder of the argument list for these
+        # methods.
+        def method_missing(method,*args)
+            get = @obj.method(method)
+            set = @obj.method(method.to_s<<"=")
+            if args.size>0
+                getter = proc { |*a| get[*(args+a)] }
+                setter = proc { |*a| set[*(args+a)] }
+            else
+                getter = get
+                setter = set
+            end
+            Reference.new(getter,setter)
+        end
+        
+    end
+    # Provides an easy way to create a Reference.  There are several ways to do
+    # it:
+    #  
+    # * ref { <i>symbol</i> }
+    # * ref { <i>expression-string</i> }
+    # * <i>obj</i>.ref
+    # * <i>obj</i>.ref.<i>method</i>(<i>arguments</i>)
+    # * <i>obj</i>.ref(<i>getsymbol</i>,<i>putsymbol</i>,<i>arguments</i>)
+    # * <i>obj</i>.ref([<i>getsymbol</i>,<i>getargs</i>],[<i>putsymbol</i>,<i>putargs</i>],<i>more-args</i>)
+    #  
+    # Here are some examples:
+    #
+    #  require 'reference'
+    #  a = ("a".."h").to_a       # ["a", "b", "c", "d", "e", "f", "g", "h"]
+    #  b = a                     # b and a have the same object
+    #  p = ref{:a}               # reference to the variable :a
+    #  q = a.ref                 # reference to the object in a
+    #  r = ref{"a[4]"}           # reference to the assignable expression a[4]
+    #  s = a.ref[4]              # reference to the [4] attribute of a
+    #  t = a.ref.[](4)           # same
+    #  u = a.ref(:"[]",:"[]=",4) # same except set/get method names are explicit
+    #  v = a.ref([:"[]",4],[:"[]=",4]) # same except arguments are explicit
+    #  p[]                       # ["a", "b", "c", "d", "e", "f", "g", "h"]
+    #  p[] = (0..7).to_a         # [0, 1, 2, 3, 4, 5, 6, 7]
+    #  a                         # [0, 1, 2, 3, 4, 5, 6, 7]
+    #  b                         # ["a", "b", "c", "d", "e", "f", "g", "h"]
+    #  q[]                       # ["a", "b", "c", "d", "e", "f", "g", "h"]
+    #  q[] = (-7..0).to_a        # [-7, -6, -5, -4, -3, -2, -1, 0]
+    #  a                         # [0, 1, 2, 3, 4, 5, 6, 7]
+    #  b                         # [-7, -6, -5, -4, -3, -2, -1, 0]
+    #  r[]                       # 4   
+    #  r[] = "r"                 # "r"
+    #  a                         # [0, 1, 2, 3, "r", 5, 6, 7]
+    #  b                         # [-7, -6, -5, -4, -3, -2, -1, 0]
+    #  # extra arg is slice length
+    #  s[2]                      # [-3, -2]
+    #  s[2] = ["s"]              # ["s"]
+    #  a                         # [0, 1, 2, 3, "r", 5, 6, 7]
+    #  b                         # [-7, -6, -5, -4, "s", -1, 0]
+    #  t[]                       # "s"
+    #  t[] = "t"                 # "t"
+    #  a                         # [0, 1, 2, 3, "r", 5, 6, 7]
+    #  b                         # [-7, -6, -5, -4, "t", -1, 0]
+    #  u[]                       # "t"
+    #  u[] = "t"                 # "u"
+    #  a                         # [0, 1, 2, 3, "r", 5, 6, 7]
+    #  b                         # [-7, -6, -5, -4, "u", -1, 0]
+    #  v[]                       # "t"
+    #  v[] = "t"                 # "v"
+    #  a                         # [0, 1, 2, 3, "r", 5, 6, 7]
+    #  b                         # [-7, -6, -5, -4, "v", -1, 0]
+    #
+    def reference(*args,&block)
+        if block
+            args.size==0 or raise(ArgumentError,"no arguments allowed when block given")
+            block.binding.variable_reference(block[])
+        elsif args.size>0
+            get,set,*args = *args
+            if get.kind_of?Array
+                get,*getargs = *(get+args)
+            else
+                getargs = args
+            end
+            set ||= get.to_s<<"="
+            if set.kind_of?Array
+                set,*setargs = *(set+args)
+            else
+                setargs = args
+            end
+            get = self.method(get)
+            set = self.method(set)
+            if getargs.size>0 then getter = proc { |*a| get[*(getargs+a)] }
+            else getter = get
+            end
+            if setargs.size>0 then setter = proc { |*a| set[*(setargs+a)] }
+            else setter = set
+            end
+            Reference.new(getter,setter)
+        else
+            ObjectReference.new(self)
+        end
+    end
+    alias ref reference
+    
+end
+
+

metadata

@@ -0,0 +1,37 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.10
+specification_version: 1
+name: reference
+version: !ruby/object:Gem::Version 
+  version: "0.5"
+date: 2005-05-08
+summary: provides reference/pointer functionality of other languages
+require_paths: 
+  - "."
+email: 
+homepage: 
+rubyforge_project: reference
+description: 
+autorequire: reference
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+authors: 
+  - Eric Mahurin
+files: 
+  - reference.rb
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: []