fabulator 0.0.1

data/lib/fabulator/expr/path_expr.rb

@@ -0,0 +1,49 @@
+module Fabulator
+  module Expr
+    class PathExpr
+      def initialize(pe, predicates, segment)
+        @primary_expr = pe
+        @predicates = predicates
+        @segment = (segment.is_a?(Array) ? segment : [ segment ]) - [nil]
+      end
+
+      def expr_type(context)
+        nil
+      end
+
+      def run(context, autovivify = false)
+        if @primary_expr.nil?
+          possible = [ context.root ]
+        else
+          possible = @primary_expr.run(context,autovivify).uniq
+        end
+
+        final = [ ]
+
+        @segment = [ @segment ] unless @segment.is_a?(Array)
+
+        possible.each do |e|
+          next if e.nil?
+          not_pass = false
+          @predicates.each do |p|
+            if !p.test(context.with_root(e))
+              not_pass = true
+              break
+            end
+          end
+          next if not_pass
+          pos = [ e ]
+          @segment.each do |s|
+            pos = pos.collect{ |p| 
+              s.run(context.with_root(p), autovivify) 
+            }.flatten - [ nil ]
+          end
+            
+          final = final + pos
+        end
+
+        return final
+      end
+    end
+  end
+end

data/lib/fabulator/expr/predicates.rb

@@ -0,0 +1,45 @@
+module Fabulator
+  module Expr
+    class Predicates
+      def initialize(axis,p)
+        @axis = axis
+        @predicates = p
+      end
+
+      def run(context, autovivify = false)
+        # we want to run through all of the predicates and return true if
+        # they all return true
+        result = [ ]
+        possible = @axis.run(context, autovivify)
+        return possible if @predicates.nil? || @predicates.empty?
+        @predicates.each do |p|
+          n_p = [ ]
+          if p.is_a?(Fabulator::Expr::IndexPredicate)
+            n_p = p.run(context).collect{ |i| possible[i-1] }
+          else
+            possible.each do |c|
+              res = p.run(context.with_root(c))
+              if res.is_a?(Array)
+                n_p << c if !res.empty? && !!res.first.value
+              else
+                n_p << c if !!res.value
+              end
+            end
+          end
+          possible = n_p
+        end
+        return possible
+      end
+    end
+
+    class IndexPredicate
+      def initialize(l)
+        @indices = l
+      end
+
+      def run(context)
+        @indices.collect { |e| e.run(context).collect{ |i| i.to([FAB_NS, 'numeric']).value.to_i } }.flatten
+      end
+    end
+  end
+end

data/lib/fabulator/expr/statement_list.rb

@@ -0,0 +1,96 @@
+module Fabulator
+  module Expr
+    class StatementList
+      def initialize
+        @statements = [ ]
+        @ensures = [ ]
+        @catches = [ ]
+      end
+
+      def add_statement(s)
+        @statements << s if !s.nil?
+      end
+
+      def add_ensure(s)
+        @ensures << s
+      end
+
+      def add_catch(s)
+        @catches << s
+      end
+
+      def is_noop?
+        @statements.empty? && @ensures.empty?
+      end
+
+      def run(context, autovivify = false)
+        result = [ ]
+        begin
+          if !@statements.nil?
+            (@statements - [nil]).each do |s| 
+              result = s.run(context, autovivify)
+            end
+          end
+        rescue Fabulator::StateChangeException => e
+          raise e
+        rescue => e
+          result = []
+          caught = false
+          ex = nil
+          if e.is_a?(Fabulator::Expr::Exception) 
+            ex = e.node
+          else
+            ex = context.root.anon_node(e.to_s, [ FAB_NS, 'string' ])
+            ex.set_attribute('class', 'ruby.' + e.class.to_s.gsub(/::/, '.'))
+          end
+          if !@catches.nil?
+            @catches.each do |s|
+              if !s.nil? && s.run_test(ex)
+                caught = true
+                result = s.run(context.with_root(ex), autovivify)
+              end
+            end
+          end
+
+          raise e unless caught
+        ensure
+          if !@ensures.nil? && !@ensures.empty?
+            @ensures.each do |s|
+              s.run(context, autovivify) unless s.nil?
+            end
+          end
+        end
+
+        return result
+      end
+    end
+
+    class WithExpr
+      def initialize(e,w)
+        @expr = e
+        @with = w
+      end
+
+      def run(context, autovivify = false)
+        result = @expr.run(context, autovivify)
+        result.each do |r|
+          @with.run(context.with_root(r), true)
+        end
+        result
+      end
+    end
+
+    class DataSet
+      def initialize(p,v)
+        @path = p
+        @value = v
+      end
+
+      def run(context, autovivify = false)
+        context.set_value(@path, @value)
+        [ context.root ]
+      end
+    end
+  end
+end
+

