fabulator 0.0.1

data/lib/fabulator/core/group.rb

@@ -0,0 +1,123 @@
+module Fabulator
+  module Core
+  class Group < Fabulator::Action
+    attr_accessor :name, :params, :tags
+
+    namespace Fabulator::FAB_NS
+
+    has_select
+
+    def initialize
+      @params = [ ]
+      @constraints = [ ]
+      @filters = [ ]
+      @required_params = [ ]
+      @tags = [ ]
+    end
+
+    def compile_xml(xml, context)
+      super
+      xml.each_element do |e|
+        next unless e.namespaces.namespace.href == FAB_NS
+
+        case e.name
+          when 'param':
+            v = Parameter.new.compile_xml(e,@context)
+            @params << v
+            @required_params = @required_params + v.names if v.required?
+          when 'group':
+            v = Group.new.compile_xml(e,@context)
+            @params << v
+            @required_params = @required_params + v.required_params.collect{ |n| (@name + '/' + n).gsub(/\/+/, '/') }
+          when 'constraint':
+            @constraints << Constraint.new.compile_xml(e,@context)
+          when 'filter':
+            @filters << Filter.new.compile_xml(e,@context)
+        end
+      end
+      self
+    end
+
+    def apply_filters(context)
+      filtered = [ ]
+ 
+      @context.with(context) do |ctx|
+
+        self.get_context(ctx).each do |root|
+          @params.each do |param|
+            @filters.each do |f|
+              filtered = filtered + f.apply_filter(ctx.with_root(root))
+            end
+            filtered = filtered + param.apply_filters(ctx.with_root(root))
+          end
+        end
+      end
+      filtered.uniq
+    end
+
+    def apply_constraints(context)
+      res = { :missing => [], :invalid => [], :valid => [], :messages => [] }
+      passed = [ ]
+      failed = [ ]
+      @context.with(context) do |ctx|
+        self.get_context(ctx).each do |root|
+          @params.each do |param|
+            @constraints.each do |c|
+              r = c.test_constraint(ctx.with_root(root))
+              passed += r[0]
+              failed += r[1]
+            end
+            p_res = param.apply_constraints(ctx.with_root(root))
+            res[:messages] += p_res[:messages]
+            failed += p_res[:invalid]
+            passed += p_res[:valid]
+            res[:missing] += p_res[:missing]
+          end
+        end
+      end
+      res[:invalid] = failed.uniq
+      res[:valid] = (passed - failed).uniq
+      res[:messages].uniq!
+      res[:missing] = (res[:missing] - passed).uniq
+      res
+    end
+
+
+    def get_context(context)
+      return [ context.root ] if @select.nil?
+      ret = [ ]
+      context.in_context do |ctx|
+        ret = @select.run(ctx)
+      end
+      ret
+    end
+
+    def test_constraints(context)
+      passed = [ ]
+      failed = [ ]
+      @context.with(context) do |ctx|
+        roots = self.get_context(ctx)
+        roots.each do |root|
+          @params.each do |param|
+            p_ctx = param.get_context(ctx.with_root(root))
+            if !p_ctx.nil? && !p_ctx.empty?
+              p_ctx.each do |p|
+                @constraints.each do |c|
+                  r = c.test_constraint(ctx.with_root(p))
+                  passed += r[0]
+                  failed += r[1]
+                end
+              end
+            end
+          end
+        end
+      end
+      if failed.empty?
+        return [ passed.uniq, [] ]
+      else
+        return [ (passed - failed).uniq, failed ]
+      end
+    end
+  end
+  end
+end

data/lib/fabulator/core/parameter.rb

