fabulator 0.0.8 → 0.0.9

data/lib/fabulator/expr/statement_list.rb

@@ -5,6 +5,11 @@ module Fabulator
         @statements = [ ]
         @ensures = [ ]
         @catches = [ ]
+        @context = nil
+      end
+
+      def use_context(c)
+        @context = c
       end
 
       def add_statement(s)
@@ -28,6 +33,9 @@ module Fabulator
       end
 
       def run(context, autovivify = false)
+        if !@context.nil?
+          context = @context
+        end
         result = [ ]
         begin
           if !@statements.nil?
@@ -84,6 +92,25 @@ module Fabulator
       end
     end
 
+    class ErrExpr
+      def initialize(e,c)
+        @expr = e
+        @err_expr = c
+      end
+
+      def run(context, autovivify = false)
+        result = []
+        begin
+          result = @expr.run(context, autovivify)
+        rescue => e
+          ctx = context.merge
+          ctx.set_var('e', e)
+          result = @err_expr.run(ctx)
+        end
+        result
+      end
+    end
+
     class DataSet
       def initialize(p,v)
         @path = p

data/lib/fabulator/lib.rb

@@ -65,6 +65,9 @@ module Fabulator
     #structural :type, Type
     #structural :filter, Filter
     #structural :constraint, Constraint
+
+    presentations do
+    end
   end
   end
 end

data/lib/fabulator/lib/action.rb

@@ -5,6 +5,7 @@ module Fabulator
   module Lib
     class Action < Fabulator::Structural
       attr_accessor :attributes
+      attr_accessor :namespace
 
       namespace FAB_LIB_NS
 
@@ -18,7 +19,7 @@ module Fabulator
       def compile_action(e, context)
         ret = nil
         context.with(e) do |ctx|
-          ret = ActionRef.new(self, ctx, ctx.compile_actions(e))
+          ret = ActionRef.new([ e.namespaces.namespace.href, e.name ], ctx, ctx.compile_actions(e))
         end
         ret
       end
@@ -30,8 +31,8 @@ module Fabulator
         @action = defining_action
         @actions = actions
         @static_attributes = { }
-        @action.attributes.collect{ |a| a.is_static? }.each do |a|
-          @static_attributes[a.path] = a.value(@context)
+        @context.get_action(@action.first, @action.last).attributes.collect{ |a| a.is_static? }.each do |a|
+          @static_attributes[a.name] = a.value(@context)
         end
       end
 
@@ -39,17 +40,19 @@ module Fabulator
         ret = [ ]
         @context.with(context) do |ctx|
           @static_attributes.each_pair do |p,v|
-            ctx.set_value(p, v)
+            ctx.set_var(p, v)
           end
 # These can be passed to f:eval to get their value
-          @action.attributes.collect{ |a| !a.is_static? }.each do |attr|
-            ctx.set_value(attr.path, attr.value(ctx))
+          action = ctx.get_action(@action.first, @action.last)
+          action.attributes.collect{ |a| !a.is_static? }.each do |attr|
+            ctx.set_var(attr.name, attr.value(ctx))
           end
           # we can f:eval($actions) in whatever current context we have
-          if @action.has_actions?
-            ctx.set_var('actions', ctx.root.anon_node(@actions, [ FAB_NS, 'expression' ]))
+          if action.has_actions?
+            @actions.use_context(context)
+            ctx.set_var('actions', ctx.root.anon_node( @actions, [ FAB_NS, 'expression' ]))
           end
-          ret = @action.run(ctx)
+          ret = action.run(ctx)
         end
         ret
       end

data/lib/fabulator/lib/lib.rb

@@ -8,15 +8,21 @@ module Fabulator
     
     attribute :ns, :static => true
 
