mort666-wongi-engine 0.2.9

data/lib/wongi-engine/dsl/action/statement_generator.rb

@@ -0,0 +1,46 @@
+module Wongi::Engine
+  module DSL::Action
+    class StatementGenerator < Base
+
+      def initialize template
+        @template = template
+      end
+
+      def execute token
+        subject, predicate, object = @template.resolve!(token)
+
+        # link to rete here to ensure proper linking with token
+        wme = WME.new subject, predicate, object, rete
+        wme.manual = false
+        wme.overlay = token.overlay
+
+        production.tracer.trace( action: self, wme: wme ) if production.tracer
+        if existing = rete.exists?( wme )
+          generated = existing.generating_tokens.size
+          if generated > 0 && ! token.generated_wmes.include?( existing )
+            token.generated_wmes << existing
+            existing.generating_tokens << token
+          end
+        else
+          token.generated_wmes << wme
+          wme.generating_tokens << token
+          # this MUST be done after we link the wme and the token
+          # in order for neg rule invalidation to work
+          wme.overlay.assert wme
+        end
+
+      end
+
+      def deexecute token
+        token.generated_wmes.reject( &:manual? ).inject( [] ) do |list, wme|
+          list.tap do |l|
+            wme.generating_tokens.delete token
+            l << wme if wme.generating_tokens.empty?
+          end
+        end.each do |wme|
+          wme.overlay.retract wme, automatic: true
+        end
+      end
+    end
+  end
+end

data/lib/wongi-engine/dsl/action/trace_action.rb

@@ -0,0 +1,49 @@
+module Wongi::Engine
+  module DSL::Action
+    class TraceAction < Base
+
+      class DefaultTracer
+        attr_accessor :action
+        def trace args
+          case args[:action]
+          when TraceAction
+            if args[:token]
+              action.io.puts "EXECUTED RULE #{args[:action].rule.name} WITH #{args[:token]}"
+            else
+              action.io.puts "EXECUTED RULE #{args[:action].rule.name}"
+            end
+          when StatementGenerator
+            action.io.puts "GENERATED #{args[:wme]}" if action.generation?
+          end
+        end
+      end
+
+      attr_reader :io
+      attr_predicate :generation, :values
+
+      def initialize opts = { }
+        [:generation, :values, :tracer, :tracer_class, :io].each do |option|
+          if opts.has_key? option
+            instance_variable_set "@#{option}", opts[option]
+          end
+        end
+        @io ||= $stdout
+        @tracer ||= (@tracer_class || DefaultTracer).new
+        @tracer.action = self
+      end
+
+      def trace args
+        @tracer.trace args
+      end
+
+      def execute token
+        production.tracer = self
+        if values?
+          trace action: self, token: token
+        else
+          trace action: self
+        end
+      end
+    end
+  end
+end

data/lib/wongi-engine/dsl/any_rule.rb

@@ -0,0 +1,33 @@
+module Wongi::Engine
+  module DSL
+    class AnyRule
+
+    attr_reader :variants
+
+    def initialize &block
+      @variants = []
+      if block
+        instance_eval &block
+      end
+    end
+
+    def option &block
+      var = VariantRule.new
+      var.instance_eval &block
+      variants << var
+    end
+
+    def compile context
+      context.tap { |c| c.or_node(variants) }
+    end
+
+  end
+
+    class VariantRule < Rule
+    def initialize name = nil
+      super
+      @current_section = :forall
+    end
+  end
+  end
+end

data/lib/wongi-engine/dsl/assuming.rb

@@ -0,0 +1,31 @@
+module Wongi::Engine
+
+  class UndefinedBaseRule < StandardError
+    def initialize rule_name
+      @rule_name = rule_name
+    end
+
+    def message
+      "undefined production #@rule_name"
+    end
+  end
+
+  class AssumingClause
+
+    attr_reader :base_rule_name
+
+    def initialize base_rule_name
+      @base_rule_name = base_rule_name
+    end
+
+    def compile context
+      base_production = context.rete.productions[base_rule_name]
+      raise UndefinedBaseRule.new(base_rule_name) unless base_production
+      raise DefinitionError.new("'assuming' cannot be preceded by other matchers") unless context.node.root?
+      raise StandardError.new("missing base context") unless base_production.compilation_context
+      base_production.compilation_context.dup
+    end
+
+  end
+
+end

data/lib/wongi-engine/dsl/builder.rb

