fabulator 0.0.6 → 0.0.7

data/lib/fabulator/expr/function.rb

@@ -2,6 +2,7 @@ module Fabulator
   module Expr
     class Function
       def initialize(ctx, nom, args)
+        nom.gsub(/\s+/, '')
         bits = nom.split(/:/, 2)
         @ns = ctx.get_ns(bits[0])
         @name = bits[1]
@@ -13,17 +14,22 @@ module Fabulator
       end
 
       def expr_type(context)
-        klass = ActionLib.namespaces[@ns]
+        return [ FAB_NS, 'boolean' ] if @name =~ /\?$/
+        klass = TagLib.namespaces[@ns]
         (klass.function_return_type(@name) rescue nil)
       end
 
       def run(context, autovivify = false)
-        klass = ActionLib.namespaces[@ns]
+        klass = TagLib.namespaces[@ns]
         return [] if klass.nil?
         ctx = @ctx.merge(context)
-        return klass.run_function(
+        ret = klass.run_function(
           ctx, @name, @args.run(ctx)
         )
+        if @name =~ /\?$/
+          ret = ret.collect{ |v| v.to([FAB_NS, 'boolean']) }
+        end
+        ret
       end
     end
 

data/lib/fabulator/expr/literal.rb

@@ -23,7 +23,7 @@ module Fabulator
       def expr_type(context)
         v = context.get_var(@var)
         if( v.is_a?(Array) )
-          ActionLib.unify_types(v.collect{ |i| i.vtype })
+          TagLib.unify_types(v.collect{ |i| i.vtype })
         else
           v.vtype
         end

data/lib/fabulator/expr/node.rb

@@ -94,7 +94,7 @@ module Fabulator
       end
 
       def children(n = nil)
-        op = ActionLib.find_op(@vtype, :children)
+        op = TagLib.find_op(@vtype, :children)
         possible = op.nil? ? @children : op.call(self)
         if n.nil?
           possible

data/lib/fabulator/expr/node_logic.rb

@@ -31,7 +31,7 @@ module Fabulator
         # see if there's a path between @vtype and t
         #   if so, do the conversion
         #   otherwise, return nil
-        path = Fabulator::ActionLib.type_path(self.vtype, t)
+        path = Fabulator::TagLib.type_path(self.vtype, t)
         return self.anon_node(nil,nil) if path.empty?
         v = self
         path.each do |p|

data/lib/fabulator/expr/parser.rb

@@ -49,7 +49,7 @@ module_eval(<<'...end xsm_expression_parser.racc/module_eval...', 'xsm_expressio
   @@regex[:qname] = %r{((?:#{@@regex[:ncname]}:)?#{@@regex[:ncname]})}
   @@regex[:dollar_qname] = %r{\$#{@@regex[:qname]}}
   @@regex[:dollar_int] = %r{\$([0-9]+)}
-  @@regex[:function_name] = %r{#{@@regex[:qname]}\*?\s*(?=\([^:])}
+  @@regex[:function_name] = %r{#{@@regex[:qname]}\??\*?\s*(?=\([^:])}
 
   @@ops = {
     '..' => :DOT_DOT,

data/lib/fabulator/expr/predicates.rb

@@ -26,7 +26,7 @@ module Fabulator
                 # if all boolean and one is true, then keep
                 # if numeric, then keep if position == number
                 # if string and non-blank, then keep
-                unified_type = Fabulator::ActionLib.unify_types(res.collect{ |r| r.vtype })
+                unified_type = Fabulator::TagLib.unify_types(res.collect{ |r| r.vtype })
                 case unified_type.join('') 
                   when FAB_NS+'boolean':
                     if res.select{ |r| r.to([FAB_NS, 'boolean']).value }.size > 0

data/lib/fabulator/expr/statement_list.rb

@@ -23,6 +23,10 @@ module Fabulator
         @statements.empty? && @ensures.empty?
       end
 
+      def empty?
+        @statements.empty? && @ensures.empty?
+      end
+
       def run(context, autovivify = false)
         result = [ ]
         begin

data/lib/fabulator/expr/union_expr.rb

@@ -6,7 +6,7 @@ module Fabulator
       end
 
       def expr_type(context)
-        Fabulator::ActionLib.unify_types(@exprs.collect{ |e| e.expr_type(context) })
+        Fabulator::TagLib.unify_types(@exprs.collect{ |e| e.expr_type(context) })
       end
 
       def run(context, autovivify = false)

data/lib/fabulator/lib.rb

@@ -0,0 +1,69 @@
+#
+# Allows definition of a lib as XSM stuff -- the glue between the core
+# engine and the lib definition
+#
+
+# need a way to specify a library entry type -- to support grammars
+
+# library ns: http://dh.tamu.edu/ns/fabulator/1.0#
+#<f:library f:ns="">
+#  <action name=''>
+#    <attribute name='' type='' as='' />  (could be type='expression')
+#    actions...
+#  </action>
+#
+# <structure name=''>
+#   <attribute ... />
+#   <element ... />
+#   actions
+# </structure>
+#
+#  <function name=''>
+#    actions...
+#  </function>
+#
+#  <type name=''>
+#    <op name=''>
+#      actions...
+#    </op>
+#    <to name='' weight=''>
+#      actions...
+#    </to>
+#    <from name='' weight=''>
+#      actions...
+#    </from>
+#  </type>
+#
+#  <filter name=''>
+#     actions...
+#  </filter>
+#
+#  <constraint name=''>
+#    actions...
+#  </constraint>
+#</library>
+
+require 'fabulator/lib/lib'
+require 'fabulator/lib/structural'
+require 'fabulator/lib/action'
+require 'fabulator/lib/attribute'
+
+module Fabulator
+  module Lib
+  class LibLib < Fabulator::TagLib
+    namespace FAB_LIB_NS
+
+    structural :library, Lib
+    structural :structural, Structural
+    structural :action, Action
+    structural :attribute, Attribute
+    #structural :function, Function
+    #structural :mapping, Mapping
+    #structural :reduction, Reduction
+    #structural :consolidation, Consolidation
+    #structural :type, Type
+    #structural :filter, Filter
+    #structural :constraint, Constraint
+  end
+  end
+end

data/lib/fabulator/lib/action.rb

@@ -0,0 +1,13 @@
+module Fabulator
+  module Lib
+    class Action < Fabulator::Structural
+      namespace FAB_LIB_NS
+
+      attribute :name, :static => true
+
+      contains :attribute
+
+      has_actions
+    end
+  end
+end

data/lib/fabulator/lib/attribute.rb

@@ -0,0 +1,9 @@
+module Fabulator
+  module Lib
+    class Attribute < Fabulator::Structural
+      namespace FAB_LIB_NS
+
+      attribute :name, :static => true
+    end
+  end
+end

data/lib/fabulator/lib/lib.rb

@@ -0,0 +1,47 @@
+module Fabulator
+  module Lib
+  class Lib < Fabulator::Structural
+
+    namespace FAB_LIB_NS
+    
+    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
+
+    def register_library
+      Fabulator::TagLib.namespaces[@ns] = self
+      @attributes.each do |attr|
+        Fabulator::TagLib.attributes << [ @ns, attr[:name], attr[:options] ]
+      end
+    end
+
+    def compile_action(e, c_attrs)
+    end
+
+    def run_function(context, nom, args)
+    end   
+
+    def function_return_type(name)
+      (self.function_descriptions[name][:returns] rescue nil)
+    end
+
+    def function_args
+      @function_args ||= { }
+    end
+
+    def run_filter(context, nom)
+    end
+ 
+    def run_constraint(context, nom)
+    end
+  end
+  end
+end

data/lib/fabulator/lib/structural.rb

@@ -0,0 +1,13 @@
+module Fabulator
+  module Lib
+    class Structural < Fabulator::Structural
+      namespace FAB_LIB_NS
+
+      attribute :name, :static => true
+
+      contains :attribute
+
+      has_actions
+    end
+  end
+end

data/lib/fabulator/structural.rb

@@ -0,0 +1,92 @@
+module Fabulator
+  class Structural < Action
+
+    def compile_xml(xml, context)
+      XML.default_line_numbers = true
+      if xml.is_a?(String)
+        xml = LibXML::XML::Document.string xml
+      end
+      if xml.is_a?(LibXML::XML::Document)
+        xml = xml.root
+      end
+
+      if context.nil?
+        @context = @context.merge(xml)
+      else
+        @context = context.merge(xml)
+      end
+
+      self.setup(xml)
+
+      self
+    end
+
+    def self.element(nom)
+      @@elements[self.name] = nom
+    end
+
+    def self.contains(nom, opts = { })
+      ns = opts[:ns] || self.namespace
+      @@structurals ||= { }
+      @@structurals[self.name] ||= { }
+      @@structurals[self.name][ns] ||= { }
+      @@structurals[self.name][ns][nom.to_sym] = opts
+    end
+
+    def self.structurals
+      return @@structurals[self.name]
+    end
+
+    def self.accepts_structural?(ns, nom)
+      return false if @@structurals.nil?
+      return false if @@structurals[self.name].nil?
+      return false if @@structurals[self.name][ns].nil?
+      return false if @@structurals[self.name][ns][nom.to_sym].nil?
+      return true
+    end
+
+    def accepts_structural?(ns, nom)
+      self.class.accepts_structural?(ns, nom)
+    end
+
+
+  protected
+    def setup(xml)
+      super
+
+      #klass = self.class.name
+      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
+            if opts[:storage].nil? || opts[:storage] == :array
+              self.instance_variable_set(as.to_sym, [])
+            elsif opts[:storage] == :hash
+              self.instance_variable_set(as.to_sym, {})
+            end
+          end
+        end
+
+        structs = @context.compile_structurals(xml)
+        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
+      end
+    end
+  end
+end

data/lib/fabulator/{action_lib.rb → tag_lib.rb}

@@ -1,6 +1,8 @@
 module Fabulator
-  module ActionLib
+  class TagLib
     @@action_descriptions = {}
+    @@structural_descriptions = {}
+    @@structural_classes = {}
     @@function_descriptions = {}
     @@function_args = { }
     @@namespaces = {}
@@ -18,6 +20,12 @@ module Fabulator
     def self.action_descriptions
       @@action_descriptions
     end
+    def self.structural_descriptions
+      @@structural_descriptions
+    end
+    def self.structural_classes
+      @@structural_classes
+    end
     def self.function_description
       @@function_description
     end
@@ -43,6 +51,12 @@ module Fabulator
     def self.action_descriptions=(x)
       @@action_descriptions = x
     end
+    def self.structural_descriptions=(x)
+      @@structural_descriptions = x
+    end
+    def self.structural_classes=(x)
+      @@structural_classes = x
+    end
     def self.function_description=(x)
       @@function_description = x
     end
@@ -59,19 +73,27 @@ module Fabulator
       @@axes = x
     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
+      def structural_class(nom)
+        Fabulator::TagLib.structural_classes[self.class.name][nom]
       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.find_op(t,o)
       (@@types[t[0]][t[1]][:ops][o] rescue nil)
     end
@@ -209,6 +231,12 @@ module Fabulator
       end
     end
 
+    def compile_structural(e, c)
+      if self.class.method_defined? "structural:#{e.name}"
+        send "structural:#{e.name}", e, c
+      end
+    end
+
     def run_function(context, nom, args, depth=0)
       ret = []
 
@@ -310,36 +338,40 @@ module Fabulator
       end
       
       def action_descriptions(hash = nil)
-        Fabulator::ActionLib.action_descriptions[self.name] ||= (hash ||{})
+        Fabulator::TagLib.action_descriptions[self.name] ||= (hash ||{})
       end
 
       def function_descriptions(hash = nil)
-        Fabulator::ActionLib.action_descriptions[self.name] ||= (hash ||{})
+        Fabulator::TagLib.action_descriptions[self.name] ||= (hash ||{})
       end
     
       def register_namespace(ns)
-        Fabulator::ActionLib.namespaces[ns] = self.new
+        Fabulator::TagLib.namespaces[ns] = self.new
+      end
+
+      def namespace(ns)
+        Fabulator::TagLib.namespaces[ns] = self.new
       end
 
       def register_attribute(a, options = {})
         ns = nil
-        Fabulator::ActionLib.namespaces.each_pair do |k,v|
+        Fabulator::TagLib.namespaces.each_pair do |k,v|
           if v.is_a?(self)
             ns = k
           end
         end
-        Fabulator::ActionLib.attributes << [ ns, a, options ]
+        Fabulator::TagLib.attributes << [ ns, a, options ]
       end
 
       def register_type(nom, options={})
         ns = nil
-        Fabulator::ActionLib.namespaces.each_pair do |k,v|
+        Fabulator::TagLib.namespaces.each_pair do |k,v|
           if v.is_a?(self)
             ns = k
           end
         end
-        Fabulator::ActionLib.types[ns] ||= {}
-        Fabulator::ActionLib.types[ns][nom] = options
+        Fabulator::TagLib.types[ns] ||= {}
+        Fabulator::TagLib.types[ns][nom] = options
 
         function nom do |ctx, args|
           args[0].collect { |i|
@@ -349,45 +381,67 @@ module Fabulator
       end
 
       def axis(nom, &block)
-        Fabulator::ActionLib.axes[nom] = block
+        Fabulator::TagLib.axes[nom] = block
       end
 
       def namespaces
-        Fabulator::ActionLib.namespaces
+        Fabulator::TagLib.namespaces
       end
   
       def desc(text)
-        Fabulator::ActionLib.last_description = RedCloth.new(Util.strip_leading_whitespace(text)).to_html
+        Fabulator::TagLib.last_description = RedCloth.new(Util.strip_leading_whitespace(text)).to_html
       end
       
       def action(name, klass = nil, &block)
-        self.action_descriptions[name] = Fabulator::ActionLib.last_description if Fabulator::ActionLib.last_description
-        Fabulator::ActionLib.last_description = nil
+        self.action_descriptions[name] = Fabulator::TagLib.last_description if Fabulator::TagLib.last_description
+        Fabulator::TagLib.last_description = nil
         if block
           define_method("action:#{name}", &block)
         elsif !klass.nil?
-          action(name) { |e,r|
-            return klass.new.compile_xml(e,r)
+          action(name) { |e,c|
+            r = klass.new
+            r.compile_xml(e,c)
+            r
+          }
+        end
+      end
+
+      def structural(name, klass = nil, &block)
+        self.structural_descriptions[name] = Fabulator::TagLib.last_description if Fabulator::TagLib.last_description
+        Fabulator::TagLib.last_description = nil
+        if block
+          define_method("structural:#{name}", &block)
+        elsif !klass.nil?
+          structural(name) { |e,c|
+            r = klass.new
+            r.compile_xml(e,c)
+            r
           }
+          Fabulator::TagLib.structural_classes[self.name] ||= {}
+          Fabulator::TagLib.structural_classes[self.name][name] = klass
         end
       end
 
+      def structural_class(nom)
+        (Fabulator::TagLib.structural_classes[self.class.name][nom] rescue nil)
+      end
+
       def function(name, returns = nil, takes = nil, &block)
         self.function_descriptions[name] = { :returns => returns, :takes => takes }
-        self.function_descriptions[name][:description] = Fabulator::ActionLib.last_description if Fabulator::ActionLib.last_description
+        self.function_descriptions[name][:description] = Fabulator::TagLib.last_description if Fabulator::TagLib.last_description
         #self.function_args[name] = { :return => returns, :takes => takes }
-        Fabulator::ActionLib.last_description = nil
+        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::ActionLib.last_description if Fabulator::ActionLib.last_description
-        Fabulator::ActionLib.last_description = nil
+        self.function_descriptions[name][: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]
         if !cons.nil?
-          Fabulator::ActionLib.last_description = self.function_descriptions[name][:description]
+          Fabulator::TagLib.last_description = self.function_descriptions[name][:description]
           consolidation name do |ctx, args|
             send "fctn:#{cons}", ctx, args
           end
@@ -396,15 +450,15 @@ module Fabulator
 
       def consolidation(name, opts = {}, &block)
         self.function_descriptions[name] = { :type => :consolidation }.merge(opts)
-        self.function_descriptions[name][:description] = Fabulator::ActionLib.last_description if Fabulator::ActionLib.last_description
-        Fabulator::ActionLib.last_description = nil
+        self.function_descriptions[name][: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)
         self.function_descriptions[name] = { :type => :mapping }.merge(opts)
-        self.function_descriptions[name][:description] = Fabulator::ActionLib.last_description if Fabulator::ActionLib.last_description
-        Fabulator::ActionLib.last_description = nil
+        self.function_descriptions[name][:description] = Fabulator::TagLib.last_description if Fabulator::TagLib.last_description
+        Fabulator::TagLib.last_description = nil
         define_method("fctn:#{name}", &block)
       end
 
@@ -431,22 +485,6 @@ module Fabulator
       def constraint(name, &block)
         define_method("constraint:#{name}", &block)
       end
-
-      def compile_actions(xml, rdf_model)
-        actions = [ ]
-        xml.each_element do |e|
-          ns = e.namespaces.namespace.href
-          #Rails.logger.info("Compiling <#{ns}><#{e.name}>")
-          next unless Fabulator::ActionLib.namespaces.include?(ns)
-          actions << (Fabulator::ActionLib.namespaces[ns].compile_action(e, rdf_model) rescue nil)
-          #Rails.logger.info("compile_actions: #{actions}")
-        end
-        #Rails.logger.info("compile_actions: #{actions}")
-        actions = actions - [ nil ]
-        #Rails.logger.info("compile_actions returning: #{actions}")
-        return actions
-      end
-  
     end
      
     module Util