-    contains :action, :storage => :hash, :key => :name
-    contains :structural, :storage => :hash, :key => :name
-    contains :function, :storage => :hash, :key => :name
-    contains :mapping, :storage => :hash, :key => :name
-    contains :reduction, :storage => :hash, :key => :name
-    contains :consolidation, :storage => :hash, :key => :name
-    contains :type, :storage => :hash, :key => :name
-    contains :filter, :storage => :hash, :key => :name
-    contains :constraint, :storage => :hash, :key => :name
+    contains :action, :storage => :hash, :key => :name, :delayable => true
+    contains :structural, :storage => :hash, :key => :name, :delayable => true
+    contains :function, :storage => :hash, :key => :name, :delayable => true
+    contains :mapping, :storage => :hash, :key => :name, :delayable => true
+    contains :reduction, :storage => :hash, :key => :name, :delayable => true
+    contains :consolidation, :storage => :hash, :key => :name, :delayable => true
+    contains :type, :storage => :hash, :key => :name, :delayable => true
+    contains :filter, :storage => :hash, :key => :name, :delayable => true
+    contains :constraint, :storage => :hash, :key => :name, :delayable => true
+    contains :format, :storage => :hash, :key => :name
+    contains :transform
+
+    def presentation
+      @presentations ||= Fabulator::TagLib::Presentations.new
+    end
 
     def register_library
       Fabulator::TagLib.namespaces[self.ns] = self
@@ -28,6 +34,15 @@ module Fabulator
       @actions[name].compile_action(e, context)
     end
 
+    def get_action(nom, context)
+      return nil unless self.action_exists?(nom)
+      @actions[nom]
+    end
+
+    def action_exists?(nom)
+      @actions.has_key?(nom.to_s)
+    end
+
     def run_function(context, nom, args)
       # look for a function/mapping/consolidation
       # then pass along to any objects in @contained
@@ -115,6 +130,67 @@ module Fabulator
       end
       false
     end
+
+  protected
+
+    def setup(xml)
+      ns = xml.attributes.get_attribute_ns(FAB_LIB_NS, 'ns').value
+      Fabulator::TagLib.namespaces[ns] = self
+
+      self.init_attribute_storage
+    
+      possibilities = self.class.structurals
+
+      if !possibilities.nil?
+      
+        our_ns = xml.namespaces.namespace.href
+        our_nom = xml.name
+        delayed = [ ]
+        xml.each_element{ |e| delayed << e }
+        while !delayed.empty?
+          structs = { }
+          new_delayed = [ ]
+          delayed.each do |e|
+            ns = e.namespaces.namespace.href
+            nom = e.name.to_sym
+            allowed = (Fabulator::TagLib.namespaces[our_ns].structural_class(our_nom).accepts_structural?(ns, nom) rescue false)
+            next unless allowed
+            structs[ns] ||= { }
+            structs[ns][nom] ||= [ ]
+            begin
+              structs[ns][nom] << @context.compile_structural(e)
+            rescue => ee
+              new_delayed << e
+            end
+            structs[ns][nom] -= [ nil ]
+          end
+
+          structs.each_pair do |ns, parts|
+            next unless possibilities[ns]
+            parts.each_pair do |nom, objs|
+              next unless possibilities[ns][nom]
+              opts = possibilities[ns][nom]
+              as = "@" + (opts[:as] || nom.to_s.pluralize).to_s
+              if opts[:storage].nil? || opts[:storage] == :array
+                self.instance_variable_set(as.to_sym, self.instance_variable_get(as.to_sym) + objs)
+              else
+                tgt = self.instance_variable_get(as.to_sym)
+                objs.each do |obj|
+                  tgt[obj.send(opts[:key] || :name)] = obj
+                end
+              end
+            end
+          end
+
+          if (new_delayed - delayed).empty? && (delayed - new_delayed).empty?
+            delayed = []
+          else
+            delayed = new_delayed
+          end
+        end
+      end
+
+    end
   end
   end
 end

data/lib/fabulator/structural.rb

@@ -3,6 +3,8 @@ module Fabulator
 
     def initialize
       @context = Fabulator::Expr::Context.new
+      self.init_attribute_storage
+
     end
 
     def compile_xml(xml, context = nil)
