wongi-engine 0.3.5 → 0.3.7

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

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

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

@@ -1,31 +1,24 @@
 module Wongi::Engine
-
   class UndefinedBaseRule < StandardError
-    def initialize rule_name
-      @rule_name = rule_name
-    end
-
-    def message
-      "undefined production #@rule_name"
+    def initialize(rule_name)
+      super("undefined production #{rule_name}")
     end
   end
 
   class AssumingClause
-
     attr_reader :base_rule_name
 
-    def initialize base_rule_name
+    def initialize(base_rule_name)
       @base_rule_name = base_rule_name
     end
 
-    def compile context
+    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
+      raise UndefinedBaseRule, base_rule_name unless base_production
+      raise DefinitionError, "'assuming' cannot be preceded by other matchers" unless context.node.root?
+      raise StandardError, "missing base context" unless base_production.compilation_context
+
       base_production.compilation_context.dup
     end
-
   end
-
 end

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

@@ -1,14 +1,13 @@
 module Wongi::Engine::DSL
   class Builder
-
     def initialize
       @current_section = nil
       @current_clause = nil
       @clauses = []
     end
 
-    def build &definition
-      instance_eval &definition
+    def build(&definition)
+      instance_eval(&definition)
       @clauses.each do |c|
         Wongi::Engine::DSL.sections[c[:section]] ||= Class.new do
           include Generated
@@ -16,32 +15,34 @@ module Wongi::Engine::DSL
         Wongi::Engine::DSL.sections[c[:section]].create_dsl_method(c)
       end
     end
-    
-    def section s
+
+    def section(s)
       @current_section = s
     end
-    
-    def clause *c
+
+    def clause(*c)
       @current_clause = c
     end
-    
-    def action klass = nil, &block
+
+    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
+    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
+    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/aggregate.rb

@@ -0,0 +1,21 @@
+module Wongi::Engine
+  module DSL::Clause
+    class Aggregate < Has
+      attr_reader :map, :function, :assign
+
+      def initialize(s, p, o, options = {})
+        member = options[:on]
+        @map = options[:map]
+        @function = options[:function]
+        @assign = options[:assign]
+        @map ||= -> { _1.send(member) }
+        super
+      end
+
+      def compile(context)
+        tests, assignment = parse_variables(context)
+        context.tap { |c| c.aggregate_node(self, tests, assignment, map, function, assign) }
+      end
+    end
+  end
+end

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

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

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

@@ -4,12 +4,13 @@ module Wongi::Engine
       include CoreExt
       attr_predicate :debug
 
-      def initialize(s, p, o, options = { })
+      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
+        raise "Cannot look into the future" if time.positive?
+
         super(s, p, o, time)
       end
 
@@ -26,7 +27,7 @@ module Wongi::Engine
 
       def parse_variables(context)
         tests = []
-        assignment_mapping = [:subject, :predicate, :object].map do |member|
+        assignment_mapping = %i[subject predicate object].map do |member|
           value = send(member)
           if Template.variable?(value)
             if context.declares_variable?(value)
@@ -47,9 +48,11 @@ module Wongi::Engine
 
     class Neg < Has
       attr_reader :unsafe
-      def compile context
+
+      def compile(context)
         tests, assignment = parse_variables(context)
-        raise DefinitionError.new("Negative matches may not introduce new variables: #{assignment.variables}") unless assignment.root?
+        raise DefinitionError, "Negative matches may not introduce new variables: #{assignment.variables}" unless assignment.root?
+
         context.tap { |c| c.neg_node(self, tests, unsafe) }
       end
 
@@ -59,10 +62,11 @@ module Wongi::Engine
     end
 
     class Opt < Has
-      def compile context
+      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

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

@@ -1,17 +1,15 @@
 module Wongi::Engine
   module DSL::Clause
     class Gen
-
-      def initialize s, p, o
-        @triple = Template.new( s, p, o )
+      def initialize(s, p, o)
+        @triple = Template.new(s, p, o)
       end
 
-      def import_into rete
+      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

@@ -1,19 +1,18 @@
 module Wongi::Engine
   module DSL::Clause
     class Generic
-
       attr_accessor :name, :action, :rule
 
-      def initialize *args, &block
+      def initialize(*args, &block)
         @args = args
         @block = block
       end
 
-      def import_into rete
+      def import_into(rete)
         if action.respond_to? :call
           self
         else
-          action.new( *@args, &@block ).tap do |a|
+          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=
@@ -25,14 +24,13 @@ module Wongi::Engine
         raise e1
       end
 
-      def compile *args
-        action.call *args
+      def compile(*args)
+        action.call(*args)
       end
 
-      def execute *args
-        action.call *args
+      def execute(*args)
+        action.call(*args)
       end