@@ -0,0 +1,44 @@
+module Wongi::Engine::DSL
+  class Builder
+
+    def initialize
+      @current_section = nil
+      @current_clause = nil
+      @clauses = []
+    end
+
+    def build &definition
+      instance_eval &definition
+      @clauses.each do |c|
+        Generated.create_dsl_method c
+      end
+    end
+    
+    def section s
+      @current_section = s
+    end
+    
+    def clause *c
+      @current_clause = c
+    end
+    
+    def action klass = nil, &block
+      raise DefinitionError, "Cannot create an action without a clause" if @current_clause.nil?
+      @clauses << { section: @current_section, clause: @current_clause, action: klass || block }
+      @current_clause = nil
+    end
+
+    def body klass = nil, &block
+      raise DefinitionError, "Cannot create a body without a clause" if @current_clause.nil?
+      @clauses << { section: @current_section, clause: @current_clause, body: klass || block }
+      @current_clause = nil
+    end
+
+    def accept klass
+      raise DefinitionError, "Cannot create an acceptor without a clause" if @current_clause.nil?
+      @clauses << { section: @current_section, clause: @current_clause, accept: klass }
+      @current_clause = nil
+    end
+
+  end
+end

data/lib/wongi-engine/dsl/clause/assign.rb

@@ -0,0 +1,15 @@
+module Wongi::Engine
+  module DSL::Clause
+    class Assign
+
+      def initialize variable, &body
+        @variable, @body = variable, body
+        raise DefinitionError, "#{variable} is not a variable" unless Template.variable?(variable)
+      end
+
+      def compile context
+        context.tap { |c| c.assignment_node(@variable, @body) }
+      end
+    end
+  end
+end

data/lib/wongi-engine/dsl/clause/fact.rb

@@ -0,0 +1,71 @@
+module Wongi::Engine
+  module DSL::Clause
+    Has = Struct.new(:subject, :predicate, :object, :time) do
+      include CoreExt
+      attr_predicate :debug
+
+      def initialize(s, p, o, options = { })
+        time = options[:time] || 0
+        @unsafe = options[:unsafe] || false
+        debug! if options[:debug]
+        raise "Cannot work with continuous time" unless time.integer?
+        raise "Cannot look into the future" if time > 0
+        super(s, p, o, time)
+      end
+
+      def compile(context)
+        tests, assignment = parse_variables(context)
+        context.tap { |c| c.join_node(self, tests, assignment) }
+      end
+
+      def inspect
+        "<+#{subject.inspect} #{predicate.inspect} #{object.inspect}>"
+      end
+
+      private
+
+      def parse_variables(context)
+        tests = []
+        assignment_mapping = [:subject, :predicate, :object].map do |member|
+          value = send(member)
+          if Template.variable?(value)
+            if context.declares_variable?(value)
+              tests << BetaTest.new(member, value)
+              :_
+            else
+              value
+            end
+          else
+            :_
+          end
+        end
+        assignment = Template.new(*assignment_mapping)
+        assignment.variables.each { |v| context.declare(v) }
+        [tests, assignment]
+      end
+    end
+
+    class Neg < Has
+      attr_reader :unsafe
+      def compile context
+        tests, assignment = parse_variables(context)
+        raise DefinitionError.new("Negative matches may not introduce new variables: #{assignment.variables}") unless assignment.root?
+        context.tap { |c| c.neg_node(self, tests, unsafe) }
+      end
+
+      def inspect
+        "<-#{subject.inspect} #{predicate.inspect} #{object.inspect}>"
+      end
+    end
+
+    class Opt < Has
+      def compile context
+        tests, assignment = parse_variables(context)
+        context.tap { |c| c.opt_node(self, tests, assignment) }
+      end
+      def inspect
+        "<?#{subject.inspect} #{predicate.inspect} #{object.inspect}>"
+      end
+    end
+  end
+end

data/lib/wongi-engine/dsl/clause/gen.rb

@@ -0,0 +1,17 @@
+module Wongi::Engine
+  module DSL::Clause
+    class Gen
+
+      def initialize s, p, o
+        @triple = Template.new( s, p, o )
+      end
+
+      def import_into rete
+        generator = DSL::Action::StatementGenerator.new @triple
+        generator.rete = rete
+        generator
+      end
+
+    end
+  end
+end

data/lib/wongi-engine/dsl/clause/generic.rb

