noteikumi 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 54301cbe45d5868cbfe3335a90a713e0b14d20c8
+  data.tar.gz: 72cd7208a75bd59dc401a627eedfe11d7b81c07b
+SHA512:
+  metadata.gz: 947dd850767a14be17f9fa6c61a22ddd206a107fe5d9d5c4a0dcb47bb887b0d4d4fc8d0ba19b731c9f4a87009ae11d74c84e83c51492785f57b630858415f2c1
+  data.tar.gz: c26d4f9c130b0160172bb446ac12c3e5615243db59e1f574271ad33949d6fa8a36f8f08fa65d81f02ec9d83b2742d60d8fe730d6903698c5f2920abf394fa586

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gem 'rspec', '~> 3.4.0'
+gem 'mocha', '~> 1.1.0'
+gem 'rake', '~> 10.5.0'
+gem 'guard', '~> 2.13.0', :require => false
+gem 'guard-shell',:require => false
+gem 'guard-compat',:require => false
+gem 'rubocop', :require => false
+gem 'yard', :require => false
+gem 'rubygems-tasks', :require => false

data/lib/noteikumi.rb

@@ -0,0 +1,37 @@
+require "logger"
+
+require "noteikumi/engine"
+require "noteikumi/result"
+require "noteikumi/rule"
+require "noteikumi/rule_condition_validator"
+require "noteikumi/rule_execution_scope"
+require "noteikumi/rules"
+require "noteikumi/state"
+require "noteikumi/version"
+
+# A light weight rule engine
+#
+# Visit https://github.com/ripienaar/noteikumi for more information
+class Noteikumi
+  # Helper to create a new rule from a block
+  #
+  # @param rule_name [String,Symbol] unique name for this rule, Symbols preferred
+  # @param blk [Proc] the rule body with access to methods on {Rule}
+  # @return [Rule]
+  def self.rule(rule_name, &blk)
+    rule = Rule.new(rule_name)
+
+    rule.instance_eval(&blk)
+
+    rule
+  end
+
+  # Helper to create a new {Engine}
+  #
+  # @param path [String] a File::PATH_SEPARATOR seperated list of paths to load rules from
+  # @param logger [Logger] a logger to use
+  # @return [Engine]
+  def self.new_engine(path, logger)
+    Engine.new(path, logger)
+  end
+end

data/lib/noteikumi/engine.rb

@@ -0,0 +1,98 @@
+class Noteikumi
+  # The main driver of the rule set
+  #
+  # @example create a engine and process some data
+  #
+  #   engine = Engine.new("rules")
+  #   state = engine.create_state
+  #
+  #   state[:thing] = data_to_process
+  #
+  #   engine.process_state(state)
+  #
+  #   puts "%d rules ran" % [state.results.size]
+  class Engine
+    # The paths this engine consulted for rules
+    #
+    # @return [Array<String>] list of paths
+    attr_reader :path
+
+    # Creates an instance of the rule engine
+    #
+    # @param path [String] a File::PATH_SEPARATOR list of paths to load rules from
+    # @param logger [Logger]
+    # @return [Engine]
+    def initialize(path, logger=Logger.new(STDOUT))
+      @logger = logger
+      @path = parse_path(path)
+
+      rules_collection.load_rules
+    end
+
+    # Parse a File::PATH_SEPARATOR seperated path into expanded directories
+    #
+    # @api private
+    # @param path [String] The path to parse, should be a File::PATH_SEPARATOR list of paths
+    # @return [Array<String>]
+    def parse_path(path)
+      path.split(File::PATH_SEPARATOR).map do |part|
+        File.expand_path(part)
+      end
+    end
+
+    # Reset the run count on all loaded rules
+    #
+    # @api private
+    # @return [void]
+    def reset_rule_counts
+      rules_collection.rules.each(&:reset_counter)
+    end
+
+    # Given a state object process all the loaded rules
+    #
+    # @note the rule set is processed once only
+    # @param state [State]
+    # @return [Array<Result>]
+    def process_state(state)
+      raise("No rules have been loaded into engine %s" % self) if rules_collection.empty?
+
+      reset_rule_counts
+
+      rules_collection.by_priority.each do |rule|
+        state.process_rule(rule)
+      end
+
+      state.results
+    end
+
+    # Creates a new state that has an associated with this {Engine}
+    #
+    # @return [State]
+    def create_state
+      State.new(self, @logger)
+    end
+
+    # Iterates all the rules in the {Rules} collection
+    #
+    # @yieldparam rule [Rule]
+    # @return [void]
+    def each_rule
+      rules_collection.rules.each do |rule|
+        yield(rule)
+      end
+    end
+
+    # Creates and caches a rules collection
+    #
+    # @return [Rules]
+    def rules_collection
+      @rules ||= Rules.new(@path, @logger)
+    end
+
+    # :nodoc:
+    # @return [String]
+    def inspect
+      "#<%s:%s %d rules from %s>" % [self.class, object_id, rules_collection.count, @path.inspect]
+    end
+  end
+end