@@ -35,6 +37,9 @@ module Fabulator
       @@structurals[self.name] ||= { }
       @@structurals[self.name][ns] ||= { }
       @@structurals[self.name][ns][nom.to_sym] = opts
+      self.module_eval {
+        attr_accessor (opts[:as] || nom.to_s.pluralize).to_sym
+      }
     end
 
     def self.contained_in(ns, nom, h = {})
@@ -43,7 +48,7 @@ module Fabulator
       @@contained_in[ns] ||= { }
       @@contained_in[ns][nom.to_sym] ||= { }
       @@contained_in[ns][nom.to_sym][self.namespace] ||= { }
-      @@contained_in[ns][nom.to_sym][self.namespace][self.element.to_sym] = h.update({ :as => :contained})
+      @@contained_in[ns][nom.to_sym][self.namespace][self.element.to_sym] = { :as => :contained }.update(h)
     end
 
     def self.structurals
@@ -79,16 +84,20 @@ module Fabulator
 
 
   protected
-    def setup(xml)
-      super
 
-      #klass = self.class.name
+    def init_attribute_storage
       possibilities = self.class.structurals
 
       if !possibilities.nil?
         possibilities.each_pair do |ns, parts|
           parts.each_pair do |nom, opts|
-            as = "@" + (opts[:as] || nom.to_s.pluralize).to_s
+            snom = (opts[:as] || nom.to_s.pluralize).to_s
+            as = "@" + snom
+            if !self.class.respond_to?(snom.to_sym)
+              self.class.module_eval {
+                attr_accessor snom.to_sym
+              }
+            end
             if opts[:storage].nil? || opts[:storage] == :array
               self.instance_variable_set(as.to_sym, [])
             elsif opts[:storage] == :hash
@@ -96,7 +105,17 @@ module Fabulator
             end
           end
         end
+      end
+    end
 
+    def setup(xml)
+      super
+
+      self.init_attribute_storage
+
+      possibilities = self.class.structurals
+
+      if !possibilities.nil?
         structs = @context.compile_structurals(xml)
         structs.each_pair do |ns, parts|
           next unless possibilities[ns]

data/lib/fabulator/tag_lib.rb

@@ -8,6 +8,7 @@ module Fabulator
     @@namespaces = {}
     @@attributes = [ ]
     @@last_description = nil
+    @@presentations = { }
     @@types = { }
     @@axes = { }
 
@@ -41,6 +42,9 @@ module Fabulator
     def self.axes
       @@axes
     end
+    def self.presentations
+      @@presentations
+    end
 
     def self.last_description=(x)
       @@last_description = x
@@ -72,30 +76,24 @@ module Fabulator
     def self.axes=(x)
       @@axes = x
     end
+    def self.presentations=(x)
+      @@presentations = x
+    end
 
-      def structural_class(nom)
-        Fabulator::TagLib.structural_classes[self.class.name][nom.to_sym]
-      end
+    def structural_class(nom)
+      Fabulator::TagLib.structural_classes[self.class.name][nom.to_sym]
+    end
 
     def self.inherited(base)
       base.extend(ClassMethods)
     end
 
-#    def self.included(base)
-#      base.extend(ClassMethods)
-#      base.module_eval do
-#        def self.included(new_base)
-#          super
-#          new_base.action_descriptions.merge! self.action_descriptions
-#          new_base.function_descriptions.merge! self.function_descriptions
-#          new_base.function_args.merge! self.function_args
-#          new_base.types.merge! self.types
-#        end
-#      end
-#    end
+    def self.type_handler(t)
+      (@@types[t[0]][t[1].to_sym] rescue nil)
+    end
 
     def self.find_op(t,o)
-      (@@types[t[0]][t[1]][:ops][o] rescue nil)
+      (self.type_handler(t).get_method(t + o.upcase) rescue nil)
     end
 
     # returns nil if no common type can be found
@@ -110,6 +108,7 @@ module Fabulator
       # now group by types since we only need one of each type for unification
       grouped = { }
       ts.each do |t|
