fabulator 0.0.8 → 0.0.9

data/lib/fabulator/tag_lib/presentations.rb

@@ -0,0 +1,39 @@
+module Fabulator
+  class TagLib
+    class Presentations
+      def initialize
+        @transformations = Fabulator::TagLib::Transformations.new
+        @interactives = { }
+        @structurals = { }
+      end
+
+      def transformations_into
+        @transformations
+      end
+
+      def interactives
+        @interactives.keys
+      end
+
+      def structurals
+        @structurals.keys
+      end
+
+      def interactive(nom)
+        @interactives[nom.to_sym] = nil
+      end
+
+      def structural(nom)
+        @structurals[nom.to_sym] = nil
+      end
+
+      def transform(fmt, doc, opts = { })
+        @transformations.transform(fmt, doc, opts)
+      end
+
+      def get_root_namespaces(fmt)
+        @transformations.get_root_namespaces(fmt)
+      end
+    end
+  end
+end

data/lib/fabulator/tag_lib/transformations.rb

@@ -0,0 +1,66 @@
+require 'xml/libxml'
+require 'libxslt'
+
+module Fabulator
+  class TagLib
+    class Transformations
+
+      def initialize
+        @formats = { }
+      end
+
+      def html(&block)
+        @formats[:html] ||= Fabulator::TagLib::Format.new
+        @formats[:html].instance_eval &block
+      end
+
+      def transform(fmt, doc, opts = { })
+        if !@formats[fmt.to_sym].nil?
+          @formats[fmt.to_sym].transform(doc, opts)
+        else
+          doc
+        end
+      end
+
+      def get_root_namespaces(fmt)
+        if !@formats[fmt.to_sym].nil?
+          @formats[fmt.to_sym].get_root_namespaces
+        else
+          []
+        end
+      end
+    end
+
+    class Format
+      def initialize
+      end
+
+      def transform(doc, opts)
+        if !@xslt.nil?
+          @xslt.apply(doc, opts) 
+        else
+          doc
+        end
+      end
+
+      def xslt_from_file(fpath)
+        @xslt_file = fpath
+        @xslt_doc = LibXML::XML::Document.file(@xslt_file)
+        @xslt = LibXSLT::XSLT::Stylesheet.new(@xslt_doc)
+      end
+
+      def get_root_namespaces
+        if !@xslt_doc.nil?
+          # extract namespace declarations from root element
+          ret = [ ]
+          @xslt_doc.root.namespaces.each { |ns|
+            ret << ns.href
+          }
+          ret
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/fabulator/tag_lib/type.rb