data/lib/fabulator/expr/step.rb

@@ -0,0 +1,43 @@
+module Fabulator
+  module Expr
+    class Step
+      def initialize(a,n)
+        @axis = a
+        @node_test = n
+      end
+
+      def run(context, autovivify = false)
+        c = context.root
+        if !@axis.nil? && @axis != '' && context.root.roots.has_key?(@axis) &&
+            @axis != context.root.axis
+          c = context.root.roots[@axis]
+        end
+        if @node_test.is_a?(String)
+          n = @node_test
+        else
+          n = (@node_test.run(context).last.value rescue nil)
+        end 
+        return [ ] if n.nil?
+        if n == '*'
+          possible = c.children
+        else
+          possible = c.children.select{ |cc| cc.name == n }
+          if possible.empty? && autovivify
+            #Rails.logger.info("Autovivifying #{n}")
+            possible = context.with_root(c).traverse_path([ n ], true)
+          end
+        end
+        return possible
+      end
+
+      def create_node(context)
+        return nil if node_text == '*'
+
+        c = Fabulator::Expr::Node.new(context.root.axis, context.root.roots, nil, [])
+        c.name = @node_test
+        context.root.add_child(c)
+        c
+      end
+    end
+  end
+end

data/lib/fabulator/expr/unary_expr.rb

@@ -0,0 +1,30 @@
+module Fabulator
+  module Expr
+    class UnaryExpr
+      def initialize(e)
+        @expr = e
+      end
+
+      def run(context, autovivify = false)
+        l = @expr.run(context, autovivify)
+
+        l = [ l ] unless l.is_a?(Array)
+
+        l = l.collect { |i| i.value }.uniq - [ nil ]
+
+        return @expr.collect{|e|  Fabulator::Expr::Node.new(
+              context.root.axis,
+              context.root.roots,
+              self.calculate(e),
+              []
+            ) }
+      end
+    end
+
+    class NegExpr < UnaryExpr
+      def calculate(e)
+        e.nil? ? nil : -e
+      end
+    end
+  end
+end

data/lib/fabulator/expr/union_expr.rb

@@ -0,0 +1,21 @@
+module Fabulator
+  module Expr
+    class UnionExpr
+      def initialize(es)
+        @exprs = es
+      end
+
+      def expr_type(context)
+        Fabulator::ActionLib.unify_types(@exprs.collect{ |e| e.expr_type(context) })
+      end
+
+      def run(context, autovivify = false)
+        u = [ ]
+        @exprs.each do |e|
+          u = u + e.run(context, autovivify)
+        end
+        return u.uniq
+      end
+    end
+  end
+end

data/lib/fabulator/template.rb

@@ -0,0 +1,9 @@
+module Fabulator
+  module Template
+    require 'fabulator/template/taggable'
+    require 'fabulator/template/standard_tags'
+    require 'fabulator/template/context'
+    require 'fabulator/template/parse_result'
+    require 'fabulator/template/parser'
+  end
+end

data/lib/fabulator/template/context.rb

@@ -0,0 +1,51 @@
+require 'radius'
+
+module Fabulator::Template
+  class Context < Radius::Context
+
+  attr_reader :context
+
+  def initialize(parser)
+    super()
+    @parser = parser
+    globals.context = @context
+    parser.tags.each do |name|
+      define_tag(name) { |tag_binding| parser.render_tag(name, tag_binding) }
+    end
+  end
+
+  def raise_errors?
+    true
+  end
+
+  def render_tag(name, attributes = {}, &block)
+    binding = @tag_binding_stack.last
+    locals = binding ? binding.locals : globals
+    set_process_variables(locals.page)
+    super
+  rescue Exception => e
+    raise e if raise_errors?
+    @tag_binding_stack.pop unless @tag_binding_stack.last == binding
+    render_error_message(e.message)
+  end
+
+  def tag_missing(name, attributes = {}, &block)
+    super
+  rescue Radius::UndefinedTagError => e
+    raise StandardTags::TagError.new(e.message)
+  end
+
+  private
+
+    def render_error_message(message)
+      "<div><strong>#{message}</strong></div>"
+    end
+
+    def set_process_variables(parser)
+      #parser.request ||= @parser.request
+      #parser.response ||= @parser.response
+    end
+
+  end
+end
+