@@ -0,0 +1,38 @@
+module Wongi::Engine
+  module DSL::Clause
+    class Generic
+
+      attr_accessor :name, :action, :rule
+
+      def initialize *args, &block
+        @args = args
+        @block = block
+      end
+
+      def import_into rete
+        if action.respond_to? :call
+          self
+        else
+          action.new( *@args, &@block ).tap do |a|
+            a.name = name if a.respond_to? :name=
+            a.rule = rule if a.respond_to? :rule=
+            a.rete = rete if a.respond_to? :rete=
+          end
+        end
+      rescue StandardError => e
+        e1 = StandardError.new "error defining clause #{name} handled by #{action}: #{e}"
+        e1.set_backtrace e.backtrace
+        raise e1
+      end
+
+      def compile *args
+        action.call *args
+      end
+
+      def execute *args
+        action.call *args
+      end
+
+    end
+  end
+end

data/lib/wongi-engine/dsl/generated.rb

@@ -0,0 +1,43 @@
+module Wongi::Engine::DSL
+  module Generated
+
+    def self.create_dsl_method extension
+
+      section = extension[:section]
+      clause = extension[:clause]
+      action = extension[:action]
+      body = extension[:body]
+      acceptor = extension[:accept]
+
+      define_method clause.first do |*args, &block|
+
+        raise "#{clause.first} can only be invoke in section #{section}, currently in #{@current_section}" if section != @current_section
+
+        if body
+
+          instance_exec *args, &body
+
+        elsif acceptor
+
+          accept acceptor.new( *args, &block )
+
+        elsif action
+
+          c = Clause::Generic.new *args, &block
+          c.name = clause.first
+          c.action = action
+          c.rule = self
+          accept c
+
+        end
+
+      end
+
+      clause[1..-1].each do |al|
+        alias_method al, clause.first
+      end
+
+    end
+
+  end
+end

data/lib/wongi-engine/dsl/ncc_subrule.rb

@@ -0,0 +1,17 @@
+module Wongi::Engine
+  module DSL
+    class NccSubrule < Rule
+
+    def initialize name = nil, &block
+      super
+      if block
+        forall &block
+      end
+    end
+
+    def compile context
+      context.tap { |c| c.ncc_node(self, false) }
+    end
+  end
+  end
+end

data/lib/wongi-engine/dsl/query.rb

@@ -0,0 +1,24 @@
+module Wongi::Engine
+  module DSL
+    class Query < Rule
+
+    def search_on *terms
+      terms.each { |term| parameters << term }
+    end
+
+    def import_into model
+      super.tap { |copy| copy.search_on *parameters }
+    end
+
+    def parameters
+      @parameters ||= []
+    end
+
+    def install( rete )
+      rete.install_query( self )
+    end
+
+  end
+
+  end
+end

data/lib/wongi-engine/dsl/rule.rb

@@ -0,0 +1,84 @@
+module Wongi::Engine
+  module DSL
+    class Rule
+
+    attr_reader :name
+
+      include Generated
+
+    class << self
+
+      def section s, *aliases
+        unless sections.include?(s)
+          sections << s
+          define_method s do |&d|
+            @current_section = s
+            instance_eval &d
+          end
+          aliases.each { |a| alias_method a, s }
+        end
+      end
+      
+      def sections
+        @sections ||= []
+      end
+
+    end
+
+    section :forall, :for_all
+    section :make, :do!
+
+    def initialize name
+      @name = name
+      @current_section = nil
+        Rule.sections.each { |section| acceptors[section] ||= [] }
+    end
+
+    def acceptors
+      @acceptors ||= {}
+    end
+
+    def conditions
+      acceptors[:forall] ||= []
+    end
+
+    def conditions= c
+      acceptors[:forall] = c
+    end
+
+    def actions
+      acceptors[:make] ||= []
+    end
+
+    def actions= a
+      acceptors[:make] = a
+    end
+
+    def import_into rete
+      self.class.new( @name ).tap do |copy|
+        copy.conditions = conditions
+
+        copy.actions = actions.map do |action|
+          if action.respond_to? :import_into
+            action.import_into(rete)
+          else
+            action
+          end
+        end
+      end
+    end
+
+    def install( rete )
+      rete.install_rule( self )
+    end
+
+    protected
+
+    def accept stuff
+      acceptors[@current_section] << stuff
+    end
+
+
+  end
+  end
+end