wongi-engine 0.0.1

data/lib/wongi-engine/dsl.rb

@@ -0,0 +1,112 @@
+def ruleset name = nil, &definition
+  rs = Wongi::Engine::Ruleset.new
+  if ! name.nil?
+    rs.name name
+  end
+  rs.instance_eval &definition if block_given?
+  rs
+end
+
+def rule name, &definition
+  r = Wongi::Engine::ProductionRule.new name
+  r.instance_eval &definition
+  r
+end
+
+def query name, &definition
+  q = Wongi::Engine::Query.new name
+  q.instance_eval &definition
+  q
+end
+
+def dsl &definition
+  Wongi::Engine::DSLBuilder.new.build &definition
+end
+
+require 'wongi-engine/dsl/dsl_extensions'
+require 'wongi-engine/dsl/dsl_builder'
+require 'wongi-engine/dsl/action'
+require 'wongi-engine/dsl/generation_clause'
+require 'wongi-engine/dsl/extension_clause'
+require 'wongi-engine/dsl/generic_production_rule'
+require 'wongi-engine/dsl/production_rule'
+require 'wongi-engine/dsl/ncc_production_rule'
+require 'wongi-engine/dsl/any_rule'
+require 'wongi-engine/dsl/query'
+require 'wongi-engine/dsl/actions/simple_action'
+require 'wongi-engine/dsl/actions/statement_generator'
+require 'wongi-engine/dsl/actions/simple_collector'
+require 'wongi-engine/dsl/actions/trace_action'
+require 'wongi-engine/dsl/actions/error_generator'
+
+
+
+dsl {
+
+  section :forall
+
+  clause :has, :fact
+  action Wongi::Engine::Template
+
+  clause :missing, :neg
+  action Wongi::Engine::NegTemplate
+
+  clause :none, :ncc
+  accept Wongi::Engine::NccProductionRule
+
+  clause :any
+  action Wongi::Engine::AnyRule
+
+  clause :maybe, :optional
+  accept Wongi::Engine::OptionalTemplate
+
+  clause :same, :eq, :equal
+  accept Wongi::Engine::EqualityTest
+
+  clause :diff, :ne
+  accept Wongi::Engine::InequalityTest
+
+  clause :asserted, :added
+  body { |s, p, o|
+    missing s, p, o, -1
+    has s, p, o, 0
+  }
+
+  clause :retracted, :removed
+  body { |s, p, o|
+    has s, p, o, -1
+    missing s, p, o, 0
+  }
+
+  clause :kept, :still_has
+  body { |s, p, o|
+    has s, p, o, -1
+    has s, p, o, 0
+  }
+
+  clause :kept_missing, :still_missing
+  body { |s, p, o|
+    missing s, p, o, -1
+    missing s, p, o, 0
+  }
+
+
+  section :make
+
+  clause :gen
+  accept Wongi::Engine::GenerationClause
+
+  clause :trace
+  action Wongi::Engine::TraceAction
+
+  clause :error
+  action Wongi::Engine::ErrorGenerator
+
+  clause :collect
+  action Wongi::Engine::SimpleCollector
+
+  clause :action
+  action Wongi::Engine::SimpleAction
+
+}
+

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

@@ -0,0 +1,12 @@
+module Wongi::Engine
+  class Action
+
+    include CoreExt
+
+    attr_accessor :production
+    attr_accessor :rule
+    attr_accessor :name
+    attr_accessor :rete
+
+  end
+end

data/lib/wongi-engine/dsl/actions/error_generator.rb

@@ -0,0 +1,42 @@
+module Wongi
+  module Engine
+    class ReteError
+
+      attr_reader :token, :message
+      def initialize token, message, literate
+        @token, @message, @literate = token, message, literate
+      end
+      def literate?
+        @literate
+      end
+    end
+
+    class ErrorGenerator < Wongi::Engine::Action
+
+      def initialize message = nil, &messenger
+        @message, @messenger = message, messenger
+      end
+
+      def rete=
+        super
+        rete.add_collector :error, self
+      end
+
+      def errors
+        production.tokens.map do |token|
+          message = if @messenger
+            @messenger.call token.assignments
+          else
+            @message
+          end
+          ReteError.new token, message, literate?
+        end
+      end
+
+      def literate?
+        not @messenger.nil?
+      end
+
+    end
+  end
+end