data/lib/fabulator/template/parse_result.rb

@@ -0,0 +1,153 @@
+require 'xml/libxml'
+require 'xml/xslt'
+
+@@fabulator_xslt_file = File.join(File.dirname(__FILE__), "..", "..", "..", "xslt", "form.xsl")
+
+@@fabulator_xmlt = LibXML::XML::Document.file(@@fabulator_xslt_file)
+
+
+module Fabulator::Template
+  class ParseResult
+    def initialize(text)
+      @doc = LibXML::XML::Document.string text
+    end
+
+    def add_default_values(context)
+      each_form_element do |el|
+        own_id = el.attributes['id']
+        next if own_id.nil? || own_id.to_s == ''
+
+        default = nil
+        is_grid = false
+        if el.name == 'grid'
+          default = el.find('./default | ./row/default | ./column/default')
+          is_grid = true
+        else
+          default = el.find('./default')
+        end
+
+        id = el_id(el)
+        ids = id.split('/')
+        if !context.nil? && (default.is_a?(Array) && default.empty? || !default)
+          l = context.traverse_path(ids)
+          if !l.nil? && !l.empty?
+            if is_grid
+              count = (el.attributes['count'].to_s rescue '')
+              how_many = 'multiple' 
+              direction = 'both'
+              if count =~ %r{^(multiple|single)(-by-(row|column))?$}
+                how_many = $1
+                direction = $3 || 'both'
+              end
+              if direction == 'both' 
+                l.collect{|ll| ll.value}.each do |v|
+                  el << XML::Node.new('default', v)
+                end
+              elsif direction == 'row' || direction == 'column'
+                el.find("./#{direction}").each do |div|
+                  id = (div.attributes['id'].to_s rescue '')
+                  next if id == ''
+                  l.collect{|c| context.with_root(c).traverse_path(id)}.flatten.collect{|c| c.value}.each do |v|
+                    div << XML::Node.new('default', v)
+                  end
+                end
+              end
+            else
+              l.collect{|ll| ll.value}.each do |v|
+                el << XML::Node.new('default', v)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def add_missing_values(missing = [ ])
+      each_form_element do |el|
+        id = el_id(el)
+        next if id == ''
+        next unless missing.include?(id)
+        el.attributes["missing"] = "1"
+      end
+    end
+
+    def add_errors(errors = { })
+      each_form_element do |el|
+        id = el_id(el)
+        next if id == ''
+        next unless errors.has_key?(id)
+        if errors[id].is_a?(Array)
+          errors[id].each do |e|
+            el << XML::Node.new('error', e)
+          end
+        else
+          el << XML::Node.new('error', errors[id])
+        end
+      end
+    end
+
+    def add_captions(captions = { })
+      each_form_element do |el|
+        id = el_id(el)
+        next if id == ''
+        next unless captions.has_key?(id)
+
+        is_grid = false
+        if el.name == 'grid'
+        else
+          caption = el.find_first('./caption')
+          if caption.nil?
+            el << XML::Node.new('caption', captions[id])
+          else
+            caption.content = captions[id]
+          end
+        end
+      end
+    end
+
+    def to_s
+      @doc.to_s
+    end
+
+    def to_html
+      xslt = XML::XSLT.new
+      xslt.parameters = { }
+      xslt.xml = @doc
+      xslt.xsl = @@fabulator_xslt
+      xslt.serve
+    end
+
+protected
+
+    def each_form_element(&block)
+      @doc.root.find(%{
+        //text
+        | //textline
+        | //textbox
+        | //editbox
+        | //asset
+        | //password
+        | //selection
+        | //grid
+        | //submit
+      }).each do |el|
+        yield el
+      end
+    end
+
+    def el_id(el)
+      own_id = el.attributes['id']
+      return '' if own_id.nil? || own_id == ''
+
+      ancestors = el.find(%{
+        ancestor::option[@id != '']
+        | ancestor::group[@id != '']
+        | ancestor::form[@id != '']
+        | ancestor::container[@id != '']
+      })
+      ids = ancestors.collect{|a| a.attributes['id']}.select{|a| !a.nil? }
+      ids << own_id
+      ids.collect{|i| i.to_s}.join('/')
+    end
+  end
+end