data/lib/noteikumi/result.rb

@@ -0,0 +1,88 @@
+class Noteikumi
+  # Represents the result of running a specific rule
+  class Result
+    # The time it took for the rule to be processed
+    # @return [Float]
+    attr_reader :run_time
+
+    # The time the rule started
+    # @return [Time,nil]
+    attr_reader :start_time
+
+    # The time the rule ended
+    # @return [Time,nil]
+    attr_reader :end_time
+
+    # Any output produced by the rule
+    attr_reader :output
+
+    # The rule the result relates to
+    # @return [Rule,nil]
+    attr_reader :rule
+
+    # The exception a rule raised
+    # @return [Exception,nil]
+    attr_accessor :exception
+
+    # Any output returned from the rule run block
+    # @return [Object,nil]
+    attr_accessor :output
+
+    # Creates a result for a rule
+    #
+    # @param rule [Rule]
+    # @return [Result]
+    def initialize(rule)
+      @rule = rule
+      @start_time = nil
+      @end_time = nil
+      @run_time = nil
+      @exception = nil
+      @output = nil
+      @ran = false
+    end
+
+    # The rule name
+    #
+    # @return [String,Symbol]
+    def name
+      @rule.name
+    end
+
+    # If the result has an exception
+    #
+    # @return [Boolean]
+    def error?
+      !!exception
+    end
+
+    # Determines if this rule ran
+    #
+    # @return [Boolean]
+    def ran?
+      @ran
+    end
+
+    # Records the start time for the rule process
+    #
+    # @return [Time]
+    def start_processing
+      @ran = true
+      @start_time = Time.now
+    end
+
+    # Records that processing have ended
+    #
+    # @return [Time]
+    def stop_processing
+      @end_time = Time.now
+      @run_time = @end_time - @start_time
+    end
+
+    # :nodoc:
+    # @return [String]
+    def inspect
+      "#<%s:%s rule: %s ran: %s error: %s>" % [self.class, object_id, name, ran?, error?]
+    end
+  end
+end

data/lib/noteikumi/rule.rb