@@ -0,0 +1,128 @@
+module Fabulator
+  module Core
+  class Parameter < Fabulator::Action
+    attr_accessor :name
+
+    namespace Fabulator::FAB_NS
+
+    attribute :name, :eval => false, :static => true
+    attribute :required, :static => true, :default => 'false'
+
+    def required?
+      @required
+    end
+
+    def param_names
+      [ @name ]
+    end
+
+    def compile_xml(xml, context)
+      super
+
+      @constraints = [ ]
+      @filters = [ ]
+
+      case @required.downcase
+        when 'yes':
+          @required = true
+        when 'true':
+          @required = true
+        when 'no':
+          @required = false
+        when 'false':
+          @required = false
+      end
+
+      xml.each_element do |e|
+        next unless e.namespaces.namespace.href == FAB_NS
+        case e.name
+          when 'constraint':
+            @constraints << Constraint.new.compile_xml(e, @context)
+          when 'filter':
+            @filters << Filter.new.compile_xml(e, @context)
+          when 'value':
+            @constraints << Constraint.new.compile_xml(e, @context)
+        end
+      end
+      self
+    end
+
+    def get_context(context)
+      context = [ context ] unless context.is_a?(Array)
+      context.collect{ |c| c.traverse_path(@name) }.flatten
+    end
+
+    def apply_filters(context)
+      filtered = [ ]
+      @context.with(context) do |ctx|
+        @filters.each do |f|
+          self.get_context(ctx).each do |cc|
+            filtered = filtered + f.run(ctx.with_root(cc))
+          end
+        end
+      end
+      filtered
+    end
+
+    def apply_constraints(context)
+      res = { :missing => [], :invalid => [], :valid => [], :messages => [] }
+      ctx = @context.merge(context)
+      items = self.get_context(ctx)
+      #name = context.attribute(FAB_NS, 'name')
+      if items.empty?
+        if required?
+          res[:missing] = [ (ctx.root.path + '/' + @name).gsub(/\/+/, '/') ]
+        end
+      elsif @constraints.empty? # make sure something exists
+        res[:valid] = items
+      elsif @all_constraints
+        @constraints.each do |c|
+          items.each do |item|
+            r = c.test_constraint(ctx.with_root(i))
+            res[:valid] += r[0]
+            if !r[1].empty?
+              res[:invalid] += r[1]
+              res[:messages] += r[1].collect{ |i| c.error_message(i) }
+            end
+          end
+        end
+      else
+        items.each do |item|
+          passed = @constraints.select {|c| c.test_constraint(ctx.with_root(item))[1].empty? }
+          if passed.empty?
+            res[:invalid] << item
+            res[:messages] += @constraints.collect { |c| c.error_message(item) }
+          else
+            res[:valid] << item
+          end
+        end
+      end
+
+      return res
+    end
+
+    def test_constraints(context)
+      @context.with(context) do |ctx|
+        me = ctx.traverse_path(@name)
+        return [ [ me.collect{ |m| m.path } ], [] ] if @constraints.empty?
+        paths = [ [], [] ]
+        if @all_constraints
+          @constraints.each do |c|
+            p =  c.test_constraints(ctx, me)
+            paths[0] += p[0]
+            paths[1] += p[1]
+          end
+          return [ (paths[0] - paths[1]).uniq, paths[1].uniq ]
+        else
+          @constraints.each do |c|
+            p = c.test_constraints(ctx, me)
+            paths[0] += p[0]
+            paths[1] += p[1]
+          end
+          return [ paths[0].uniq, (paths[1] - paths[0]).uniq ]
+        end
+      end
+    end
+  end
+  end
+end

data/lib/fabulator/core/state.rb

@@ -0,0 +1,91 @@
+module Fabulator
+  module Core
+  class State < Fabulator::Action
+    attr_accessor :name, :transitions
+
+    def initialize
+      @transitions = []
+      @pre_actions = nil
+      @post_actions = nil
+    end
+
+    namespace Fabulator::FAB_NS
+    attribute :name, :static => true
+    
+
+    def compile_xml(xml, ctx)
+      super
+
+      inheriting = !@transitions.empty?
+      xml.each_element do |e|
+        next unless e.namespaces.namespace.href == FAB_NS
+        case e.name
+          when 'goes-to':
+            if inheriting
+              target = e.attributes.get_attribute_ns(FAB_NS, 'view').value
+              tags = (e.attributes.get_attribute_ns(FAB_NS, 'tag').value rescue '').split(/\s+/)
+              old = @transitions.collect{ |t| t.state == target && (tags.empty? || !(tags & t.tags).empty?)}
+              if old.empty?
+                @transitions << Transition.new.compile_xml(e,@context)
+              else
+                old.each do |t|
+                  t.compile_xml(e,@context)
+                end
+              end
+            else 
+              @transitions << Transition.new.compile_xml(e, @context)
+            end
+          when 'before':
+            ActionLib.with_super(@pre_actions) do
+              t = @context.compile_actions(e)
+              @pre_actions = t if @pre_actions.nil? || !t.is_noop?
+            end
+          when 'after':
+            ActionLib.with_super(@post_actions) do
+              t = @context.compile_actions(e)
+              @post_actions = t if @post_actions.nil? || !t.is_noop?
+            end
+        end
+      end
+      self
+    end
+
+    def states
+      @transitions.map { |t| t.state }.uniq
+    end
+
+    def select_transition(context,params)
+      # we need hypthetical variables here :-/
+      best_match = nil
+      @context.with(context) do |ctx|
+        best_match = nil
+        @transitions.each do |t|
+          res = t.validate_params(ctx,params)
+          if res[:missing].empty? && res[:messages].empty? && res[:unknown].empty? && res[:invalid].empty?
+            res[:transition] = t
+          end
+          if best_match.nil? || res[:score] > best_match[:score]
+            best_match = res
+            best_match[:transition] = t
+          end
+        end
+      end
+      return best_match
+    end
+
+    def run_pre(context)
+      # do queries, denials, assertions in the order given
+      ctx = context.class.new(@context, context)
+      @pre_actions.run(ctx) unless @pre_actions.nil?
+      return []
+    end
+
+    def run_post(context)
+      # do queries, denials, assertions in the order given
+      ctx = context.class.new(@context, context)
+      @post_actions.run(ctx) unless @post_actions.nil?
+      return []
+    end
+  end
+  end
+end