+        t = t.vtype.collect{ |i| i.to_s} unless t.is_a?(Array)
         grouped[t.join('')] = t
       end
 
@@ -121,96 +120,17 @@ module Fabulator
       # until we unify all of them
       t1 = grouped.pop
       t2 = grouped.pop
-      ut = self._unify_types(t1, t2)
+      t1_obj = self.type_handler(t1)
+      ut = t1_obj.unify_with_type(t2)
       return nil if ut.nil?
       self.unify_types([ ut[:t] ] + grouped)
     end
 
     def self.type_path(from, to)
       return [] if from.nil? || to.nil? || from.join('') == to.join('')
-      ut = self._unify_types(from, to, true)
-      return [] if ut.nil? || ut[:t].join('') != to.join('')
-      return ut[:convert]
-    end
-
-    ## TODO: allow unification with values as well so we can have
-    #        conversions dependent on the value
-    # for example: strings that look like integers can convert to integers
-    def self._unify_types(t1, t2, ordered = false)
-      return nil if t1.nil? || t2.nil?
-      d1 = { t1.join('') => { :t => t1, :w => 1.0, :path => [ t1 ], :convert => [ ] } }
-      d2 = { t2.join('') => { :t => t2, :w => 1.0, :path => [ t2 ], :convert => [ ] } }
-
-      added = true
-      while added
-        added = false
-        [d1, d2].each do |d|
-          d.keys.each do |t|
-            if (@@types[d[t][:t][0]][d[t][:t][1]].has_key?(:to) rescue false)
-              @@types[d[t][:t][0]][d[t][:t][1]][:to].each do |conv|
-                w = d[t][:w] * conv[:weight]
-                conv_key = conv[:type].join('')
-                if d.has_key?(conv_key) 
-                  if d[conv_key][:w] < w
-                    d[conv_key][:w] = w
-                    d[conv_key][:path] = d[t][:path] + [ conv[:type] ]
-                    d[conv_key][:convert] = d[t][:convert] + [ conv[:convert] ] - [nil]
-                  end
-                else
-                  d[conv_key] = {
-                    :t => conv[:type],
-                    :w => w,
-                    :path => d[t][:path] + [ conv[:type] ],
-                    :convert => d[t][:convert] + [ conv[:convert] ] - [ nil ]
-                  }
-                  added = true
-                end
-              end
-            end
-          end
-          # go through each type looking for :from
-          @@types.keys.each do |ns|
-            @@types[ns].each_pair do |ct, cd|
-              next if cd[:from].nil?
-              to_key = ns + ct
-              cd[:from].each do |conv|
-                next if conv[:type].nil?
-                from_key = conv[:type].join('')
-                next if !d.has_key?(from_key)
-                w = d[from_key][:w] * conv[:weight]
-                if d.has_key?(to_key)
-                  if d[to_key][:w] < w
-                    d[to_key][:w] = w
-                    d[to_key][:path] = d[from_key][:path] + [ conv[:type] ]
-                    d[to_key][:convert] = d[from_key][:convert] + [ conv[:convert] ] - [nil]
-                  end
-                else
-                  d[to_key] = {
-                    :t => [ns, ct],
-                    :w => w * 95 / 100, # favor to over from
-                    :path => d[from_key][:path] + [ conv[:type] ],
-                    :convert => d[from_key][:convert] + [ conv[:convert] ] - [ nil ]
-                  }
-                  added = true
-                end
-              end
-            end
-          end
-        end
-        r = self._select_type_path(d1, d2, t2, ordered)
-        return r unless r.nil?
-      end
-      return self._select_type_path(d1, d2, t2, ordered)
-    end
-
-    def self._select_type_path(d1, d2, t2, ordered)
-      common = d1.keys & d2.keys
-      if ordered && common.include?(t2.join(''))
-        return d1[t2.join('')]
-      elsif !common.empty? 
-        return d1[common.sort_by{ |c| d1[c][:w] * d2[c][:w] / d1[c][:path].size / d2[c][:path].size }.reverse.first]
-      end
-      return nil
+      from_obj = self.type_handler(from)
+      return [] if from_obj.nil?
+      return from_obj.build_conversion_to(to)
     end
 
     def self.with_super(s, &block)