@@ -0,0 +1,310 @@
+class Noteikumi
+  # A class that represents an individual rule used by the engine
+  #
+  # Rules are generally stored in files named something_rule.rb in a rule
+  # directory, there are several samples of these in the examples dir
+  # and in docs on the wiki at GitHub
+  class Rule
+    # The priority for this fule
+    # @return [Fixnum]
+    attr_reader :priority
+
+    # The state this rule is being evaluated against
+    # @api private
+    # @return [State,nil]
+    attr_reader :state
+
+    # Named conditions for this rule
+    # @api private
+    # @see {condition}
+    # @return [Hash]
+    attr_reader :conditions
+
+    # Items the rule expect on the state
+    # @api private
+    # @see {requirement}
+    # @return [Array]
+    attr_reader :needs
+
+    # The concurrency safe level
+    # @api private
+    # @see {concurrency=}
+    # @return [:safe, :unsafe]
+    attr_reader :concurrent
+
+    # The run conditions for this rule
+    # @api private
+    # @see {run_when}
+    # @return [Proc]
+    attr_reader :run_condition
+
+    # The logic to run
+    # @api private
+    # @see {run}
+    # @return [Proc]
+    attr_reader :run_logic
+
+    # How many times this rule have been run
+    # @api private
+    # @return [Fixnum]
+    attr_reader :run_count
+
+    # The file the rule was found in
+    # @api private
+    # @return [String]
+    attr_accessor :file
+
+    # The rule name
+    # @api private
+    # @return [String,Symbol]
+    attr_accessor :name
+
+    # The logger used by this rule
+    # @api private
+    # @return [Logger]
+    attr_accessor :logger
+
+    # Creates a new rule
+    #
+    # @param name [String,Symbol] the name of the rule
+    # @return [Rule]
+    def initialize(name)
+      @name = name
+      @priority = 500
+      @concurrent = :unsafe
+      @needs = []
+      @conditions = {}
+      @state = nil
+      @file = "unknown file"
+      @run_count = 0
+
+      run_when { true }
+      run { raise("No execution logic provided for rule") }
+    end
+
+    # Checks if a condition matching the name has been created on the rule
+    #
+    # @see {#condition}
+    # @param condition [Symbol] condition name
+    # @return [Boolean]
+    def has_condition?(condition)
+      @conditions.include?(condition)
+    end
+
+    # Assign the provided state to the rule
+    #
+    # @param state [State] the state to store
+    # @return [void]
+    def assign_state(state)
+      @state = state
+    end
+
+    # Resets the state to nil state
+    #
+    # @return [void]
+    def reset_state
+      @state = nil
+    end
+
+    # Resets the run count for the rule to 0
+    #
+    # @return [void]
+    def reset_counter
+      @run_count = 0
+    end
+
+    # Assigns the state, yields to the block and resets it
+    #
+    # @param state [State] a state to act on
+    # @return [Object] the outcome from the block
+    def with_state(state)
+      assign_state(state)
+
+      yield
+    ensure
+      reset_state
+    end
+
+    # Runs the rule logic
+    #
+    # Rules are run within an instance of {RuleExecutionScope}
+    #
+    # @return [Result]
+    def run_rule_logic
+      @run_count += 1
+
+      result = new_result
+
+      begin
+        result.start_processing
+        result.output = RuleExecutionScope.new(self).run
+      rescue => e
+        logger.error("Error during processing of rule: %s: %s: %s" % [self, e.class, e.to_s])
+        logger.debug(e.backtrace.join("\n\t"))
+        result.exception = e
+      ensure
+        result.stop_processing
+      end
+
+      result
+    end
+
+    # Construct a result object for this rule
+    #
+    # @return [Result]
+    def new_result
+      Result.new(self)
+    end
+
+    # Process a rule after first checking all the requirements are met
+    #
+    # @param state [State] the state to use as scope
+    # @return [Result,nil] nil when the rule never ran due to state checks
+    def process(state)
+      result = nil
+
+      with_state(state) do
+        if state_meets_requirements?
+          if satisfies_run_condition?
+            logger.debug("Processing rule %s" % self)
+            result = run_rule_logic
+          else
+            logger.debug("Skipping processing rule due to run_when block returning false on %s" % self)
+          end
+        else
+          logger.debug("Skipping processing rule %s due to state check failing" % self)
+        end
+      end
+
+      result
+    end
+
+    # Determines if the run_when block is satisfied
+    #
+    # @return [Boolean]
+    def satisfies_run_condition?
+      validator = RuleConditionValidator.new(self)
+      validator.__should_run?
+    end
+
+    # Checks every requirement against the state
+    #
+    # @return [Boolean]
+    def state_meets_requirements?
+      @needs.each do |requirement|
+        valid, reason = state.meets_requirement?(requirement)
+
+        unless valid
+          logger.debug("State does not meet the requirements %s: %s" % [self, reason])
+          return false
+        end
+      end
+
+      true
+    end
+
+    # :nodoc:
+    # @return [String]
+    def to_s
+      "#<%s:%s run_count: %d priority: %d name: %s @ %s>" % [self.class, object_id, run_count, priority, name, file]
+    end
+
+    # Logic to execute once state has met to determine if the rule should be run
+    #
+    # @see #condition for an example
+    # @param blk [Proc] the checking logic that should return boolean
+    # @return [void]
+    def run_when(&blk)
+      raise("A block is needed to evaluate for run_when") unless block_given?
+      @run_condition = blk
+    end
+
+    # Creates the logic that will be run when all the conditions are met
+    #
+    # @see #requirement
+    # @see #condition
+    # @see #run_when
+    # @param blk [Proc] the logic to run
+    # @return [void]
+    def run(&blk)
+      raise("A block is needed to run") unless block_given?
+      @run_logic = blk
+    end
+
+    # Sets the rule priority
+    #
+    # @param priority [Fixnum]
+    # @return [Fixnum]
+    def rule_priority(priority)
+      @priority = Integer(priority)
+    end
+
+    # Sets the concurrency safe level
+    #
+    # This is mainly not used now but will result in the state becoming immutable
+    # when the level is :safe.  This is with an eye on supporting parallel or threaded
+    # execution of rules in the long term
+    #
+    # @param level [:safe, :unsafe]
+    # @return [:safe, :unsafe]
+    def concurrency=(level)
+      raise("Concurrency has to be one of :safe, :unsafe") unless [:safe, :unsafe].include?(level)
+
+      @concurrent = level
+    end
+
+    # Determines if the concurrency level is :safe
+    #
+    # @return [Boolean]
+    def concurrent_safe?
+      @concurrent == :safe
+    end
+
+    # Creates a named condition
+    #
+    # @example create and use a condition
+    #
+    #  condition(:weekend?) { Time.now.wday > 5 }
+    #  condition(:daytime?) { Time.now.hour.between?(9, 18) }
+    #
+    #  run_when { weekend? || !daytime? }
+    #
+    # @note these blocks must always return boolean and will be coerced to that
+    # @param name [Symbol] a unique name for this condition
+    # @param blk [Proc] the code to run when this condition is called
+    # @return [void]
+    def condition(name, &blk)
+      raise("Duplicate condition name %s" % name) if @conditions[name]
+      raise("A block is required for condition %s" % name) unless block_given?
+
+      @conditions[name] = blk
+
+      nil
+    end
+
+    # Sets a requirement that the state should meet
+    #
+    # @example require any scope item with a specific type
+    #
+    #    requirement nil, String
+    #
+    # @example require that a specific item should be of a type
+    #
+    #    requirement :thing, String
+    #
+    # @param args [Array] of requirements
+    # @return [void]
+    def requirement(*args)
+      case args.size
+      when 1
+        @needs << [nil, args[0]]
+      when 2
+        @needs << args
+      else
+        raise("Unsupported requirement input %s" % args.inspect)
+      end
+    end
+
+    nil
+  end
+end