-
     end
   end
 end

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

@@ -1,40 +1,35 @@
 module Wongi::Engine::DSL
   module Generated
-
     module ClassMethods
-      def create_dsl_method extension
-
+      def create_dsl_method(extension)
         clause = extension[:clause]
         action = extension[:action]
         body = extension[:body]
         acceptor = extension[:accept]
 
         define_method clause.first do |*args, &block|
-
           if body
 
-            instance_exec *args, &body
+            instance_exec(*args, &body)
 
           elsif acceptor
 
-            rule.accept acceptor.new( *args, &block )
+            rule.accept acceptor.new(*args, &block)
 
           elsif action
 
-            c = Clause::Generic.new *args, &block
+            c = Clause::Generic.new(*args, &block)
             c.name = clause.first
             c.action = action
-            c.rule = self.rule
+            c.rule = rule
             rule.accept c
 
           end
-
         end
 
-        clause[1..-1].each do |al|
+        clause[1..].each do |al|
           alias_method al, clause.first
         end
-
       end
     end
 
@@ -43,6 +38,5 @@ module Wongi::Engine::DSL
     def self.included(base)
       base.extend ClassMethods
     end
-
   end
 end

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

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

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

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

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

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

data/lib/wongi-engine/dsl.rb

@@ -1,43 +1,39 @@
 module Wongi::Engine
   module DSL
-    extend self
-
-    def sections
+    module_function def sections
       @sections ||= {}
     end
 
-    def ruleset name = nil, &definition
+    module_function def ruleset(name = nil, &definition)
       rs = Ruleset.new
-      if ! name.nil?
-        rs.name name
-      end
-      rs.instance_eval &definition if block_given?
+      rs.name name if name
+      rs.instance_eval(&definition) if block_given?
       rs
     end
 
-    def rule name = nil, &definition
+    module_function def rule(name = nil, &definition)
       r = Rule.new name
-      r.instance_eval &definition
+      r.instance_eval(&definition)
       r
     end
 
-    def query name, &definition
+    module_function def query(name, &definition)
       q = Query.new name
-      q.instance_eval &definition
+      q.instance_eval(&definition)
       q
     end
 
-    def dsl &definition
-      Builder.new.build &definition
+    module_function def dsl(&definition)
+      Builder.new.build(&definition)
     end
   end
-
 end
 
 require 'wongi-engine/dsl/generated'
 require 'wongi-engine/dsl/builder'
 require 'wongi-engine/dsl/clause/generic'
 require 'wongi-engine/dsl/clause/fact'
+require 'wongi-engine/dsl/clause/aggregate'
 require 'wongi-engine/dsl/clause/assign'
 require 'wongi-engine/dsl/clause/gen'
 require 'wongi-engine/dsl/action/base'
@@ -90,10 +86,28 @@ module Wongi::Engine::DSL
     clause :gte
     accept Wongi::Engine::GreaterThanOrEqualTest
 
+    clause :aggregate
+    accept Clause::Aggregate
+
+    clause :least, :min
+    body { |s, p, o, opts|
+      aggregate s, p, o, on: opts[:on], function: :min, assign: opts[:assign]
+    }
+
+    clause :greatest, :max
+    body { |s, p, o, opts|
+      aggregate s, p, o, on: opts[:on], function: :max, assign: opts[:assign]
+    }
+
+    clause :count
+    body { |s, p, o, opts|
+      aggregate s, p, o, map: ->(_) { 1 }, function: -> { _1.inject(&:+) }, assign: opts[:assign]
+    }
+
     clause :assert, :dynamic
     accept Wongi::Engine::AssertingTest
 
-    clause :assign, :introduce
+    clause :assign, :introduce, :let
     accept Clause::Assign
 
     clause :asserted, :added

data/lib/wongi-engine/enumerators.rb

@@ -8,13 +8,14 @@ module Wongi::Engine
       end
     end
   end
+
   class DeleteSafeEnumerator
     def self.new(collection)
       Enumerator.new do |y|
         collection.dup.each do |e|
           y << e unless e.deleted?
         end
-        collection.reject! &:deleted?
+        collection.reject!(&:deleted?)
       end
     end
   end

data/lib/wongi-engine/error.rb

@@ -1,22 +1,21 @@
 module Wongi::Engine
-
   class Error < StandardError
-
   end
 
   class DefinitionError < Error
-
   end
 
   class ReteError
     attr_reader :token, :message
-    def initialize token, message, literate
-      @token, @message, @literate = token, message, literate
+
+    def initialize(token, message, literate)
+      @token = token
+      @message = message
+      @literate = literate
     end
+
     def literate?
       @literate
     end
   end
-
-
 end