fabulator 0.0.1

data/lib/fabulator/core/actions/choose.rb

@@ -0,0 +1,167 @@
+module Fabulator
+  module Core
+  module Actions
+  class Choose < Fabulator::Action
+    def compile_xml(xml, context)
+      super
+
+      @choices = [ ]
+      @default = nil
+
+      xml.each_element do |e|
+        next unless e.namespaces.namespace.href == FAB_NS
+        case e.name
+          when 'when':
+            @choices << When.new.compile_xml(e, @context)
+          when 'otherwise':
+            @default = When.new.compile_xml(e, @context)
+        end
+      end
+      self
+    end
+
+    def run(context, autovivify = false)
+      @context.with(context) do |ctx|
+        @choices.each do |c|
+          if c.run_test(ctx)
+            return c.run(ctx)
+          end
+        end
+        return @default.run(ctx) unless @default.nil?
+        return []
+      end
+    end
+  end
+
+  class When < Fabulator::Action
+    namespace Fabulator::FAB_NS
+    attribute :test, :eval => true, :static => false
+
+    has_actions
+
+    def run_test(context)
+      return true if @test.nil?
+      result = @test.run(@context.merge(context)).collect{ |a| !!a.value }
+      return false if result.nil? || result.empty? || !result.include?(true)
+      return true
+    end
+
+    def run(context, autovivify = false)
+      return @actions.run(@context.merge(context))
+    end
+  end
+
+  class If < Fabulator::Action
+    namespace Fabulator::FAB_NS
+    attribute :test, :eval => true, :static => false
+
+    has_actions
+
+    def run(context, autovivify = false)
+      return [ ] if @test.nil?
+      @context.with(context) do |ctx|
+        test_res = @test.run(ctx).collect{ |a| !!a.value }
+        return [ ] if test_res.nil? || test_res.empty? || !test_res.include?(true)
+        return @actions.run(ctx)
+      end
+    end
+  end
+
+  class Block < Fabulator::Action
+
+    namespace Fabulator::FAB_NS
+    has_actions
+
+    def run(context, autovivify = false)
+       return @actions.run(@context.merge(context),autovivify)
+    end
+  end
+
+  class Goto < Fabulator::Action
+    namespace Fabulator::FAB_NS
+    attribute :test, :eval => true, :static => false
+    attribute :state, :static => true
+
+    def run(context, autovivify = false)
+      raise Fabulator::StateChangeException, @state, caller if @test.nil?
+      test_res = @test.run(@context.merge(context)).collect{ |a| !!a.value }
+      return [ ] if test_res.nil? || test_res.empty? || !test_res.include?(true)
+      raise Fabulator::StateChangeException, @state, caller
+    end
+  end
+
+  class Catch < Fabulator::Action
+    namespace Fabulator::FAB_NS
+    attribute :test, :eval => true, :static => false
+    attribute :as, :static => true
+
+    has_actions
+
+    def run_test(context)
+      return true if @test.nil?
+      @context.with(context) do |ctx|
+        ctx.set_var(@as, context) if @as
+        result = @test.run(context).collect{ |a| !!a.value }
+        return false if result.nil? || result.empty? || !result.include?(true)
+        return true
+      end
+    end
+
+    def run(context, autovivify = false)
+      @context.with(context) do |ctx|
+        ctx.set_var(@as, context) if @as
+        return @actions.run(context)
+      end
+    end
+  end
+
+  class Raise < Fabulator::Action
+ 
+    namespace Fabulator::FAB_NS
+    attribute :test, :eval => true, :static => false
+    has_actions
+
+    def run(context, autovivify = false)
+      @context.with(context) do |ctx|
+        select = ctx.get_select
+        if !@test.nil?
+          test_res = @test.run(ctx).collect{ |a| !!a.value }
+          return [ ] if test_res.nil? || test_res.empty? || !test_res.include?(true)
+        end
+        res = [ ]
+        if select.nil? && !@actions.nil?
+          res = @actions.run(ctx, autovivify)
+        elsif !select.nil?
+          res = select.run(ctx, autovivify)
+        else
+          raise ctx   # default if <raise/> with no attributes
+        end
+
+        return [ ] if res.empty?
+
+        raise Fabulator::Expr::Exception.new(res.first)
+      end
+    end
+  end
+
+  class Super < Fabulator::Action
+    namespace Fabulator::FAB_NS
+    has_select
+    has_actions :super
+
+    def run(context, autovivify = false)
+      return [] if @actions.nil?
+
+      @context.with(context) do |ctx|
+        new_context = @select.run(ctx,autovivify)
+
+        new_context = [ new_context ] unless new_context.is_a?(Array)
+
+        return new_context.collect { |c| @actions.run(ctx.with_root(c), autovivify) }.flatten
+      end
+    end
+  end
+
+  end
+  end
+end