data/lib/noteikumi/rule_condition_validator.rb

@@ -0,0 +1,85 @@
+class Noteikumi
+  # This is a class used by {Rule#satisfies_run_condition?} to create a
+  # clean room to evaluate the state conditions in and provides helpers
+  # to expose named conditions as methods for use by {Rule#run_when}
+  #
+  # @api private
+  class RuleConditionValidator
+    # Creates a new validator
+    #
+    # @param rule [Rule]
+    # @return [RuleConditionValidator]
+    def initialize(rule)
+      @__rule = rule
+    end
+
+    # Checks if this is the first time the rule is being ran
+    #
+    # @return [Boolean]
+    def first_run?
+      @__rule.run_count == 0
+    end
+
+    # Checks if the state had any past failures
+    #
+    # @return [Boolean]
+    def state_had_failures?
+      @__rule.state.had_failures?
+    end
+
+    # Checks if a rule with a specific name acted on the state
+    #
+    # @param rule [Symbol,Rule]
+    # @return [Boolean]
+    def state_processed_by?(rule)
+      @__rule.state.processed_by?(rule)
+    end
+
+    # Runs the rules run condition
+    #
+    # @return [Boolean]
+    def __should_run?
+      instance_eval(&@__rule.run_condition)
+    end
+
+    # Determines if the rule has a condition by name
+    #
+    # @param condition [Symbol] the condition name
+    # @return [Boolean]
+    def __known_condition?(condition)
+      @__rule.has_condition?(condition)
+    end
+
+    # Retrieves a named condition from the rule
+    #
+    # @param condition [Symbol] the condition name
+    # @return [Proc,nil]
+    def __condition(condition)
+      @__rule.conditions[condition]
+    end
+
+    # Evaluate a named condition
+    #
+    # @param condition [Symbol] the condition name
+    # @param args [Array<Object>] arguments to pass to the condition
+    # @return [Boolean]
+    def __evaluate_condition(condition, *args)
+      result = !!__condition(condition).call(*args)
+      @__rule.logger.debug("Condition %s returned %s on %s" % [condition, result.inspect, @__rule])
+      result
+    end
+
+    # Provide method access to named based conditions
+    #
+    # @see {__evaluate_condition}
+    # @return [Boolean]
+    # @raise [NoMethodError] for unknown conditions
+    def method_missing(method, *args, &blk)
+      if __known_condition?(method)
+        __evaluate_condition(method, *args)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/noteikumi/rule_execution_scope.rb

