fabulator 0.0.1

data/lib/fabulator/core/transition.rb

@@ -0,0 +1,164 @@
+module Fabulator
+  module Core
+  class Transition < Fabulator::Action
+    attr_accessor :state, :validations, :tags
+
+    namespace Fabulator::FAB_NS
+    attribute :view, :as => :lstate, :static => true
+    attribute :tag,  :as => :ltags,  :static => true, :default => ''
+
+    def initialize
+      @state = nil
+      @tags = nil
+      @groups = { }
+      @params = [ ]
+      @actions = nil
+    end
+
+    def compile_xml(xml, ctx)
+      super
+
+      inheriting = !@state.nil?
+
+      if !inheriting
+        @state = @lstate
+        @tags = @ltags
+      end
+
+        # TODO: figure out some way to reference inherited actions
+        #   figure out 'super' vs. 'inner' -- only supporting 'super'
+        #   for now
+      ActionLib.with_super(@actions) do
+        t = @context.compile_actions(xml)
+        @actions = t if @actions.nil? || !t.is_noop?
+      end
+      parser = Fabulator::Expr::Parser.new
+
+      xml.each_element do |e|
+        next unless e.namespaces.namespace.href == FAB_NS
+        case e.name
+# TODO: handle parameters when inheriting
+          when 'params':
+            p_ctx = @context.merge(e)
+            @select = p_ctx.get_select('/')
+
+            e.each_element do |ee|
+              next unless ee.namespaces.namespace.href == FAB_NS
+              case ee.name
+                when 'group':
+                  if !inheriting
+                    g = Group.new.compile_xml(ee, p_ctx)
+                    @params << g
+                  else
+                    tags = (ee.attributes.get_attribute_ns(FAB_NS, 'tag').value rescue '').split(/\s+/)
+                  end
+                when 'param':
+                  if !inheriting
+                    p = Parameter.new.compile_xml(ee, p_ctx)
+                    @params << p
+                  else
+                    tags = (ee.attributes.get_attribute_ns(FAB_NS, 'tag').value rescue '').split(/\s+/)
+                  end
+              end
+            end
+        end
+      end
+      self
+    end
+
+    def param_names
+      (@params.collect{|w| w.param_names}.flatten).uniq
+    end
+
+    def validate_params(context,params)
+      ctx = @context.merge(context)
+      my_params = params
+
+      param_context = Fabulator::Expr::Node.new(
+        'ext',
+        ctx.root.roots,
+        nil,
+        []
+      )
+      ctx.root.roots['ext'] = param_context
+      p_ctx = ctx.with_root(param_context)
+      p_ctx.merge_data(my_params)
+
+      if @select.nil?
+        self.apply_filters(p_ctx)
+      else
+        @select.run(p_ctx).each{ |c| self.apply_filters(p_ctx.with_root(c)) }
+      end
+
+      res = {
+        :unknown => [ ],
+        :valid => [ ],
+        :invalid => [ ],
+        :missing => [ ],
+        :messages => [ ],
+      }
+
+      if @select.nil?
+        rr = self.apply_constraints(p_ctx)
+        res[:invalid] += rr[:invalid]
+        res[:valid] += rr[:valid]
+        res[:unknown] += rr[:unknown]
+        res[:messages] += rr[:messages]
+      else
+        @select.run(p_ctx).each do |c|
+          rr = self.apply_constraints(p_ctx.with_root(c))
+          res[:invalid] += rr[:invalid]
+          res[:valid] += rr[:valid]
+          res[:unknown] += rr[:unknown]
+          res[:messages] += rr[:messages]
+        end
+      end
+
+      res[:unknown] = [ ]
+
+      res[:invalid].uniq!
+      res[:invalid].each do |k|
+        res[:valid].delete(k.path)
+        res[:unknown].delete(k.path)
+      end
+      #res[:unknown] = res[:unknown].collect{|k| @select + k}
+      res[:unknown].each do |k|
+        res[:valid].delete(k)
+      end
+
+      res[:score] = (res[:valid].size+1)*(params.size)
+      res[:score] = res[:score] / (res[:missing].size + 1)
+      res[:score] = res[:score] / (res[:invalid].size + 1)
+      res[:score] = res[:score] / (res[:unknown].size + 1)
+      return res
+    end
+
+    def apply_filters(ctx)
+      @params.collect { |p|
+        p.apply_filters(ctx)
+      }.flatten
+    end
+
+    def apply_constraints(ctx)
+      invalid = [ ]
+      missing = [ ]
+      valid = [ ]
+      msgs = [ ]
+      @params.each do |p|
+        res = p.apply_constraints(ctx)
+        invalid = invalid + res[:invalid]
+        missing = missing + res[:missing]
+        valid = valid + res[:valid]
+        msgs = msgs + res[:messages]
+      end
+      return { :missing => missing, :invalid => invalid, :valid => valid, :messages => msgs, :unknown => [ ] }
+    end
+
+    def run(context)
+      # do queries, denials, assertions in the order given
+      @actions.run(@context.merge(context))
+      return []
+    end
+  end
+  end
+end