@@ -237,6 +157,10 @@ module Fabulator
       end
     end
 
+    def action_exists?(nom)
+      self.respond_to?("action:#{nom.to_s}")
+    end
+
     def run_function(context, nom, args, depth=0)
       ret = []
 
@@ -273,23 +197,28 @@ module Fabulator
           end
           rr
         else
-          context.root.anon_node(r) #, self.function_return_type(nom))
+          rt = self.function_return_type(nom)
+          if rt.nil?
+            context.root.anon_node(r) #, self.function_return_type(nom))
+          else
+            context.root.anon_node(r,rt)
+          end
         end
       }
       ret.flatten
     end
 
     def function_return_type(name)
-      (self.function_descriptions[name][:returns] rescue nil)
+      (self.function_descriptions[name.to_sym][:returns] rescue nil)
     end
 
     def function_run_scaling(name)
-      (self.function_descriptions[name][:scaling] rescue nil)
+      (self.function_descriptions[name.to_sym][:scaling] rescue nil)
     end
 
     def function_run_type(name)
-      r = (self.function_descriptions[name][:type] rescue nil)
-      if r.nil? && !self.function_descriptions.has_key?(name)
+      r = (self.function_descriptions[name.to_sym][:type] rescue nil)
+      if r.nil? && !self.function_descriptions.has_key?(name.to_sym)
         if name =~ /^consolidation:(.*)/
           if function_run_scaling($1) != :flat
             return :consolidation
@@ -330,6 +259,10 @@ module Fabulator
       self.class.function_args hash
     end
 
+    def presentation
+      self.class.presentation
+    end
+
     module ClassMethods
       def inherited(subclass)
         subclass.action_descriptions.reverse_merge! self.action_descriptions
@@ -353,6 +286,10 @@ module Fabulator
         Fabulator::TagLib.namespaces[ns] = self.new
       end
 
+      def presentation
+        Fabulator::TagLib.presentations[self.name] ||= Fabulator::TagLib::Presentations.new
+      end
+
       def register_attribute(a, options = {})
         ns = nil
         Fabulator::TagLib.namespaces.each_pair do |k,v|
@@ -363,7 +300,17 @@ module Fabulator
         Fabulator::TagLib.attributes << [ ns, a, options ]
       end
 
-      def register_type(nom, options={})
+      def get_type(nom)
+        ns = nil
+        Fabulator::TagLib.namespaces.each_pair do |k,v|
+          if v.is_a?(self)
+            ns = k
+          end
+        end
+        Fabulator::TagLib.types[ns][nom.to_sym]
+      end
+
+      def has_type(nom, &block)
         ns = nil
         Fabulator::TagLib.namespaces.each_pair do |k,v|
           if v.is_a?(self)
@@ -371,12 +318,14 @@ module Fabulator
           end
         end
         Fabulator::TagLib.types[ns] ||= {}
-        Fabulator::TagLib.types[ns][nom] = options
+        Fabulator::TagLib.types[ns][nom.to_sym] ||= Fabulator::TagLib::Type.new([ns, nom.to_sym])
 
-        function nom do |ctx, args|
-          args[0].collect { |i|
-            i.to([ ns, nom ])
-          }
+        if block
+          Fabulator::TagLib.types[ns][nom.to_sym].instance_eval &block
+        end
+
+        mapping nom do |ctx, i|
+          ctx.with_root(i).to([ ns, nom.to_s ]).root
         end
       end
 
@@ -393,10 +342,10 @@ module Fabulator
       end
       
       def action(name, klass = nil, &block)
-        self.action_descriptions[name] = Fabulator::TagLib.last_description if Fabulator::TagLib.last_description
+        self.action_descriptions[name.to_sym] = Fabulator::TagLib.last_description if Fabulator::TagLib.last_description
         Fabulator::TagLib.last_description = nil
         if block