@@ -0,0 +1,34 @@
+class Noteikumi
+  # A class that exist to execute the logic of the rule
+  # @api private
+  class RuleExecutionScope
+    # The rule being ran
+    # @return [Rule]
+    attr_reader :rule
+
+    # The state the rule is processing
+    # @return [State]
+    attr_reader :state
+
+    # The active logger
+    # @return [Logger]
+    attr_reader :logger
+
+    # Creates a new scope object
+    #
+    # @param rule [Rule]
+    # @return [RuleExecutionScope
+    def initialize(rule)
+      @rule = rule
+      @state = rule.state
+      @logger = rule.logger
+    end
+
+    # Runs the rule logic within this scope
+    #
+    # @return [Object] the output from the rule
+    def run
+      @rule.run_logic.call
+    end
+  end
+end

data/lib/noteikumi/rules.rb

@@ -0,0 +1,121 @@
+class Noteikumi
+  # A collection of rules with various methods to load and find rules
+  class Rules
+    # The loaded rules
+    # @return [Array<Rule>]
+    attr_reader :rules
+
+    # The logger
+    # @api private
+    # @return [Logger]
+    attr_reader :logger
+
+    # Creates a rule collection
+    #
+    # @param rules_dir [Array<String>,String] a directory or list of directories to look for rules in
+    # @param logger [Logger] a logger to use
+    # @return Rules
+    def initialize(rules_dir, logger)
+      @rules = []
+      @logger = logger
+      @rules_dir = Array(rules_dir)
+    end
+
+    # Use a block to select rules out of the overall set
+    #
+    # @param blk [Proc] logic to use when selecting rules
+    # @return [Array<Rule>]
+    def select(&blk)
+      @rules.select(&blk)
+    end
+
+    # Return the rule ordered by priority
+    #
+    # @return [Array<Rule>]
+    def by_priority
+      @rules.sort_by(&:priority)
+    end
+
+    # The amont of rules loaded
+    #
+    # @return [Fixnum]
+    def size
+      @rules.size
+    end
+    alias_method :count, :size
+
+    # Determines if any rules are loaded
+    #
+    # @return [Boolean]
+    def empty?
+      @rules.empty?
+    end
+
+    # Append a rule to the collection
+    #
+    # @param rule [Rule]
+    # @return [Rule]
+    def <<(rule)
+      @rules << rule
+    end
+
+    # Get the names of all the rules
+    #
+    # @return [Array<String,Symbol>]
+    def rule_names
+      @rules.map(&:name)
+    end
+
+    # Load a rule from a file
+    #
+    # @param file [String] the file to load the rule from
+    # @return [Rule]
+    def load_rule(file)
+      raise("The rule %s is not readable" % file) unless File.readable?(file)
+
+      body = File.read(file)
+
+      clean = Object.new
+      rule = clean.instance_eval(body, file, 1)
+
+      rule.file = file
+      rule.logger = @logger
+
+      logger.debug("Loaded rule %s from %s" % [rule.name, file])
+
+      rule
+    end
+
+    # Load all the rules  from the configured paths
+    #
+    # @return [void]
+    def load_rules
+      @rules_dir.each do |directory|
+        find_rules(directory).each do |rule|
+          rule = load_rule(File.join(directory, rule))
+
+          if rule_names.include?(rule.name)
+            raise("Already have a rule called %s, cannot load another" % rule.name)
+          end
+
+          self << rule
+        end
+      end
+    end
+
+    # Find all rules in a given directory
+    #
+    # Valid rules have names ending in _\_rule.rb_
+    #
+    # @param directory [String] the directory to look in
+    # @return [Array<String>] list of rule names
+    def find_rules(directory)
+      if File.directory?(directory)
+        Dir.entries(directory).grep(/_rule.rb$/)
+      else
+        @logger.debug("Could not find directory %s while looking for rules" % directory)
+        []
+      end
+    end
+  end
+end

