fabulator 0.0.1

data/History.txt

@@ -0,0 +1,4 @@
+=== 0.0.1 2010-02-23
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,41 @@
+History.txt
+Manifest.txt
+README.rdoc
+lib/fabulator.rb
+lib/fabulator/action.rb
+lib/fabulator/action_lib.rb
+lib/fabulator/context.rb
+lib/fabulator/core.rb
+lib/fabulator/core/actions.rb
+lib/fabulator/core/actions/choose.rb
+lib/fabulator/core/actions/for_each.rb
+lib/fabulator/core/actions/variables.rb
+lib/fabulator/core/constraint.rb
+lib/fabulator/core/filter.rb
+lib/fabulator/core/group.rb
+lib/fabulator/core/parameter.rb
+lib/fabulator/core/state.rb
+lib/fabulator/core/state_machine.rb
+lib/fabulator/core/transition.rb
+lib/fabulator/expr.rb
+lib/fabulator/expr/axis.rb
+lib/fabulator/expr/axis_descendent_or_self.rb
+lib/fabulator/expr/bin_expr.rb
+lib/fabulator/expr/context.rb
+lib/fabulator/expr/for_expr.rb
+lib/fabulator/expr/function.rb
+lib/fabulator/expr/function.rb.old
+lib/fabulator/expr/if_expr.rb
+lib/fabulator/expr/let_expr.rb
+lib/fabulator/expr/literal.rb
+lib/fabulator/expr/node.rb
+lib/fabulator/expr/node.rb.bak
+lib/fabulator/expr/node_logic.rb
+lib/fabulator/expr/parser.rb
+lib/fabulator/expr/path_expr.rb
+lib/fabulator/expr/predicates.rb
+lib/fabulator/expr/statement_list.rb
+lib/fabulator/expr/step.rb
+lib/fabulator/expr/unary_expr.rb
+lib/fabulator/expr/union_expr.rb
+lib/fabulator/version.rb

data/README.rdoc

@@ -0,0 +1,61 @@
+= fabulator
+
+* http://github.com/jgsmith/ruby-fabulator
+
+== DESCRIPTION:
+
+The fabulator library provides a state machine implementation of a core 
+set of semantics for building data-driven applications using a simple
+XML language coupled with an XQuery-like expression language.
+
+== FEATURES/PROBLEMS:
+
+* XML compilation into Ruby objects
+* XQuery-like expression language for accessing data
+* Easily extensible with XML actions and expression functions
+
+== SYNOPSIS:
+
+ require 'fabulator'
+
+ parser = Fabulator::Expr::Parser.new
+ context = Fabulator::Expr::Context.new_context_environment
+
+ context.set_value( '/a', 'some_values' )
+ expr = parser.parse( 'f:sum(/a[. > 0]' )
+ result = expr.run( context )
+
+ puts "sum: #{ result.value }"
+
+== REQUIREMENTS:
+
+The expression engine does not depend on any external libraries.  The
+XML framework depends on the Ruby libxml libraries at
+<http://libxml.rubyforge.org/>.
+
+== INSTALL:
+
+* sudo gem install fabulator
+
+== LICENSE:
+
+Copyright (c) 2009-2010 Texas A&M University
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,54 @@
+$: << File.expand_path(File.dirname(__FILE__))+'/lib'
+
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require 'fabulator'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+Hoe.plugin :cucumberfeatures
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'fabulator' do
+  self.version = Fabulator::VERSION::STRING
+  self.developer 'James Smith', 'jgsmith@tamu.edu'
+  self.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  self.rubyforge_name       = self.name # TODO this is default value
+  # self.extra_deps         = [['activesupport','>= 2.0.2']]
+
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# remove_task :default
+# task :default => [:spec, :features]
+
+desc "Look for TODO and FIXME tags in the code"
+task :todo do
+  egrep /(FIXME|TODO|TBD)/
+end
+
+desc "verify_committed, verify_rcov, post_news, release"
+task :complete_release => [:verify_committed, :release]
+
+desc "Verifies that there is no uncommitted code"
+task :verify_committed do
+  IO.popen('git status') do |io|
+    io.each_line do |line|
+      raise "\n!!! Do a git commit first !!!\n\n" if line =~ /^#\s*modified:/
+    end
+  end
+end
+
+namespace :update do
+  desc "update the manifest"
+  task :manifest do
+    system %q[touch Manifest.txt; rake check_manifest | grep -v "(in " | patch]
+  end
+end
+

