cheri 0.0.2

data/lib/cheri/builder/config.rb

@@ -0,0 +1,187 @@
+#--
+# Copyright (C) 2007 William N Dortch <bill.dortch@gmail.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+#
+
+module Cheri
+module Builder
+
+class Config
+  None = {}.freeze #:nodoc:
+  def initialize(*mods)
+    @m = [] # included modules
+    @f = {} # factories, indexed by module
+    @c = {} # connecters, indexed by module
+    # lazily allocated:
+    # @n = {} # consumers, indexed by module
+    # @r = {} # resolvers, indexed by module
+    mods.each do |mod| self << mod; end
+  end
+
+  def mods
+    @m
+  end
+
+  def factories
+    @f
+  end
+
+  def connecters
+    @c
+  end
+
+  def consumers
+    @n || None
+  end
+
+  def resolvers
+    @r || None
+  end
+
+  def <<(mod)
+    return if @m.include?(mod)
+    validate(mod) unless mod == Cheri::Builder
+    extendee = mod.respond_to?(:extends) ? mod.extends : nil
+    raise BuilderException,"extended builder module not included: #{extendee}" if extendee && !@m.include?(extendee)
+    #puts "config add mod #{mod}"
+    @m << mod
+    @f[mod] = mod.factory if mod.respond_to?(:factory) && mod.factory
+    @c[mod] = mod.connecter if mod.respond_to?(:connecter) && mod.connecter
+    (@n ||= {})[mod] = mod.consumer if mod.respond_to?(:consumer) && mod.consumer
+    (@r ||= {})[mod] = mod.resolver if mod.respond_to?(:resolver) && mod.resolver
+    #puts "@n = #{@n}"
+    extend_mod(extendee,mod) if extendee
+    self
+  end
+  alias_method :add, :<<
+
+  def extend_mod(mod,ext)
+    # get to the base module to be extended
+    mod = mod.extends while mod.respond_to?(:extends) && mod.extends
+
+    # if we're extending the factory...
+    if (fx = @f[ext])
+      if (fm = @f[mod])
+          # if there's already a factory, wrap it in a SuperFactory
+          # extender goes first so it can override
+        @f[mod] = SuperFactory[fx,fm]
+      else
+        # no factory, use the extender
+        @f[mod] = fx
+      end
+    end
+
+    # if we're extending the connecter...
+    if (cx = @c[ext])
+      # TODO: break apart mod/ext SuperConnecters to combine embedded type connecters?
+      # Right now all built-in/generated Cheri connecters are type connecters, so it's
+      # not an issue... yet...
+      if (cm = @c[mod])
+        if TypeConnecter === cm && TypeConnecter === cx
+          # if they're both TypeConnecters, create a combined TypeConnecter
+          # extender goes second so it can override
+          @c[mod] = TypeConnecter.new(cm,cx)
+        else
+          # otherwise, combine them in a SuperConnecter
+          # extender goes first so it can override
+          @c[mod] = SuperConnecter[cx,cm]
+        end
+      else
+        # no connecter, use extender
+        @c[mod] = cx
+      end
+    end
+
+    # if we're extending the consumer... (see comments for factory)
+    if @n && (nx = @n[ext])
+      if (nm = @n[mod])
+        @n[mod] = SuperConsumer[nx,nm]
+      else
+        @n[mod] = nx
+      end
+    end
+
+    # if we're extending the resolver...
+    # FIXME: this won't really work right now, at least for Java apps, which are
+    # the only ones likely to use this feature. the Java constant resolver wants
+    # all constant symbols from a single (virtual) source, and raises exceptions if
+    # it fails to resolve. coding it anyway, will rethink for next version.
+    if @r && (rx = @r[ext])
+      if (rm = @r[mod])
+        @r[mod] = SuperResolver[rx,rm]
+      else
+        @r[mod] = rx
+      end
+    end
+  end
+  
+  def include?(mod)
+    @m.include?(mod)
+  end
+
+  def each
+    @m.each_key {|m| yield m } if block_given?
+  end
+  
+  def copy
+    self.class.allocate.copy_from(@m,@f,@c,@n,@r)
+  end
+protected
+  def copy_from(m,f,c,n,r)
+    @m = m.dup
+    @f = f.dup
+    @c = c.dup
+    @n = n.dup if n
+    @r = r.dup if r
+    self
+  end  
+private
+  def validate(mod)
+    functional = nil
+    if mod.respond_to?(:factory) && (obj = mod.factory)
+      raise validate_error(mod,'invalid factory') unless obj.respond_to?(:builder)
+      functional = true
+    end
+    if mod.respond_to?(:connecter) && (obj = mod.connecter)
+      raise validate_error(mod,'invalid connecter') unless obj.respond_to?(:prepare)
+      functional = true
+    end  
+    if mod.respond_to?(:consumer) && (obj = mod.consumer)
+      raise validate_error(mod,'invalid consumer') unless obj.respond_to?(:consume)
+      functional = true
+    end
+    if mod.respond_to?(:resolver) && (obj = mod.resolver)
+      raise validate_error(mod,'invalid resolver') unless obj.respond_to?(:resolve_ctor) &&
+                                                          obj.respond_to?(:resolve_meth)
+      functional = true
+    end
+    raise validate_error(mod,'no functionality') unless functional
+    true
+  end
+  def validate_error(mod,reason)
+    BuilderException.new("not a valid builder module: #{mod} (#{reason})")  
+  end
+
+end #Config
+
+end #Builder
+end #Cheri