data/lib/fabulator/core/actions/for_each.rb

@@ -0,0 +1,105 @@
+module Fabulator
+  module Core
+  module Actions
+  class ForEach < Fabulator::Action
+    namespace Fabulator::FAB_NS
+    attribute :as, :static => true
+    has_select
+    has_actions
+
+    def compile_xml(xml, context)
+      super
+      @sort = [ ]
+
+      xml.each_element do |e|
+        next unless e.namespaces.namespace.href == FAB_NS
+        case e.name
+          when 'sort-by':
+            @sort << Sort.new.compile_xml(e, @context)
+        end
+      end
+      self
+    end
+
+    def run(context, autovivify = false)
+      @context.with(context) do |ctx|
+        items = @select.run(ctx)
+        res = nil
+        ctx.in_context do |c|
+          if !@sort.empty?
+            items = items.sort_by{ |i| 
+              c.set_var(@as, i) unless @as.nil? 
+              @sort.collect{|s| s.run(c.with_root(i)) }.join("\0") 
+            }
+          end
+          res = [ ]
+          items.each do |i|
+            c.set_var(@as, i) unless @as.nil?
+            res = res + @actions.run(c.with_root(i))
+          end
+        end
+        return res
+      end
+    end
+  end
+
+  class Sort < Fabulator::Action
+    namespace Fabulator::FAB_NS
+    has_select
+
+    def run(context, autovivify = false)
+      (@select.run(@context.merge(context)).first.to_s rescue '')
+    end
+  end
+
+  class Considering < Fabulator::Action
+    namespace Fabulator::FAB_NS
+    attribute :as, :static => true
+    has_select
+    has_actions
+
+    def run(context, autovivify = false)
+      return [] if @select.nil?
+      res = [ ]
+      @context.with(context) do |ctx|
+        c = @select.run(ctx)
+        root = nil
+        if @as.nil?
+          if c.size == 1
+            root = c.first
+          else
+            root = Fabulator::Expr::Node.new('data', context.root.roots, nil, c)
+          end
+          res = @actions.run(ctx.with_root(root))
+        else
+          ctx.in_context do |ctx2|
+            ctx2.set_var(@as, c)
+            res = @actions.run(ctx2)
+          end
+        end
+      end
+      res
+    end
+  end
+
+  class While < Fabulator::Action
+    namespace Fabulator::FAB_NS
+    attribute :test, :eval => true, :static => false
+    attribute :limit, :default => 1000
+    has_actions
+
+    def run(context, autovivify = false)
+      res = [ ]
+      counter = 0
+      @context.with(context) do |ctx|
+        lim = @limit.nil? ? 1000 : @limit.run(ctx).first.value
+        while counter < @limit && (!!@test.run(ctx).first.value rescue false)
+          res = res + @actions.run(ctx)
+        end
+      end
+      res
+    end
+  end
+  end
+  end
+end

data/lib/fabulator/core/actions/variables.rb

@@ -0,0 +1,52 @@
+module Fabulator
+  module Core
+  module Actions
+  class ValueOf < Fabulator::Action
+    namespace Fabulator::FAB_NS
+    has_select
+
+    def run(context, autovivify = false)
+      @select.run(@context.merge(context), autovivify)
+    end
+  end
+
+  class Value < Fabulator::Action
+    attr_accessor :select, :name
+
+    namespace Fabulator::FAB_NS
+    attribute :path, :static => true
+    has_select nil
+    has_actions
+
+    def run(context, autovivify = false)
+      @context.with(context) do |ctx|
+        ctx.set_value(@path, @select.nil? ? @actions : @select )
+      end
+    end
+  end
+
+  class Variable < Fabulator::Action
+    namespace Fabulator::FAB_NS
+    attribute :name, :eval => false, :static => true
+    has_select
+    has_actions
+
+    def run(context, autovivify = false)
+      return [] if @name.nil?
+      res = [ ]
+      @context.with(context) do |ctx|
+        if @select
+          res = @select.run(ctx, autovivify)
+        elsif !@actions.empty?
+          @actions.each do |a|
+            res = a.run(ctx, autovivify)
+          end
+        end
+      end
+      context.set_var(@name, res)
+      res
+    end
+  end
+  end
+  end
+end

data/lib/fabulator/core/constraint.rb