data/lib/fabulator/expr.rb

@@ -0,0 +1,37 @@
+require 'fabulator/expr/context'
+require 'fabulator/expr/axis_descendent_or_self'
+require 'fabulator/expr/axis'
+require 'fabulator/expr/bin_expr'
+require 'fabulator/expr/node_logic'
+require 'fabulator/expr/node'
+require 'fabulator/expr/parser'
+require 'fabulator/expr/path_expr'
+require 'fabulator/expr/step'
+require 'fabulator/expr/unary_expr'
+require 'fabulator/expr/union_expr'
+require 'fabulator/expr/literal'
+
+require 'fabulator/expr/for_expr'
+require 'fabulator/expr/function'
+require 'fabulator/expr/if_expr'
+require 'fabulator/expr/let_expr'
+require 'fabulator/expr/path_expr'
+require 'fabulator/expr/predicates'
+require 'fabulator/expr/step'
+
+require 'fabulator/expr/statement_list'
+
+module Fabulator
+  module Expr
+    class ParserError < StandardError
+    end
+
+    class Exception < StandardError
+      attr_accessor :node
+
+      def initialize(n)
+        @node = n
+      end
+    end
+  end
+end

data/lib/fabulator/expr/axis.rb

@@ -0,0 +1,133 @@
+module Fabulator
+  module Expr
+    class Axis
+      def initialize(axis, n = nil)
+        case axis
+          when 'attribute':
+            @axis = AxisAttribute.new(n)
+          when 'child':
+            @axis = AxisChild.new(n)
+          when 'child-or-self':
+          when 'descendent':
+          when 'descendent-or-self':
+            @axis = AxisDescendentOrSelf.new(n)
+          when 'parent':
+            @axis = AxisParent.new(n)
+          else
+            @root = axis
+            @axis = n.nil? ? nil : AxisChild.new(n)
+        end
+      end
+
+      def run(context, autovivify = false)
+        if @root.nil? || @root == ''
+          return @axis.run(context, autovivify)
+        else
+          if context.root.roots[@root].nil? && !Fabulator::ActionLib.axes[@root].nil?
+            context.root.roots[@root] = Fabulator::ActionLib.axes[@root].call(context)
+          end
+          return context.root.roots[@root].nil? ? [ ] : 
+                                @axis.nil? ? [ context.root.roots[@root] ] : 
+                                             [ @axis.run(context.with_root(context.root.roots[@root])) ]
+        end
+      end
+    end
+
+    class AxisChild
+      def initialize(n)
+        @node_test = n
+      end
+
+      def run(context, autovivify = false)
+        if @node_test.is_a?(String)
+          n = @node_test
+        else
+          n = (@node_test.run(context).last.to_s rescue nil)
+        end
+        return [ ] if n.nil?
+        if n == '*'
+          possible = context.is_a?(Array) ? context.collect{|c| c.root.children}.flatten : context.root.children
+        else
+          possible = context.is_a?(Array) ? context.collect{|c| c.root.children(n)}.flatten : context.root.children(n)
+          if possible.empty? && autovivify
+            possible = context.traverse_path([ n ], true)
+          end
+        end
+        return possible
+      end
+    end
+
+    class AxisDescendentOrSelf
+      def initialize(step = nil)
+        @step = step
+      end
+
+      def run(context, autovivify = false)
+        if context.is_a?(Array)
+          stack = context.collect{ |c| c.root }
+        else
+          stack = [ context.root ]
+        end
+        possible = [ ]
+        while !stack.empty?
+          c = stack.shift
+
+          stack = stack + c.children
+
+          possible = possible + @step.run(context.with_root(c), autovivify)
+        end
+        return possible.uniq
+      end
+    end
+
+    class AxisParent
+      def run(context, autovivify = false)
+        if context.is_a?(Array)
+          context.collect { |c| c.root.parent }.uniq
+        else
+          context.root.parent
+        end
+      end
+    end
+
+    class AxisAttribute
+      def initialize(n)
+        @name = n
+      end
+
+      def run(context, autovivify = false)
+        res = [ ]
+        context = [ context ] unless context.is_a?(Array)
+          
+        res = context.collect { |c|
+          if @name.is_a?(String)
+            nom = @name
+          else
+            nom = (@name.run(c).last.to_s rescue nil)
+          end
+          if nom == 'type'
+            if c.root.vtype.nil?
+              nil
+            else
+              n = c.root.anon_node(nil)
+              n.parent = c.root
+              n.set_attribute('namespace', c.root.vtype[0])
+              n.set_attribute('name', c.root.vtype[1])
+              n.name = 'type'
+              n.vtype = [ FAB_NS, 'uri' ]
+              n
+            end
+          else
+            t = c.root.get_attribute(nom)
+            if(t.nil? && autovivify)
+              c.root.set_attribute(nom, nil)
+              t = c.root.get_attribute(nom)
+            end
+            t
+          end
+        }
+        res = res - [ nil ]
+      end
+    end
+  end
+end