data/lib/fabulator.rb

@@ -0,0 +1,5 @@
+require 'fabulator/expr'
+require 'fabulator/action_lib'
+require 'fabulator/action'
+require 'fabulator/core'
+require 'fabulator/version'

data/lib/fabulator/action.rb

@@ -0,0 +1,46 @@
+module Fabulator
+  class Action
+
+    def compile_xml(xml, context)
+      @context = context.merge(xml)
+      klass = self.class.name
+      if @@attributes[klass]
+        @@attributes[klass].each_pair do |nom, opts|
+          as = "@" + (opts[:as] || nom).to_s
+          self.instance_variable_set(as.to_sym, @context.attribute(opts[:namespace] || @@namespace[klass], nom.to_s, opts))
+        end
+      end
+      @select = @context.get_select(@@has_select[klass]) if @@has_select.has_key?(klass)
+      if @@has_actions[klass]
+        case @@has_actions[klass]
+          when :simple:
+            @actions = @context.compile_actions(xml)
+          when :super:
+            @actions = ActionLib.current_super
+        end
+      end
+      self
+    end
+
+    def self.namespace(href)
+      @@namespace ||= { }
+      @@namespace[self.name] = href
+    end
+
+    def self.attribute(nom, opts = { })
+      @@attributes ||= { }
+      @@attributes[self.name] ||= { }
+      @@attributes[self.name][nom.to_s] = opts
+    end
+
+    def self.has_actions(t = :simple)
+      @@has_actions ||= { }
+      @@has_actions[self.name] = t
+    end
+
+    def self.has_select(default = '.')
+      @@has_select ||= { }
+      @@has_select[self.name] = default
+    end
+  end
+end

data/lib/fabulator/action_lib.rb