@@ -0,0 +1,117 @@
+module Fabulator
+  module Core
+  class Constraint < Fabulator::Action
+
+    namespace Fabulator::FAB_NS
+    attribute :invert, :static => true, :default => 'false'
+    attribute :name, :as => :c_type, :static => true
+    has_select
+
+    def compile_xml(xml, ctx)
+      super
+      @constraints = [ ]
+      @values = [ ]
+      @params = [ ]
+      @attributes = { }
+
+      if xml.name == 'value'
+        @c_type = 'any'
+        @values << xml.content
+      else
+        xml.each_attr do |attr|
+          next unless attr.ns.href == FAB_NS
+          next if attr.name == 'name' || attr.name == 'invert'
+          @attributes[attr.name] = attr.value
+        end
+        xml.each_element do |e|
+          next unless e.namespaces.namespace.href == FAB_NS
+          e_ctx = @context.merge(e)
+          case e.name
+            when 'param':
+              pname = e_ctx.attribute(FAB_NS, 'name') # (e.get_attribute_ns(FAB_NS, 'name').value rescue nil)
+              if !pname.nil?
+                v = e_ctx.attribute(FAB_NS, 'value', { :default => e_ctx.get_select })
+                @params[pname] = v unless v.nil?
+              end
+            when 'constraint':
+              @constraints << Constraint.new.compile_xml(e, @context)
+            when 'value':
+              v = e_ctx.get_select
+              if v.nil?
+                v = e.content
+              end
+              @values << v unless v.nil?
+          end
+        end
+      end
+      self
+    end
+
+    def error_message(context)
+      "#{context.path} does not pass the constraint"
+    end
+
+    def test_constraint(context)
+      # do special ones first
+      @context.with(context) do |ctx|
+        paths = [ [ ctx.root.path ], [] ]
+        r = paths
+
+        inv = (@invert == 'true' || @invert == 'yes') ? true : false
+        sense = !inv ? Proc.new { |r| r } : Proc.new { |r| r.reverse }
+        not_sense = inv ? Proc.new { |r| r } : Proc.new { |r| r.reverse }
+
+        case @c_type
+          when nil, '':
+            return sense.call(paths) if select.nil?
+            opts = @select.run(ctx).collect { |o| o.to_s } 
+            if !opts.include?(ctx.root.to_s)
+              paths[0] -= [ ctx.root.path ]
+              paths[1] += [ ctx.root.path ]
+            end
+            return sense.call(paths)
+          when 'all':
+            # we have enclosed constraints
+            @constraints.each do |c|
+              r = c.test_constraint(ctx)
+              return sense.call(r) unless r[1].empty?
+            end
+            return not_sense.call(r)
+          when 'any':
+            if @values.empty?
+              @constraints.each do |c|
+                r = c.test_constraint(ctx)
+                return not_sense.call(r) if r[1].empty?
+              end
+              return sense.call(r)
+            else
+              calc_values = [ ]
+              @values.each do |v|
+                if v.is_a?(String)
+                  calc_values << v
+                else
+                  calc_values = calc_values + v.run(ctx).collect{ |i| i.value }
+                end
+              end
+              if !calc_values.include?(ctx.root.value)
+                paths[0] -= [ ctx.root.path ]
+                paths[1] += [ ctx.root.path ]
+              end
+              return sense.call(paths)
+            end
+          when 'range':
+            fl = (@params['floor'].run(ctx) rescue nil)
+            ce = (@params['ceiling'].run(ctx) rescue nil)
+            if !fl.nil? && fl > c.value || !ce.nil? && ce < c.value
+              paths[0] -= [ c.path ]
+              paths[1] += [ c.path ]
+            end
+            return sense.call(r)
+          else
+            return not_sense.call(r)
+        end
+      end
+    end
+  end
+  end
+end

data/lib/fabulator/core/filter.rb

@@ -0,0 +1,41 @@
+module Fabulator
+  module Core
+  class Filter < Fabulator::Action
+    namespace Fabulator::FAB_NS
+    attribute :name, :static => true
+    
+#    def compile_xml(xml, context)
+#      @context = context.merge(xml)
+#      filter_type = @context.attribute(FAB_NS, 'name', {:static => true}).split(/:/, 2)
+#      if filter_type.size == 2
+#        @ns = @context.get_ns(filter_type[0])
+#        @name = filter_type[1]
+#      else
+#        @ns = FAB_NS
+#        @name = filter_type[0]
+#      end
+#      self
+#    end
+
+    def run(context)
+      filtered = [ ]
+      @context.with(context) do |ctx|
+        filter_type = @name.split(/:/,2)
+        ns = nil
+        name = nil
+        if filter_type.size == 2
+          ns = @context.get_ns(filter_type[0])
+          name = filter_type[1]
+        else
+          ns = FAB_NS
+          name = filter_type[0]
+        end
+
+        ctx.run_filter(ns, name)
+        filtered << ctx.root.path
+      end
+      return filtered
+    end
+  end
+  end
+end