data/lib/wongi-engine/dsl/actions/simple_action.rb

@@ -0,0 +1,23 @@
+module Wongi::Engine
+
+  class SimpleAction < Action
+
+    def initialize action = nil, *args, &block
+      @action = if action.is_a? Class
+        action.new *args, &block
+      else
+        action || block
+      end
+    end
+
+    def execute token
+      if @action.respond_to? :call
+        @action.call token
+      elsif @action.respond_to? :execute
+        @action.execute token
+      end
+    end
+
+  end
+
+end

data/lib/wongi-engine/dsl/actions/simple_collector.rb

@@ -0,0 +1,51 @@
+module Wongi::Engine
+
+  class SimpleCollector < Action
+
+    def self.collector
+      Class.new self
+    end
+
+    def initialize variable, name = nil
+      @variable = variable
+      @name = name if name
+    #(class << self; self; end).instance_eval do
+        #        define_method method do
+        #          collect variable
+        #        end
+    #    alias_method method, :default_collect
+    #  end
+    end
+
+    def default_collect
+      collect @variable
+    end
+
+    def name= n
+      @name = n unless @name
+    end
+
+    def rete= rete
+      rete.add_collector self, name
+    end
+
+    def collect var
+      production.tokens.map { |token| token[var] }
+    end
+
+  end
+
+  class GenericCollectClause
+
+    def initialize name, variable
+
+    end
+
+    def import_into rete
+      collector = SimpleCollector.new @variable
+
+    end
+
+  end
+
+end

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

@@ -0,0 +1,52 @@
+module Wongi::Engine
+  class StatementGenerator < Action
+
+    def initialize template
+      @template = template
+    end
+
+    def execute token
+
+      subject = if Template.variable?( @template.subject )
+        v = token[ @template.subject ]
+        raise "Unbound variable #{@template.subject} in token #{token}" if v.nil?
+        v
+      else
+        @template.subject
+      end
+
+      predicate = if Template.variable?( @template.predicate )
+        v = token[ @template.predicate ]
+        raise "Unbound variable #{@template.predicate} in token #{token}" if v.nil?
+        v
+      else
+        @template.predicate
+      end
+
+      object = if Template.variable?( @template.object )
+        v = token[ @template.object ]
+        raise "Unbound variable #{@template.object} in token #{token}" if v.nil?
+        v
+      else
+        @template.object
+      end
+
+      wme = WME.new subject, predicate, object
+
+      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
+        added = rete << wme
+        token.generated_wmes << added
+        added.generating_tokens << token
+      end
+
+    end
+
+  end
+end

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

@@ -0,0 +1,52 @@
+module Wongi::Engine
+  class TraceAction < Action
+
+    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

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

@@ -0,0 +1,48 @@
+module Wongi::Engine
+  class AnyRule
+
+    attr_reader :variants
+
+    def initialize &block
+      @variants = []
+      if block
+        instance_eval &block
+      end
+    end
+
+    def variant &block
+      var = VariantRule.new
+      var.instance_eval &block
+      variants << var
+    end
+
+    def import_into rete
+      AnySet.new variants.map { |variant|
+        if variant.respond_to? :import_into
+          variant.import_into(rete)
+        else
+          variant
+        end
+      }
+    end
+
+  end
+
+  class VariantRule < GenericProductionRule
+
+    def initialize name = nil
+      super
+      @current_section = :forall
+    end
+
+    def import_into rete
+      VariantSet.new @acceptors[:forall].map { |condition|
+        if condition.respond_to? :import_into
+          condition.import_into(rete)
+        else
+          condition
+        end
+      }
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Wongi::Engine
+  class DSLBuilder
+
+    def initialize
+      @current_section = nil
+      @current_clause = nil
+      @clauses = []
+    end
+
+    def build &definition
+      instance_eval &definition
+      @clauses.each do |c|
+        DSLExtensions.create_extension c
+      end
+    end
+    
+    def section s
+      @current_section = s
+    end
+    
+    def clause *c
+      @current_clause = c
+    end
+    
+    def action klass = nil, &block
+      raise "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 "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 "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