data/lib/fabulator/expr/axis_descendent_or_self.rb

@@ -0,0 +1,26 @@
+module Fabulator
+  module Expr
+    class AxisDescendentOrSelf
+      def initialize(step = nil)
+        @step = step
+      end
+
+      def run(context, autovivify = false)
+        if context.is_a?(Array)
+          stack = context.root
+        else
+          stack = [ context.root ]
+        end
+        possible = [ ]
+        while !stack.empty?
+          c = stack.shift
+
+          stack = stack + c.children
+
+          possible = possible + context.with_root(c).run(@step, autovivify)
+        end
+        return possible.uniq
+      end
+    end
+  end
+end

data/lib/fabulator/expr/bin_expr.rb

@@ -0,0 +1,178 @@
+module Fabulator
+  module Expr
+    class BinExpr
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+
+      def expr_type(context)
+        lt = @left.expr_type(context)
+        rt = @right.expr_type(context)
+        Fabulator::ActionLib.unify_types([ lt, rt ])
+      end
+
+      def run(context, autovivify = false)
+        l = @left.run(context, autovivify)
+        r = @right.run(context, autovivify)
+
+        l = [ l ] unless l.is_a?(Array)
+        r = [ r ] unless r.is_a?(Array)
+
+        res = []
+
+        l.each do |i|
+          r.each do |j|
+            ut = Fabulator::ActionLib.unify_types([ i.vtype, j.vtype ])
+            op = ActionLib.find_op(ut, self.op)
+            if(op && op[:proc])
+              calc = op[:proc].call(i.to(ut), j.to(ut))
+            else
+              calc = self.calculate(i.to(ut).value,j.to(ut).value)
+            end
+            calc = [ calc ] unless calc.is_a?(Array)
+
+            rut = self.result_type(ut)
+            res = res + calc.collect { |c| c.is_a?(Fabulator::Expr::Node) ? c : context.root.anon_node(c, rut) }
+          end
+        end
+        return res
+      end
+
+      def result_type(t)
+        t
+      end
+    end
+
+    class AddExpr < BinExpr
+      def op
+        :plus
+      end
+
+      def calculate(a,b)
+        return nil if a.nil? || b.nil?
+        a + b
+      end
+    end
+
+    class SubExpr < BinExpr
+      def op
+        :minus
+      end
+
+      def calculate(a,b)
+        return nil if a.nil? || b.nil?
+        a - b
+      end
+    end
+
+    class BoolBinExpr < BinExpr
+      def expr_type(context)
+        [ FAB_NS, 'boolean' ]
+      end
+
+      def result_type(t)
+        [ FAB_NS, 'boolean' ]
+      end
+    end
+
+    class LtExpr < BoolBinExpr
+      def op
+        :lt
+      end
+
+      def calculate(a,b)
+        return nil if a.nil? || b.nil?
+        a < b
+      end
+    end
+
+    class LteExpr < BoolBinExpr
+      def op
+        :lte
+      end
+
+      def calculate(a,b)
+        return nil if a.nil? || b.nil?
+        a <= b
+      end
+    end
+
+    class EqExpr < BoolBinExpr
+      def op
+        :eq
+      end
+
+      def calculate(a,b)
+        a == b
+      end
+    end
+
+    class NeqExpr < BoolBinExpr
+      def op
+        :neq
+      end
+
+      def calculate(a,b)
+        a != b
+      end
+    end
+
+    class MpyExpr < BinExpr
+      def op
+        :times
+      end
+
+      def calculate(a,b)
+        return nil if a.nil? || b.nil?
+        a * b
+      end
+    end
+
+    class DivExpr < BinExpr
+      def op
+        :div
+      end
+
+      def calculate(a,b)
+        return nil if b.nil? || a.nil?
+        a / b
+      end
+    end
+
+    class ModExpr < BinExpr
+      def op
+        :mod
+      end
+
+      def calculate(a,b)
+        return nil if a.nil? || b.nil?
+        a % b
+      end
+    end
+
+    class RangeExpr < BinExpr
+      def op
+        :range
+      end
+
+      def expr_type(context)
+        [ FAB_NS, 'numeric' ]
+      end
+
+      def result_type(t)
+        [ FAB_NS, 'numeric' ]
+      end
+
+      def calculate(a,b)
+        return nil if a.nil? || b.nil?
+        if a < b
+          r = (a.to_i .. b.to_i).to_a
+        else
+          r = (b.to_i .. a.to_i).to_a.reverse
+        end
+        return r
+      end
+    end
+  end
+end