data/lib/cheri/builder/connecter.rb

@@ -0,0 +1,386 @@
+#--
+# Copyright (C) 2007 William N Dortch <bill.dortch@gmail.com>
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+#
+
+module Cheri
+module Builder
+
+class TypeConnecter
+
+  def initialize(*parents,&k)
+    @t = {}
+    @s = {}
+    unless parents.empty?
+      t = @t
+      s = @s
+      parents.each do |parent|
+        raise Cheri.type_error(parent,TypeConnecter) unless TypeConnecter === parent
+        parent.get_types.each_pair do |mod,type|
+          if (tmod = t[mod])
+            tmod.merge(type)
+          else
+            t[mod] = type.copy
+          end
+        end
+        parent.get_syms.each_pair do |sym,symc|
+          if (ssym = s[sym])
+            ssym.merge(symc)
+          else
+            s[sym] = symc.copy
+          end
+        end
+      end
+    end
+    instance_eval(&k) if k
+  end
+
+  def prepare(ctx,builder,obj,sym,props)
+    # try parent symbol matches first
+    if (ssym = @s[builder.sym])
+      # child symbol match?
+      if (sctr = ssym.sctrs[sym])
+        return sctr.prepare(ctx,builder,obj,sym,props) 
+      end
+      # child type match?
+      unless ssym.tctrs.empty?
+        anc = (class<<obj;self;end).ancestors
+        ix = anc.length
+        match = nil
+        # match on nearest ancestor
+        ssym.tctrs.each do |tctr|
+          if (cix = anc.index(tctr.mod)) && cix < ix
+            ix = cix
+            match = tctr
+          end
+        end
+        return match.prepare(ctx,builder,obj,sym,props) if match
+      end
+    end
+    # then try parent type matches
+    t = @t
+    (class<<builder.object;self;end).ancestors.each do |a|
+      if (type = t[a])
+        # child symbol match?
+        if (sctr = type.sctrs[sym])
+          return sctr.prepare(ctx,builder,obj,sym,props) 
+        end
+        # child type match?
+        anc ||= (class<<obj;self;end).ancestors
+        ix ||= anc.length
+        match = nil
+        # match on nearest ancestor
+        type.tctrs.each do |tctr|
+          if (cix = anc.index(tctr.mod)) && cix < ix
+            ix = cix
+            match = tctr
+          end
+        end
+        return match.prepare(ctx,builder,obj,sym,props) if match
+      end
+    end
+    false
+  end
+
+  def type(mod,&k)
+    if Module === mod
+      tp = @t[mod] ||= Type.new(mod)
+      tp.instance_eval(&k) if k
+    elsif Symbol === mod
+      sm = @s[mod] ||= Sym.new(mod)
+      sm.instance_eval(&k) if k
+    elsif Array === mod
+      mod.each do |m|
+        if Symbol === m
+          sm = @s[m] ||= Sym.new(m)
+          sm.instance_eval(&k) if k
+        elsif Module === m
+          tp = @t[m] ||= Type.new(m)
+          tp.instance_eval(&k) if k
+        else
+          raise Cheri.type_error(m,Symbol,Class,Module)
+        end
+      end    
+    else
+      raise Cheri.type_error(mod,Class,Module,Symbol,Array)
+    end
+    nil
+  end
+  alias_method :types, :type
+  alias_method :symbol, :type
+  alias_method :symbols, :type
+
+  def get_types
+    @t
+  end
+  protected :get_types
+
+  def get_syms
+    @s
+  end
+  protected :get_syms
+
+  # used by simple builder-builder
+  def add_type(mod) #:nodoc:
+    @t[mod] ||= Type.new(mod)
+  end
+  
+  class Type
+    def initialize(mod)
+      raise Cheri.type_error(mod,Class,Module) unless Module === mod
+      @m = mod
+      @t = []
+      @s = {}
+    end
+
+    def connect(mod,adder=nil,&k)
+      raise Cheri.type_error(adder,Symbol) if adder && !(Symbol === adder)
+      adder ||= :add unless k
+      if Module === mod
+        addm(mod,adder,&k)
+      elsif Symbol === mod
+        adds(mod,adder,&k)      
+      elsif Array === mod
+        mod.each do |m|
+          if Module === m
+            addm(m,adder,&k)
+          elsif Symbol === m
+            adds(m,adder,&k)
+          else
+            raise Cheri.type_error(m,Class,Module,Symbol)
+          end
+        end
+      else
+        raise Cheri.type_error(mod,Class,Module,Symbol,Array)
+      end
+      nil
+    end
+    
+    def addm(mod,adder,&k)
+      ctr = TCtr.new(mod,adder,&k)
+      @t.delete mod
+      @t << ctr
+    end
+    private :addm
+
+    def adds(sym,adder,&k)
+      @s[sym] = SCtr.new(sym,adder,&k)
+    end
+    private :adds
+
+    def mod
+      @m
+    end
+
+    def tctrs
+      @t  
+    end
+    
+    def sctrs
+      @s    
+    end
+    
+    def merge(other)
+      raise Cheri.type_error(other,Type) unless Type === other
+      t = @t
+      other.tctrs.each do |tctr| t.delete(tctr.mod); end
+      t.concat(other.tctrs)
+      s = @s
+      other.sctrs.each do |sctr| s[sctr.sym] = sctr; end
+      nil
+    end
+
+    def copy
+      self.class.allocate.copy_from(@m,@t,@s)    
+    end
+    
+    def copy_from(mod,tctrs,sctrs)
+      @m = mod
+      @t = tctrs.dup
+      @s = sctrs.dup
+      self
+    end
+    protected :copy_from
+
+  end #Type
+
+  class Sym
+    def initialize(sym)
+      raise Cheri.type_error(sym,Symbol) unless Symbol === sym
+      @m = sym
+      @t = []
+      @s = {}
+    end
+
+    def connect(sym,adder=nil,&k)
+      raise Cheri.type_error(adder,Symbol) if adder && !(Symbol === adder)
+      adder ||= :add unless k
+      if Symbol === sym
+        adds(sym,adder,&k)      
+      elsif Module === sym
+        addm(sym,adder,&k)
+      elsif Array === sym
+        sym.each do |m|
+          if Symbol === m
+            adds(m,adder,&k)
+          elsif Module === m
+            addm(m,adder,&k)
+          else
+            raise Cheri.type_error(m,Symbol,Class,Module)
+          end
+        end
+      else
+        raise Cheri.type_error(sym,Symbol,Class,Module,Array)
+      end
+      nil
+    end
+    
+    def addm(mod,adder,&k)
+      ctr = TCtr.new(mod,adder,&k)
+      @t.delete mod
+      @t << ctr
+    end
+    private :addm
+
+    def adds(sym,adder,&k)
+      @s[sym] = SCtr.new(sym,adder,&k)
+    end
+    private :adds
+
+    def sym
+      @m
+    end
+
+    def tctrs
+      @t  
+    end
+    
+    def sctrs
+      @s    
+    end
+    
+    def merge(other)
+      raise Cheri.type_error(other,Sym) unless Sym === other
+      t = @t
+      other.tctrs.each do |tctr| t.delete(tctr.mod); end
+      t.concat(other.tctrs)
+      s = @s
+      other.sctrs.each do |sctr| s[sctr.sym] = sctr; end
+      nil
+    end
+
+    def copy
+      self.class.allocate.copy_from(@m,@t,@s)    
+    end
+    
+    def copy_from(sym,tctrs,sctrs)
+      @m = sym
+      @t = tctrs.dup
+      @s = sctrs.dup
+      self
+    end
+    protected :copy_from
+
+  end #Sym
+
+  class TCtr #:nodoc: all
+    def initialize(mod,adder=nil,&k)
+      raise Cheri.type_error(mod,Class,Module) unless Module === mod
+      raise Cheri.type_error(adder,Symbol) if adder && !(Symbol === adder)
+      @m = mod
+      @a = adder if adder
+      @k = k if k
+    end
+
+    def mod
+      @m
+    end
+
+    def ==(other)
+      TCtr === other ? @m == other.mod : @m == other      
+    end
+      
+    def eql?(other)
+      TCtr === other ? @m.eql?(other.mod) : @m.eql?(other)
+    end
+      
+    def <=>(other)
+      @m.name <=> other.mod.name      
+    end
+
+    def prepare(ctx,builder,obj,sym,props)
+      ctx.ppd(self,builder,obj,(@a || sym),props)
+    end
+
+    def connect(parent,obj,sym,props)
+      if @k
+        @k.call(parent,obj,sym,props)
+      else
+        parent.__send__(sym,obj) #rescue nil
+      end
+      nil
+    end
+  end #TCtr
+
+  class SCtr #:nodoc: all
+    def initialize(sym,adder=nil,&k)
+      raise Cheri.type_error(sym,Symbol) unless Symbol === sym
+      raise Cheri.type_error(adder,Symbol) if adder && !(Symbol === adder)
+      @m = sym
+      @a = adder if adder
+      @k = k if k
+    end
+
+    def sym
+      @m
+    end
+
+    def ==(other)
+      SCtr === other ? @m == other.sym : @m == other      
+    end
+      
+    def eql?(other)
+      SCtr === other ? @m.eql?(other.sym) : @m.eql?(other)
+    end
+      
+    def <=>(other)
+      @m.to_s <=> other.sym.to_s      
+    end
+
+    def prepare(ctx,builder,obj,sym,props)
+      ctx.ppd(self,builder,obj,(@a || sym),props)
+    end
+
+    def connect(parent,obj,sym,props)
+      if @k
+        @k.call(parent,obj,sym,props)
+      else
+        parent.__send__(sym,obj) #rescue nil
+      end
+      nil
+    end
+  end #SCtr
+
+end #TypeConnecter
+
+end #Builder
+end #Cheri