data/lib/noteikumi/state.rb

@@ -0,0 +1,233 @@
+class Noteikumi
+  # The state a rule will process, this is not a state machine
+  # but rather can be thought of like a scope
+  class State
+    # The list of result obtained from each rule
+    # @return [Array<Result>]
+    attr_reader :results
+
+    # A list of rules that acted on this state
+    # @return [Array<Rule>]
+    attr_reader :processed_by
+
+    # The engine this state is associated with
+    # @api private
+    # @return [Engine]
+    attr_reader :engine
+
+    # The logger used
+    # @api private
+    # @return [Logger]
+    attr_reader :logger
+
+    # Set the state mutable or not
+    # @return [Boolean]
+    attr_writer :mutable
+
+    # Creates a new state
+    #
+    # @param engine [Engine]
+    # @param logger [Logger]
+    # @return [State]
+    def initialize(engine, logger)
+      @items = {}
+      @results = []
+      @processed_by = []
+      @engine = engine
+      @logger = logger
+      @mutable = true
+    end
+
+    # Allow the state to be modified
+    #
+    # @return [void]
+    def allow_mutation
+      @mutable = true
+    end
+
+    # Prevent the state from being modified
+    #
+    # @return [void]
+    def prevent_mutation
+      @mutable = false
+    end
+
+    # Process a rule with the state
+    #
+    # @return [Result, nil] nil when the rule did not run
+    def process_rule(rule)
+      rule.concurrent_safe? ? prevent_mutation : allow_mutation
+
+      result = rule.process(self)
+
+      allow_mutation
+
+      record_rule(rule, result)
+    end
+
+    # Yields each recorded result
+    #
+    # @yieldparam result [Result] for every rule that ran
+    # @return [void]
+    def each_result
+      @results.each do |result|
+        yield(result)
+      end
+    end
+
+    # Adds a result to the list of results
+    #
+    # @param result [Result]
+    # @return [Result]
+    def add_result(result)
+      @results << result if result
+    end
+
+    # Checks all results for failures
+    #
+    # @return [Boolean] true when there were failures
+    def had_failures?
+      @results.map(&:error?).include?(true)
+    end
+
+    # Determines if a rule with a specific name acted on this state
+    #
+    # @param rule [Rule,Symbol] the rule name or a rule
+    # @return [Boolean]
+    def processed_by?(rule)
+      if rule.is_a?(Rule)
+        @processed_by.include?(rule)
+      else
+        @processed_by.map(&:name).include?(rule)
+      end
+    end
+
+    # Selects any item that has a certain ruby class type
+    #
+    # @param type [Class] the type to search for
+    # @return [Hash] items found
+    def items_by_type(type)
+      @items.select {|_, v| v.is_a?(type)} || []
+    end
+
+    # Checks if a given requirement is matched by this state
+    #
+    # @example
+    #
+    #   state[:one] = "hello world"
+    #
+    #   state.meets_requirements?(:one, String) => [true, "reason"]
+    #   state.meets_requirements?(nil, String) => [true, "reason"]
+    #   state.meets_requirements?(nil, Fixnum) => [false, "State has no items of class Fixnum"]
+    #   state.meets_requirements?(:one, Fixnum) => [false, "State item :one is not a Fixnum"]
+    #   state.meets_requirements?(:not_set, Fixnum) => [false, "State has no item not_set"]
+    #
+    # @param requirement [Array<key,type>]
+    # @return [Array<Boolean,String>]
+    def meets_requirement?(requirement)
+      key, klass = requirement
+
+      if key
+        return([false, "State has no item %s" % key]) unless include?(key)
+
+        unless self[key].is_a?(klass)
+          return [false, "State item %s is not a %s" % [key, klass]]
+        end
+      end
+
+      unless has_item_of_type?(klass)
+        return [false, "State has no items of class %s" % klass]
+      end
+
+      [true, "Valid state found"]
+    end
+
+    # Determines if any item in the State has a certain type
+    #
+    # @param type [Class] a ruby class to look for
+    # @return [Boolean]
+    def has_item_of_type?(type)
+      !items_by_type(type).empty?
+    end
+
+    # Determines if the state can be mutated
+    def mutable?
+      !!@mutable
+    end
+
+    # Records a rule having acted on this state
+    #
+    # If the result is not nil the actor will be record
+    # and the result stored, else it's a noop
+    #
+    # @param rule [Rule]
+    # @param result [Result]
+    # @return [void]
+    def record_rule(rule, result)
+      if result
+        @processed_by << rule
+        @results << result
+      end
+
+      result
+    end
+
+    # Checks if a item is in the state
+    #
+    # @param item [Symbol] item name
+    # @return [Boolean]
+    def include?(item)
+      @items.include?(item)
+    end
+    alias_method :has?, :include?
+
+    # sets the value of an item without checking if it's already set
+    #
+    # @param item [Symbol] the name of the item being stored
+    # @param value [Object] the item to store
+    # @return [Object] the item being stored
+    # @raise [StandardError] when the state is not mutable
+    def set(item, value)
+      raise("State is not mustable") unless mutable?
+
+      @items[item] = value
+    end
+    alias_method :[]=, :set
+
+    # Deletes an item
+    #
+    # @param item [Symbol] item to delete
+    # @raise [StandardError] when the state is not mutable
+    def delete(item)
+      raise("State is not mustable") unless mutable?
+
+      @items.delete(item)
+    end
+
+    # Adds an item
+    #
+    # See {#set} for a version of this that does not error if the
+    # item is already on the state
+    #
+    # @param item [Symbol] item to delete
+    # @param value [Object] item to store
+    # @return [Object] the value set
+    # @raise [StandardError] when the state is not mutable
+    # @raise [StandardError] when the item is already in the state
+    def add(item, value)
+      raise("State is not mustable") unless mutable?
+      raise("Already have item %s" % item) if has?(item)
+
+      set(item, value)
+    end
+
+    # Retrieves a item from the state
+    #
+    # @param item [Symbol] the item name
+    # @return [Object,nil] the value stored
+    def get(item)
+      @items[item]
+    end
+    alias_method :[], :get
+  end
+end

data/lib/noteikumi/version.rb

@@ -0,0 +1,3 @@
+class Noteikumi
+  VERSION = "0.0.1".freeze
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: noteikumi
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- R.I.Pienaar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-09 00:00:00.000000000 Z
+dependencies: []
+description: 'description: Light weight Rule Engine'
+email: rip@devco.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/noteikumi.rb
+- lib/noteikumi/rules.rb
+- lib/noteikumi/engine.rb
+- lib/noteikumi/rule_condition_validator.rb
+- lib/noteikumi/rule_execution_scope.rb
+- lib/noteikumi/result.rb
+- lib/noteikumi/state.rb
+- lib/noteikumi/version.rb
+- lib/noteikumi/rule.rb
+- Gemfile
+homepage: http://devco.net/
+licenses:
+- Apache-2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: noteikumi
+test_files: []