-          define_method("action:#{name}", &block)
+          define_method("action:#{name.to_s}", block)
         elsif !klass.nil?
           action(name) { |e,c|
             r = klass.new
@@ -407,10 +356,10 @@ module Fabulator
       end
 
       def structural(name, klass = nil, &block)
-        self.structural_descriptions[name] = Fabulator::TagLib.last_description if Fabulator::TagLib.last_description
+        self.structural_descriptions[name.to_sym] = Fabulator::TagLib.last_description if Fabulator::TagLib.last_description
         Fabulator::TagLib.last_description = nil
         if block
-          define_method("structural:#{name}", &block)
+          define_method("structural:#{name.to_s}", block)
         elsif !klass.nil?
           structural(name) { |e,c|
             r = klass.new
@@ -423,21 +372,21 @@ module Fabulator
       end
 
       def function(name, returns = nil, takes = nil, &block)
-        self.function_descriptions[name] = { :returns => returns, :takes => takes }
-        self.function_descriptions[name][:description] = Fabulator::TagLib.last_description if Fabulator::TagLib.last_description
+        self.function_descriptions[name.to_sym] = { :returns => returns, :takes => takes }
+        self.function_descriptions[name.to_sym][:description] = Fabulator::TagLib.last_description if Fabulator::TagLib.last_description
         #self.function_args[name] = { :return => returns, :takes => takes }
         Fabulator::TagLib.last_description = nil
         define_method("fctn:#{name}", &block)
       end
 
       def reduction(name, opts = {}, &block)
-        self.function_descriptions[name] = { :type => :reduction }.merge(opts)
-        self.function_descriptions[name][:description] = Fabulator::TagLib.last_description if Fabulator::TagLib.last_description
+        self.function_descriptions[name.to_sym] = { :type => :reduction }.merge(opts)
+        self.function_descriptions[name.to_sym][:description] = Fabulator::TagLib.last_description if Fabulator::TagLib.last_description
         Fabulator::TagLib.last_description = nil
         define_method("fctn:#{name}", &block)
-        cons = self.function_descriptions[name][:consolidation]
+        cons = self.function_descriptions[name.to_sym][:consolidation]
         if !cons.nil?
-          Fabulator::TagLib.last_description = self.function_descriptions[name][:description]
+          Fabulator::TagLib.last_description = self.function_descriptions[name.to_sym][:description]
           consolidation name do |ctx, args|
             send "fctn:#{cons}", ctx, args
           end
@@ -445,17 +394,18 @@ module Fabulator
       end
 
       def consolidation(name, opts = {}, &block)
-        self.function_descriptions[name] = { :type => :consolidation }.merge(opts)
-        self.function_descriptions[name][:description] = Fabulator::TagLib.last_description if Fabulator::TagLib.last_description
+        self.function_descriptions[name.to_sym] = { :type => :consolidation }.merge(opts)
+        self.function_descriptions[name.to_sym][:description] = Fabulator::TagLib.last_description if Fabulator::TagLib.last_description
         Fabulator::TagLib.last_description = nil
         define_method("fctn:consolidation:#{name}", &block)
       end
 
       def mapping(name, opts = {}, &block)
+        name = name.to_sym
         self.function_descriptions[name] = { :type => :mapping }.merge(opts)
         self.function_descriptions[name][:description] = Fabulator::TagLib.last_description if Fabulator::TagLib.last_description
         Fabulator::TagLib.last_description = nil
-        define_method("fctn:#{name}", &block)
+        define_method("fctn:#{name.to_s}", &block)
       end
 
       def function_decl(name, expr, ns)
@@ -481,6 +431,10 @@ module Fabulator
       def constraint(name, &block)
         define_method("constraint:#{name}", &block)
       end
+
+      def presentations(&block)
+        self.presentation.instance_eval &block
+      end
     end
      
     module Util