data/lib/fabulator/core/state_machine.rb

@@ -0,0 +1,153 @@
+require 'yaml'
+require 'xml/libxml'
+
+module Fabulator
+  FAB_NS='http://dh.tamu.edu/ns/fabulator/1.0#'
+  RDFS_NS = 'http://www.w3.org/2000/01/rdf-schema#'
+  RDF_NS = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#'
+  RDFA_NS = 'http://dh.tamu.edu/ns/fabulator/rdf/1.0#'
+
+  class StateChangeException < Exception
+  end
+
+  module Core
+
+  class StateMachine
+    attr_accessor :states, :missing_params, :errors, :namespaces, :updated_at
+    attr_accessor :state
+
+    def compile_xml(xml, context = nil, callbacks = { })
+      # /statemachine/states
+      @states ||= { }
+      @state = 'start'
+
+      if xml.is_a?(String)
+        xml = LibXML::XML::Document.string xml
+      end
+
+      if context.nil?
+        @context = Fabulator::Expr::Context.new.merge(xml.root)
+      else
+        @context = context.merge(xml.root)
+      end
+
+      ActionLib.with_super(@actions) do
+        p_actions = @context.compile_actions(xml.root)
+        @actions = p_actions if @actions.nil? || !p_actions.is_noop?
+      end
+
+      xml.root.each_element do |child|
+        next unless child.namespaces.namespace.href == FAB_NS
+        case child.name
+          when 'view':
+            nom = (child.attributes.get_attribute_ns(FAB_NS, 'name').value rescue nil)
+            if !@states[nom].nil?
+              @states[nom].compile_xml(child, @context)
+            else
+              @states[nom] = State.new.compile_xml(child, @context)
+            end
+        end
+      end
+
+      if @states.empty?
+        s = State.new
+        s.name = 'start'
+        @states['start'] = s
+      end
+      self
+    end
+
+    def clone
+      YAML::load( YAML::dump( self ) )
+    end
+
+    def namespaces 
+      @context.ns
+    end
+
+    def init_context(c)
+      @context.root = c.root
+      begin
+        @actions.run(@context)
+      rescue Fabulator::StateChangeException => e
+        @state = e
+      end
+    end
+
+    def context
+      { :data => @context.root, :state => @state }
+    end
+
+    def fabulator_context
+      @context
+    end
+
+    def context=(c)
+      if c.is_a?(Fabulator::Expr::Context)
+        @context = c
+      elsif c.is_a?(Fabulator::Expr::Node)
+        @context.root = c
+      elsif c.is_a?(Hash)
+        @context.root = c[:data]
+        @state = c[:state]
+      end
+    end
+
+    def run(params)
+      current_state = @states[@state]
+      return if current_state.nil?
+      # select transition
+      # possible get some errors
+      # run transition, and move to new state as needed
+      @context.in_context do |ctx|
+        self.run_transition(current_state.select_transition(@context, params))
+      end
+    end
+
+    def run_transition(best_transition)
+      return if best_transition.nil? || best_transition.empty?
+      current_state = @states[@state]
+      t = best_transition[:transition]
+      @missing_params = best_transition[:missing]
+      @errors = best_transition[:messages]
+      if @missing_params.empty? && @errors.empty?
+        @state = t.state
+        # merge valid and context
+        best_transition[:valid].sort_by { |a| a.path.length }.each do |item|
+          p = item.path.gsub(/^[^:]+::/, '').split('/') - [ '' ]
+          n = @context.traverse_path(p, true).first
+          n.prune
+          n.copy(item)
+        end
+        # run_post of state we're leaving
+        begin
+          current_state.run_post(@context)
+          t.run(@context)
+          # run_pre for the state we're going to
+          new_state = @states[@state]
+          new_state.run_pre(@context) if !new_state.nil?
+        rescue Fabulator::StateChangeException => e # catch state change
+          new_state = @states[e]
+          begin
+            if !new_state.nil?
+              @state = new_state.name
+              new_state.run_pre(@context)
+            end
+          rescue Fabulator::StateChangeException => e
+            new_state = @states[e] 
+            retry
+          end
+        end
+      end
+    end
+
+    def data
+      @context.root
+    end
+
+    def state_names
+      (@states.keys.map{ |k| @states[k].states }.flatten + @states.keys).uniq
+    end
+  end
+  end
+end