@@ -0,0 +1,176 @@
+module Fabulator
+  class TagLib
+    class Type
+      def initialize(t)
+        @type = t
+        @goings = { }
+        @comings = { }
+        @methods = { }
+      end
+
+      def vtype
+        @type
+      end
+
+      def going_to(t, &block)
+        return unless block
+        @goings[t.join('')] ||= [ ]
+        obj = TypeConversion.new(t)
+        obj.instance_eval &block
+        @goings[t.join('')] = obj
+      end
+
+      def coming_from(t, &block)
+        return unless block
+        @comings[t.join('')] ||= [ ]
+        obj = TypeConversion.new(t)
+        obj.instance_eval &block
+        @comings[t.join('')] = obj
+      end
+
+      def outgoing_conversions
+        @goings
+      end
+
+      def incoming_conversions
+        @comings
+      end
+
+      def method(nom, &block)
+        @methods[@type[0] + nom.to_s] = block
+      end
+
+      def get_method(nom)
+        @methods[nom]
+      end
+
+      def build_conversion_to(to)
+        return [] if to.nil? || self == to
+        ut = self._unify_types(to, true)
+        return [] if ut.nil? || ut[:t].join('') != to.join('')
+        return ut[:convert]
+      end
+
+      def unify_with_type(t)
+        self._unify_types(t)
+      end
+
+    protected
+
+      def _unify_types(to, ordered = false)
+        return nil if to.nil?
+        if to.is_a?(Array)
+          to = Fabulator::TagLib.type_handler(to)
+          return nil if to.nil?
+        end
+
+        d1 = { @type.join('') => { :t => self, :w => 1.0, :path => [ self ], :convert => [ ] } }
+        d2 = { to.vtype.join('') => { :t => to, :w => 1.0, :path => [ to ], :convert => [ ] } }
+       
+        added = true
+        while added
+          added = false
+          [d1, d2].each do |d|
+            d.keys.each do |t|   
+              d[t][:t].outgoing_conversions.each_pair do |conv_key, conv|
+                #conv_key = conv.vtype.join('')
+                w = d[t][:w] * conv.weight
+                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.vtype ]
+                    d[conv_key][:convert] = d[t][:convert] + [ conv ] - [nil]
+                  end
+                else
+                  added = true
+                  d[conv_key] = {
+                    :t => conv.vtype,
+                    :w => w,
+                    :path => d[t][:path] + [ conv.vtype ],
+                    :convert => d[t][:convert] + [ conv ] - [nil],
+                  }
+                end
+              end
+            end
+            Fabulator::TagLib.types.keys.each do |ns|
+              Fabulator::TagLib.types[ns].each_pair do |ct, tob|
+                to_key = ns + ct.to_s
+                tob.incoming_conversions.each_pair do |from_key, conv|
+                  #from_key = conv.vtype.join('')
+                  next unless 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.vtype ]
+                      d[to_key][:convert] = d[from_key][:convert] + [ conv ]
+                    end
+                  else
+                    added = true
+                    d[to_key] = {
+                      :t => [ ns, ct ],
+                      :w => w * 95.0 / 100.0,
+                      :path => d[from_key][:path] + [ conv.vtype ],
+                      :convert => d[from_key][:convert] + [ conv ],
+                    }
+                  end
+                end
+              end
+            end
+          end
+          r = self._select_type_path(d1, d2, to, ordered)
+          return r unless r.nil?
+        end
+        return self._select_type_path(d1, d2, to, ordered)
+      end
+
+      def _select_type_path(d1, d2, t2, ordered)
+        common = d1.keys & d2.keys
+        if ordered && common.include?(t2.vtype.join(''))
+          return d1[t2.vtype.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
+      end
+
+    end
+
+    class TypeConversion
+      def initialize(t)
+        @type = t
+        @weight = 0.0
+#        @guard = nil
+      end
+
+      def vtype
+        @type
+      end
+
+      def weight(w = nil)
+        @weight = w unless w.nil?
+        @weight
+      end
+
+#      def guard(&block)
+#        if !block.nil?
+#          @guard = block
+#        end
+#      end
+
+      def converting(&block)
+        @conversion = block
+      end
+
+      def convert(v)
+        return v.root.anon_node(nil) if @conversion.nil?
+        @conversion.call(v)
+      end
+
+#      def can_convert?(v)
+#        return true if @guard.nil?
+#        @guard.call(v)
+#      end
+    end
+  end
+end

data/lib/fabulator/template/parse_result.rb

@@ -1,20 +1,67 @@
 require 'xml/libxml'
-require 'libxslt'
 
 module Fabulator::Template
   class ParseResult
 
-    @@fabulator_xslt_file = File.join(File.dirname(__FILE__), "..", "..", "..", "xslt", "form.xsl")
+    def initialize(text)
+      ## we want to build up the XPath expression for structural and
+      ## interactive elements for use in adding default info and
+      ## building names for those elements -- saves the XSLT from having
+      ## to do this
 
+      structurals = { }
+      interactives = { }
 
-    @@fabulator_xslt_doc = LibXML::XML::Document.file(@@fabulator_xslt_file)
-    @@fabulator_xslt = LibXSLT::XSLT::Stylesheet.new(@@fabulator_xslt_doc)
+      Fabulator::TagLib.namespaces.each_pair do |ns, ob|
+        structurals[ns] = ob.presentation.structurals
+        interactives[ns] = ob.presentation.interactives
+      end
 
+      @namespaces = { }
+      i = 1
+      (structurals.keys + interactives.keys).uniq.sort.each do |ns|
+        @namespaces["fab_ns_#{i.to_s}"] = ns
+        i += 1
+      end
+
+      structural_xpaths = []
+      interactive_xpaths = []
+      interesting_xpaths = [ ]
+      @fab_prefix = ''
+      @namespaces.keys.each do |p|
+        @fab_prefix = p if @namespaces[p] == Fabulator::FAB_NS
+        structural_xpaths += structurals[@namespaces[p]].collect{ |e| "ancestor::#{p}:#{e}" }
+        interactive_xpaths += interactives[@namespaces[p]].collect{ |e| "//#{p}:#{e}" }
+        interesting_xpaths += structurals[@namespaces[p]].collect{ |e| "//#{p}:#{e}" }
+      end
+      @structural_xpath = structural_xpaths.join("[@id != ''] | ") + "[@id != '']"
+      @interactive_xpath = interactive_xpaths.join(" | ")
+
+      @interesting_xpath = (interactive_xpaths + interesting_xpaths).join(" | ")
+
+      @namespaces = @namespaces.collect{ |k,v| "#{k}:#{v}" }
+
+      ## We also may do our dependency tree -- namespaces in the
+      ## root element of the stylesheet will be run after the current
+      ## stylesheet
 
-    def initialize(text)
       @doc = LibXML::XML::Document.string text
+
+      @fab_ns = nil
+      @doc.root.namespaces.each do |ns|
+        if ns.href == Fabulator::FAB_NS
+          @fab_ns = ns
+        end
+      end
+
+      if @fab_ns.nil?
+        @fab_ns = XML::Namespace.new(@doc.root, @fab_prefix, Fabulator::FAB_NS)
+      end
     end
 
+    # This function walks through all of the elements in the provided
+    # markup and adds f:default child elements.  TagLibs declare data
+    # elements that should receive default values.
     def add_default_values(context)
       return if context.nil?
       each_form_element do |el|
@@ -22,13 +69,7 @@ module Fabulator::Template
         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').to_a
-          is_grid = true
-        else
-          default = el.find('./default').to_a
-        end
+        default = el.find("./#{@fab_prefix}:default", @namespaces).to_a
 
         id = el_id(el)
         ids = id.split('/')
@@ -37,31 +78,8 @@ module Fabulator::Template
           if !default.nil? && !default.empty?
             default.each { |d| d.remove! }
           end
-          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 << text_node('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 << text_node('default', v)
-                end
-              end
-            end
-          else
-            l.collect{|ll| ll.value}.each do |v|
-              el << text_node('default', v)
-            end
+          l.collect{|ll| ll.value}.each do |v|
+            el << text_node('default', v)
           end
         end
       end
@@ -92,7 +110,7 @@ module Fabulator::Template
     end
 
     def add_captions(captions = { })
-      each_form_element do |el|
+      each_element do |el|
         id = el_id(el)
         next if id == ''
         caption = nil
@@ -107,7 +125,7 @@ module Fabulator::Template
         is_grid = false
         if el.name == 'grid'
         else
-          cap = el.find_first('./caption')
+          cap = el.find_first("./#{@fab_prefix}:caption", @namespaces)
           if cap.nil?
             el << text_node('caption', caption)
           else
@@ -120,56 +138,101 @@ module Fabulator::Template
     end
 
     def to_s
-      @doc.to_s
+      @doc.to_s.gsub(/^\s*<\?xml\s+.*?\?>\s*/, '')
     end
 
     def to_html(popts = { })
-      opts = { :form => true }.update(popts)
+      opts = { :form => true, :theme => 'coal' }.update(popts)
+
+      deps = { }
+      Fabulator::TagLib.namespaces.each_pair do |ns, ob|
+        deps[ns] = ob.presentation.get_root_namespaces(:html) & (Fabulator::TagLib.namespaces.keys) - [ ns ]
+      end
+
+      ordered_ns = [ ]
+
+      next_round = ([ Fabulator::FAB_NS ] + deps.keys.select { |k| deps[k].empty? }).uniq
 
-      res = @@fabulator_xslt.apply(@doc)
+      while !next_round.empty? do
+        next_round.each { |k| deps.delete(k) }
+
+        ordered_ns += next_round
+
+        deps.keys.each do |k|
+          deps[k] -= ordered_ns
+        end
+
+        next_round = deps.keys.select{ |k| deps[k].empty? }
+      end
 
+      ordered_ns.reverse!
+
+      res = @doc
+      ordered_ns.each do |ns|
+        ob = Fabulator::TagLib.namespaces[ns]
+        next if ob.nil?
+        res = ob.presentation.transform(:html, res, opts)
+      end
+
+      ret = ''
       if opts[:form]
-        res.to_s
+        ret = res.to_s.gsub(/^\s*<\?xml\s+.*?\?>\s*/, '').gsub(/xmlns(:\S+)?=['"][^'"]*['"]/, '').gsub(/\s+/, ' ').gsub(/\s+>/, '>')
       else
-        res.find('//form/*').collect{ |e| e.to_s}.join('')
+        ret = res.find('//form/*').collect{ |e| e.to_s}.join('').gsub(/^\s*<\?xml\s+.*?\?>\s*/, '').gsub(/xmlns(:\S+)?=['"][^'"]*['"]/, '').gsub(/\s+/, ' ').gsub(/\s+>/, '>')
+
       end
+
+      ret.gsub!(/<(div\s*[^<]*?)\/>/, "<\\1></div>")
+      ret.gsub!(/<(span\s*[^<]*?)\/>/, "<\\1></span>")
+      ret
     end
 
 protected
 
+    def each_element(&block)
+      @doc.root.find(@interesting_xpath, @namespaces).each do |el|
+        yield el
+      end
+    end
+
     def each_form_element(&block)
-      @doc.root.find(%{
-        //text
-        | //textline
-        | //textbox
-        | //editbox
-        | //asset
-        | //password
-        | //selection
-        | //grid
-        | //submit
-      }).each do |el|
+      @doc.root.find(@interactive_xpath, @namespaces).each do |el|
         yield el
       end
+#      @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 != '']
-      })
+#      ancestors = el.find(%{
+#        ancestor::option[@id != '']
+#        | ancestor::group[@id != '']
+#        | ancestor::form[@id != '']
+#        | ancestor::container[@id != '']
+#      })
+      ancestors = el.find(@structural_xpath, @namespaces)
       ids = ancestors.collect{|a| a.attributes['id']}.select{|a| !a.nil? }
       ids << own_id
       ids.collect{|i| i.to_s}.join('/')
     end
 
     def text_node(n,t)
-      e = XML::Node.new(n)
+      e = XML::Node.new(n, nil)
+      e.namespaces.namespace = @fab_ns
       e << t
       e
     end