@@ -0,0 +1,438 @@
+module Fabulator
+  module ActionLib
+    @@action_descriptions = {}
+    @@function_descriptions = {}
+    @@function_args = { }
+    @@namespaces = {}
+    @@attributes = [ ]
+    @@last_description = nil
+    @@types = { }
+    @@axes = { }
+
+    def self.last_description
+      @@last_description
+    end
+    def self.namespaces
+      @@namespaces
+    end
+    def self.action_descriptions
+      @@action_descriptions
+    end
+    def self.function_description
+      @@function_description
+    end
+    def self.function_args
+      @@function_args
+    end
+    def self.attributes
+      @@attributes
+    end
+    def self.types
+      @@types
+    end
+    def self.axes
+      @@axes
+    end
+
+    def self.last_description=(x)
+      @@last_description = x
+    end
+    def self.namespaces=(x)
+      @@namespaces = x
+    end
+    def self.action_descriptions=(x)
+      @@action_descriptions = x
+    end
+    def self.function_description=(x)
+      @@function_description = x
+    end
+    def self.function_args=(x)
+      @@function_args = x
+    end
+    def self.attributes=(x)
+      @@attributes = x
+    end
+    def self.types=(x)
+      @@types = x
+    end
+    def self.axes=(x)
+      @@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
+      end
+    end
+
+    def self.find_op(t,o)
+      (@@types[t[0]][t[1]][:ops][o] rescue nil)
+    end
+
+    # returns nil if no common type can be found
+    def self.unify_types(ts)
+      # breadth-first search from all ts to find common type that
+      # we can convert to.  We have to check all levels each time
+      # in case one of the initial types becomes a common type across
+      # all ts
+
+      return nil if ts.empty? || ts.include?(nil)
+
+      # now group by types since we only need one of each type for unification
+      grouped = { }
+      ts.each do |t|
+        grouped[t.join('')] = t
+      end
+
+      grouped = grouped.values
+
+      return grouped.first if grouped.size == 1
+     
+      # now we unify based on the first two and then adding one each time
+      # until we unify all of them
+      t1 = grouped.pop
+      t2 = grouped.pop
+      ut = self._unify_types(t1, t2)
+      return nil if ut.nil?
+      self.unify_types([ ut[:t] ] + grouped)
+    end
+
+    def self.type_path(from, to)
+      return [] if from.nil? || to.nil? || from.join('') == to.join('')
+      ut = self._unify_types(from, to, true)
+      return [] if ut.nil? || ut[:t].join('') != to.join('')
+      return ut[:convert]
+    end
+
+    ## TODO: allow unification with values as well so we can have
+    #        conversions dependent on the value
+    # for example: strings that look like integers can convert to integers
+    def self._unify_types(t1, t2, ordered = false)
+      return nil if t1.nil? || t2.nil?
+      d1 = { t1.join('') => { :t => t1, :w => 1.0, :path => [ t1 ], :convert => [ ] } }
+      d2 = { t2.join('') => { :t => t2, :w => 1.0, :path => [ t2 ], :convert => [ ] } }
+
+      added = true
+      while added
+        added = false
+        [d1, d2].each do |d|
+          d.keys.each do |t|
+            if (@@types[d[t][:t][0]][d[t][:t][1]].has_key?(:to) rescue false)
+              @@types[d[t][:t][0]][d[t][:t][1]][:to].each do |conv|
+                w = d[t][:w] * conv[:weight]
+                conv_key = conv[:type].join('')
+                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[:type] ]
+                    d[conv_key][:convert] = d[t][:convert] + [ conv[:convert] ] - [nil]
+                  end
+                else
+                  d[conv_key] = {
+                    :t => conv[:type],
+                    :w => w,
+                    :path => d[t][:path] + [ conv[:type] ],
+                    :convert => d[t][:convert] + [ conv[:convert] ] - [ nil ]
+                  }
+                  added = true
+                end
+              end
+            end
+          end
+          # go through each type looking for :from
+          @@types.keys.each do |ns|
+            @@types[ns].each_pair do |ct, cd|
+              next if cd[:from].nil?
+              to_key = ns + ct
+              cd[:from].each do |conv|
+                next if conv[:type].nil?
+                from_key = conv[:type].join('')
+                next if !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[:type] ]
+                    d[to_key][:convert] = d[from_key][:convert] + [ conv[:convert] ] - [nil]
+                  end
+                else
+                  d[to_key] = {
+                    :t => [ns, ct],
+                    :w => w * 95 / 100, # favor to over from
+                    :path => d[from_key][:path] + [ conv[:type] ],
+                    :convert => d[from_key][:convert] + [ conv[:convert] ] - [ nil ]
+                  }
+                  added = true
+                end
+              end
+            end
+          end
+        end
+        common = d1.keys & d2.keys
+        if ordered && common.include?(t2.join(''))
+          return d1[t2.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
+      end
+      common = d1.keys & d2.keys
+      if ordered && common.include?(t2.join(''))
+        return d1[t2.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
+
+    def self.with_super(s, &block)
+      @@super ||= []  # not thread safe :-/
+      @@super.unshift(s)
+      yield
+      @@super.shift
+    end
+
+    def self.current_super
+      return nil if @@super.nil? || @@super.empty?
+      return @@super.first
+    end
+
+    def compile_action(e, c)
+      if self.class.method_defined? "action:#{e.name}"
+        send "action:#{e.name}", e, c.merge(e)
+      end
+    end
+
+    def run_function(context, nom, args, depth=0)
+      ret = []
+
+      #begin
+        case self.function_run_type(nom)
+        when :mapping
+          ret = args.flatten.collect { |a| send "fctn:#{nom}", context, a }
+        when :reduction
+          ret = send "fctn:#{nom}", context, args.flatten
+        else
+          ret = send "fctn:#{nom}", context, args
+        end
+      #rescue => e
+      #  raise "function #{nom} raised #{e}"
+      #end
+      ret = [ ret ] unless ret.is_a?(Array)
+      ret = ret.flatten.collect{ |r| 
+        if r.is_a?(Fabulator::Expr::Node) 
+          r 
+        elsif r.is_a?(Hash)
+          rr = context.root.anon_node(nil, nil)
+          r.each_pair do |k,v|
+            rrr = context.root.anon_node(v) #, self.function_return_type(nom))
+            rrr.name = k
+            rr.add_child(rrr)
+          end
+          rr
+        else
+          context.root.anon_node(r) #, self.function_return_type(nom))
+        end
+      }
+      ret.flatten
+    end
+
+    def function_return_type(name)
+      (self.function_descriptions[name][:returns] rescue nil)
+    end
+
+    def function_run_scaling(name)
+      (self.function_descriptions[name][:scaling] rescue nil)
+    end
+
+    def function_run_type(name)
+      (self.function_descriptions[name][:type] rescue nil)
+    end
+
+    def function_args
+      @function_args ||= { }
+    end
+
+    def run_filter(context, nom)
+      send "filter:#{nom}", context
+    end
+
+    def run_constraint(context, nom)
+      context = [ context ] unless context.is_a?(Array)
+      paths = [ [], [] ]
+      context.each do |c|
+        p = send("constraint:#{nom}", c) 
+        paths[0] += p[0]
+        paths[1] += p[1]
+      end
+      return [ (paths[0] - paths[1]).uniq, paths[1].uniq ]
+    end
+
+    def action_descriptions(hash=nil)
+      self.class.action_descriptions hash
+    end
+
+    def function_descriptions(hash=nil)
+      self.class.function_descriptions hash
+    end
+
+    def function_args(hash=nil)
+      self.class.function_args hash
+    end
+
+    module ClassMethods
+      def inherited(subclass)
+        subclass.action_descriptions.reverse_merge! self.action_descriptions
+        subclass.function_descriptions.reverse_merge! self.function_descriptions
+        super
+      end
+      
+      def action_descriptions(hash = nil)
+        Fabulator::ActionLib.action_descriptions[self.name] ||= (hash ||{})
+      end
+
+      def function_descriptions(hash = nil)
+        Fabulator::ActionLib.action_descriptions[self.name] ||= (hash ||{})
+      end
+    
+      def register_namespace(ns)
+        Fabulator::ActionLib.namespaces[ns] = self.new
+      end
+
+      def register_attribute(a, options = {})
+        ns = nil
+        Fabulator::ActionLib.namespaces.each_pair do |k,v|
+          if v.is_a?(self)
+            ns = k
+          end
+        end
+        Fabulator::ActionLib.attributes << [ ns, a, options ]
+      end
+
+      def register_type(nom, options={})
+        ns = nil
+        Fabulator::ActionLib.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
+
+        function nom do |ctx, args|
+          args[0].collect { |i|
+            i.to([ ns, nom ])
+          }
+        end
+      end
+
+      def axis(nom, &block)
+        Fabulator::ActionLib.axes[nom] = block
+      end
+
+      def namespaces
+        Fabulator::ActionLib.namespaces
+      end
+  
+      def desc(text)
+        Fabulator::ActionLib.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
+        if block
+          define_method("action:#{name}", &block)
+        elsif !klass.nil?
+          action(name) { |e,r|
+            return klass.new.compile_xml(e,r)
+          }
+        end
+      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_args[name] = { :return => returns, :takes => takes }
+        Fabulator::ActionLib.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
+        define_method("fctn:#{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
+        define_method("fctn:#{name}", &block)
+      end
+
+      def function_decl(name, expr, ns)
+        parser = Fabulator::Expr::Parser.new
+        fctn_body = parser.parse(expr, ns)
+
+        function name do |ctx, args, ns|
+          res = nil
+          ctx.in_context do
+            args.size.times do |i|
+              ctx.set_var((i+1).to_s, args[i])
+            end
+            res = fctn_body.run(ctx)
+          end
+          res
+        end
+      end
+
+      def filter(name, &block)
+        define_method("filter:#{name}", &block)
+      end
+
+      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
+      def self.strip_leading_whitespace(text)
+        text = text.dup
+        text.gsub!("\t", "  ")
+        lines = text.split("\n")
+        leading = lines.map do |line|
+          unless line =~ /^\s*$/
+             line.match(/^(\s*)/)[0].length
+          else
+            nil
+          end
+        end.compact.min
+        lines.inject([]) {|ary, line| ary << line.sub(/^[ ]{#{leading}}/, "")}.join("\n")
+      end      
+    end
+  end
+end