ruy 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 003d024c6b2f05a3c015ccbd789efd59552fc7a7
-  data.tar.gz: 411c3711fe45f4abdb16e92618cd7bc120dd17b8
+  metadata.gz: cb7f94655e005150da3e73788e1f3a9fd468a736
+  data.tar.gz: 69ef1d941e8316dddcf67559502c091abe7df1af
 SHA512:
-  metadata.gz: 3872449535981b86aa3a2406ee61a1a3da36ff0b1eeb86fba96d73eab1efa96330b612c246dc684f5888b44e60ebfb9ebf741b0227ef9f18b9de05faefdc4cdb
-  data.tar.gz: 2c825a71271a12b7c85d11743d66d70ef49adb96d959b810366b0002304bb595c76d6b72384ba5a4f711b645dd8d18098d58962fd81b966917a871746042a82f
+  metadata.gz: 21f385fc78e17bbb78dc68b26194574c08ed494f16f75b4fa37f570131c8d55aeec4bbc654bcef7b873c5651f5328b274def2f032edfe338c6acbf3edd6e1810
+  data.tar.gz: dd62cdfa7593eb95b43ded250262358f057fa277d583cb7750d04811cbcf116504121fba08d9b93f111c4634371efeb3004cb64c6d7916442802a23d1b6a1748

data/lib/ruy.rb

@@ -0,0 +1,131 @@
+require_relative 'ruy/rule'
+require_relative 'ruy/adapters'
+require_relative 'ruy/conditions'
+require_relative 'ruy/rule_storage'
+
+module Ruy
+  class RuleSet < Rule
+
+    attr_reader :name
+    attr_reader :outcomes
+    attr_accessor :metadata
+
+    def initialize
+      super
+
+      @outcomes = []
+      @fallback = nil
+      @metadata = {}
+    end
+
+    def [](key)
+      @metadata[key]
+    end
+
+    def []=(key, value)
+      @metadata[key] = value
+    end
+
+    def call(ctx)
+      var_ctx = VariableContext.new(ctx, @vars)
+      if @apply = super(var_ctx)
+        compute_outcome(var_ctx)
+      else
+        @fallback
+      end
+    end
+
+    def apply?
+      @apply
+    end
+
+    def compute_outcome(var_ctx)
+      @outcomes.each do |outcome|
+        result = outcome.call(var_ctx)
+        unless result.nil?
+          return result
+        end
+      end
+
+      nil
+    end
+
+    def to_hash
+      if @outcomes.any?
+        super.merge({ outcomes: @outcomes.map { |o| o.to_hash } })
+      end
+    end
+
+    def fallback(value)
+      @fallback = value
+    end
+
+    def outcome(value, &block)
+      outcome = Outcome.new(value)
+
+      outcome.instance_exec(&block) if block_given?
+
+      @outcomes << outcome
+    end
+
+    def method_missing(m, *args, &block)
+      super
+    end
+  end
+
+  class Context < Hash
+    def self.from_hash(hash)
+       ctx = Context.new
+       ctx.merge!(hash)
+
+       ctx
+    end
+  end
+
+  class Outcome < Rule
+    attr_reader :value
+
+    def initialize(value)
+      super()
+
+      @value = value
+      @params = [@value]
+    end
+
+    def call(ctx)
+      if super(ctx)
+        @value
+      end
+    end
+
+    def ==(o)
+      o.kind_of?(Outcome) &&
+        value == o.value &&
+        conditions == o.conditions
+    end
+  end
+
+  # Context that can resolve variable access
+  class VariableContext
+    def initialize(ctx, vars)
+      @ctx = ctx
+      @vars = vars
+
+      @resolved_vars = {}
+    end
+
+    # Resolve the given attr from the variables or the context
+    # If attribute can't be resolved then throw an exception
+    #
+    # @param [Symbol] attr
+    # @return [Object]
+    def resolve(attr)
+      if @vars.include?(attr)
+        @resolved_vars[attr] ||= @ctx.instance_exec(&@vars[attr])
+      else
+        @ctx.fetch(attr) { |key| @ctx[key.to_s] }
+      end
+    end
+  end
+
+end

data/lib/ruy/adapters.rb

@@ -0,0 +1,6 @@
+require_relative 'adapters/file_adapter'
+require_relative 'adapters/sequel_adapter'
+
+module Ruy
+  module Adapters; end
+end

data/lib/ruy/adapters/file_adapter.rb

@@ -0,0 +1,28 @@
+module Ruy
+  module Adapters
+    class FileAdapter
+      #
+      # @param [String] directory
+      def initialize(directory)
+        @directory = directory
+      end
+
+      # Load all the rule files in the directory specified when the adapter
+      # was created
+      #
+      # @return [Array<Ruy::RuleSet]
+      def load_rules
+        rules = []
+
+        Dir.glob("#{@directory}/*.rb") do |rule_file|
+          rule_set = Ruy::RuleSet.new
+          rule_set.instance_eval(File.read(rule_file))
+
+          rules << rule_set
+        end
+
+        rules
+      end
+    end
+  end
+end

data/lib/ruy/adapters/sequel_adapter.rb

@@ -0,0 +1,40 @@
+require 'sequel'
+require 'json'
+
+module Ruy
+  module Adapters
+    class SequelAdapter
+      def initialize(connection_data)
+        @db = initialize_connection(connection_data)
+      end
+
+      # Load all the rule objects in the specified database.
+      #
+      # @return [Array<Ruy::RuleSet>]
+      def load_rules(params = {})
+        options = { rules_table: 'event_rules',
+          serialized_data_column: 'data' }.merge(params)
+
+        dataset = @db[options[:rules_table]].all
+        dataset.collect do |row|
+          rule_set = Ruy::RuleSet.from_hash(
+            JSON.parse(row[options[:serialized_data_column]], symbolize_names: true)
+          )
+
+          yield row, rule_set if block_given?
+          rule_set
+        end
+      end
+
+      private
+      #
+      # @param [Hash] connection_data
+      # @return []
+      def initialize_connection(connection_data)
+        Sequel.connect(adapter: connection_data[:adapter],
+          host: connection_data[:host], database: connection_data[:database],
+          user: connection_data[:user], password: connection_data[:password])
+      end
+    end
+  end
+end

data/lib/ruy/conditions.rb

@@ -0,0 +1,16 @@
+require_relative 'conditions/all'
+require_relative 'conditions/any'
+require_relative 'conditions/assert'
+require_relative 'conditions/between'
+require_relative 'conditions/cond'
+require_relative 'conditions/eq'
+require_relative 'conditions/except'
+require_relative 'conditions/greater_than_or_equal'
+require_relative 'conditions/include'
+require_relative 'conditions/included'
+require_relative 'conditions/less_than'
+require_relative 'conditions/less_than_or_equal'
+
+module Ruy
+  module Conditions; end
+end

data/lib/ruy/conditions/all.rb

@@ -0,0 +1,13 @@
+module Ruy
+  module Conditions
+
+    # Expects that all rules will succeed.
+    class All < Ruy::Rule
+      def call(var_ctx)
+        @conditions.all? do |condition|
+          condition.call(var_ctx)
+        end
+      end
+    end
+  end
+end

data/lib/ruy/conditions/any.rb

@@ -0,0 +1,18 @@
+module Ruy
+  module Conditions
+
+    # Expects that at least one of the rules will succeed.
+    class Any < Ruy::Rule
+      def call(var_ctx)
+        @conditions.any? do |condition|
+          condition.call(var_ctx)
+        end
+      end
+
+      def ==(o)
+        o.kind_of?(Any) &&
+          conditions == o.conditions
+      end
+    end
+  end
+end

data/lib/ruy/conditions/assert.rb

@@ -0,0 +1,24 @@
+module Ruy
+  module Conditions
+
+    # Asserts that an attribute has a truth value.
+    class Assert < Ruy::Rule
+      attr_reader :attr
+
+      # @param attr Context attribute's name
+      def initialize(attr)
+        @attr = attr
+        @params = [@attr]
+      end
+
+      def call(var_ctx)
+        var_ctx.resolve(@attr)
+      end
+
+      def ==(o)
+        o.kind_of?(Assert) &&
+          @attr == o.attr
+      end
+    end
+  end
+end

data/lib/ruy/conditions/between.rb

@@ -0,0 +1,40 @@
+module Ruy
+  module Conditions
+
+    # Expects that a context value belongs to a given range.
+    #
+    # Comparison formula: from <= context[attr] <= to
+    class Between < Ruy::Rule
+      attr_reader :attr, :from, :to
+
+      # @param attr Name of the attribute that will be evaluated
+      # @param from Range lower bound
+      # @param to Range upper bound
+      # @yield a block in the context of the current rule
+      def initialize(attr, from, to, &block)
+        super()
+
+        @attr = attr
+        @from = from
+        @to = to
+
+        @params = [@attr, @from, @to]
+
+        instance_exec(&block) if block_given?
+      end
+
+      def call(var_ctx)
+        value = var_ctx.resolve(@attr)
+        @from <= value && value <= @to && super
+      end
+
+      def ==(o)
+        o.kind_of?(Between) &&
+          @attr == o.attr &&
+          @from == o.from &&
+          @to   == o.to &&
+          self.conditions == o.conditions
+      end
+    end
+  end
+end

data/lib/ruy/conditions/cond.rb

@@ -0,0 +1,26 @@
+module Ruy
+  module Conditions
+
+    # Expects a successful evaluation of a sub-pair of rules.
+    #
+    # Groups rules in slices of 2 rules. Then evalutes each slice until one of them succeds.
+    # If there's an even number of rules, the last slice will only one rule.
+    #
+    # Cond is handy for mocking if/else if/else constructs.
+    class Cond < Ruy::Rule
+      def call(var_ctx)
+        clauses = @conditions.each_slice(2)
+
+        clauses.any? do |rule_1, rule_2|
+          result = rule_1.call(var_ctx)
+
+          if rule_2
+            result && rule_2.call(var_ctx)
+          else
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruy/conditions/eq.rb

@@ -0,0 +1,30 @@
+module Ruy
+  module Conditions
+
+    # Expects that a context attribute will be equal to a given value.
+    #
+    class Eq < Ruy::Rule
+      attr_reader :attr, :value
+
+      # @param attr Context attribute's name
+      # @param value Expected value
+      def initialize(attr, value)
+        super()
+
+        @attr = attr
+        @value = value
+        @params = [@attr, @value]
+      end
+
+      def call(var_ctx)
+        var_ctx.resolve(@attr) == @value
+      end
+
+      def ==(o)
+        o.kind_of?(Eq) &&
+          attr == o.attr &&
+          value == o.value
+      end
+    end
+  end
+end

data/lib/ruy/conditions/except.rb

@@ -0,0 +1,50 @@
+module Ruy
+  module Conditions
+
+    # Expects that a condition is not met.
+    #
+    # When a sub-rule is given, Except will expect an unsuccessful evaluation of that sub-rule.
+    # When a sub-rule is not given, Except will expect a context attribute is not equal to a given
+    # value.
+    class Except < Ruy::Rule
+      attr_reader :attr, :value
+
+      # @param attr Context attribute's name
+      # @param value Non-expected value
+      # @yield a block in the context of the current rule
+      def initialize(attr = nil, value = nil, &block)
+        super()
+
+        @attr = attr
+        @value = value
+
+        @params = [@attr, @value]
+
+        if block_given?
+          instance_exec(&block)
+        end
+      end
+
+      def call(var_ctx)
+        result = true
+
+        if @attr
+          result &&= var_ctx.resolve(@attr) != @value
+        end
+
+        if self.conditions.any?
+          result &&= !super(var_ctx)
+        end
+
+        result
+      end
+
+      def ==(o)
+        o.kind_of?(Except) &&
+          @attr == o.attr &&
+          @value == o.value &&
+          @conditions == o.conditions
+      end
+    end
+  end
+end

data/lib/ruy/conditions/greater_than_or_equal.rb

@@ -0,0 +1,34 @@
+module Ruy
+  module Conditions
+
+    # Expects that a context attribute will be greater than or equal to the given value.
+    class GreaterThanOrEqual < Ruy::Rule
+      attr_reader :attr, :value
+
+      # @param attr Context attribute's name
+      # @param value
+      # @yield a block in the context of the current rule
+      def initialize(attr, value, &block)
+        super()
+
+        @attr = attr
+        @value = value
+
+        @params = [@attr, @value]
+
+        instance_exec(&block) if block_given?
+      end
+
+      def call(var_ctx)
+        var_ctx.resolve(@attr) >= @value && super
+      end
+
+      def ==(o)
+        o.kind_of?(GreaterThanOrEqual) &&
+          attr == o.attr &&
+          value == o.value &&
+          self.conditions == o.conditions
+      end
+    end
+  end
+end

data/lib/ruy/conditions/include.rb

@@ -0,0 +1,34 @@
+module Ruy
+  module Conditions
+
+    # Expects that a context attribute is included in a set of values.
+    class Include < Ruy::Rule
+      attr_reader :attr, :values
+
+      # @param attr Context attribute's name
+      # @param values Expected set of values
+      # @yield a block in the context of the current rule
+      def initialize(attr, values, &block)
+        super()
+
+        @attr = attr
+        @values = values
+
+        @params = [@attr, @values]
+
+        instance_exec(&block) if block_given?
+      end
+
+      def call(var_ctx)
+        self.values.include?(var_ctx.resolve(self.attr)) && super
+      end
+
+      def ==(o)
+        o.kind_of?(Include) &&
+          self.attr == o.attr &&
+          self.values == o.values &&
+          self.conditions == o.conditions
+      end
+    end
+  end
+end

data/lib/ruy/conditions/included.rb

@@ -0,0 +1,34 @@
+module Ruy
+  module Conditions
+
+    # Expects that a value is included in a set of values from the context attribute.
+    class Included < Ruy::Rule
+      attr_reader :attr, :value
+
+      # @param attr Context attribute's name
+      # @param value Expected set of values
+      # @yield a block in the context of the current rule
+      def initialize(attr, value, &block)
+        super()
+
+        @attr = attr
+        @value = value
+
+        @params = [@attr, @value]
+
+        instance_exec(&block) if block_given?
+      end
+
+      def call(var_ctx)
+        var_ctx.resolve(self.attr).include?(self.value) && super
+      end
+
+      def ==(o)
+        o.kind_of?(Included) &&
+          self.attr == o.attr &&
+          self.value == o.value &&
+          self.conditions == o.conditions
+      end
+    end
+  end
+end

data/lib/ruy/conditions/less_than.rb

@@ -0,0 +1,28 @@
+module Ruy
+  module Conditions
+
+    # Expects that a context attribute will be less than given value.
+    class LessThan < Ruy::Rule
+      attr_reader :attr, :value
+
+      # @param attr Context attribute's name
+      # @param value
+      def initialize(attr, value)
+        @attr = attr
+        @value = value
+
+        @params = [@attr, @value]
+      end
+
+      def call(var_ctx)
+        var_ctx.resolve(@attr) < @value
+      end
+
+      def ==(o)
+        o.kind_of?(LessThan) &&
+          attr == o.attr &&
+          value == o.value
+      end
+    end
+  end
+end

data/lib/ruy/conditions/less_than_or_equal.rb

@@ -0,0 +1,28 @@
+module Ruy
+  module Conditions
+
+    # Expects that a context attribute will be less than or equal to the given value.
+    class LessThanOrEqual < Ruy::Rule
+      attr_reader :attr, :value
+
+      # @param attr Context attribute's name
+      # @param value
+      def initialize(attr, value)
+        @attr = attr
+        @value = value
+
+        @params = [@attr, @value]
+      end
+
+      def call(var_ctx)
+        var_ctx.resolve(@attr) <= @value
+      end
+
+      def ==(o)
+        o.kind_of?(LessThanOrEqual) &&
+          attr == o.attr &&
+          value == o.value
+      end
+    end
+  end
+end

data/lib/ruy/rule.rb

@@ -0,0 +1,219 @@
+module Ruy
+
+  # Returns a constant using a qualified constant name string
+  #
+  # @param [String] name
+  # @return [Object]
+  def self.qualified_const_get(name)
+    root = Object
+    name.split('::').each do |klass|
+      root = root.const_get(klass)
+    end
+
+    root
+  end
+
+  # A rule is a set of conditions
+  class Rule
+
+    attr_reader :conditions
+    attr_reader :vars
+
+    def initialize
+      @conditions = []
+      @vars = {}
+      @attrs = {}
+      @params = []
+    end
+
+    # Serialize a rule object as a hash
+    #
+    # @return [Hash]
+    def to_hash
+      ret = { node: self.class.name, params: params }
+      ret[:conditions] = @conditions.map(&:to_hash) if @conditions.any?
+
+      ret
+    end
+
+    # Look to the given keys, and load the rule nodes in their values
+    #
+    # @param [Array<Symbol>] keys
+    # @param [Hash] hash
+    # @return [Ruy::Rule]
+    def load_rule_objects_from(hash, *keys)
+      keys.each do |key|
+        if hash.has_key?(key)
+          hash[key].each { |o| self.send(key) << Ruy::Rule.from_hash(o) }
+        end
+      end
+
+      self
+    end
+
+    # Load a new role from it hash representation
+    #
+    # @param [Hash] hash
+    # @return [Ruy::Rule]
+    def self.from_hash(hash)
+      rule = Ruy.qualified_const_get(hash[:node]).new(*hash[:params])
+      rule.load_rule_objects_from(hash, :conditions, :outcomes)
+    end
+
+    # Adds an All condition.
+    #
+    # @yield Evaluates the given block in the context of the current rule
+    def all(&block)
+      cond = Conditions::All.new
+      cond.instance_exec(&block)
+
+      @conditions << cond
+    end
+
+    # Adds an Any condition.
+    #
+    # @yield Evaluates the given block in the context of the current rule
+    def any(&block)
+      cond = Conditions::Any.new
+      cond.instance_exec(&block)
+
+      @conditions << cond
+    end
+
+    # Adds an Assert condition.
+    #
+    # @param (see Conditions::Assert#initialize)
+    def assert(attr)
+      @conditions << Conditions::Assert.new(attr)
+    end
+
+    # Adds a Between condition.
+    #
+    # @param (see Conditions::Between#initialize)
+    def between(attr, from, to, &block)
+      @conditions << Conditions::Between.new(attr, from, to, &block)
+    end
+
+    # Adds an Eq condition.
+    #
+    # @param (see Conditions::Eq#initialize)
+    def eq(attr, value, &block)
+      @conditions << Conditions::Eq.new(attr, value, &block)
+    end
+
+    # Adds a Cond condition.
+    #
+    # @yield Evaluates the given block in the context of the current rule
+    def cond(&block)
+      cond = Conditions::Cond.new
+      cond.instance_exec(&block)
+
+      @conditions << cond
+    end
+
+    # Adds an Except condition.
+    #
+    # @param (see Conditions::Except#initialize)
+    def except(attr = nil, value = nil, &block)
+      @conditions << Conditions::Except.new(attr, value, &block)
+    end
+
+    # Adds a GreaterThanOrEqual condition.
+    #
+    # @param (see Conditions::GreaterThanOrEqual#initialize)
+    def greater_than_or_equal(attr, value)
+      @conditions << Conditions::GreaterThanOrEqual.new(attr, value)
+    end
+
+    # Adds an Include condition.
+    #
+    # @param (see Conditions::Include#initialize)
+    def include(attr, values, &block)
+      @conditions << Conditions::Include.new(attr, values, &block)
+    end
+
+    # Adds an Included condition.
+    #
+    # @param (see Conditions::Included#initialize)
+    def included(attr, value, &block)
+      @conditions << Conditions::Included.new(attr, value, &block)
+    end
+
+    # Adds a LessOrEqualThan condition.
+    #
+    # @param (see Conditions::LessOrEqualThan#initialize)
+    def less_than_or_equal(attr, value, &block)
+      @conditions << Conditions::LessThanOrEqual.new(attr, value)
+    end
+
+    # Adds a LessThan condition.
+    #
+    # @param (see Conditions::LessThan#initialize)
+    def less_than(attr, value)
+      @conditions << Conditions::LessThan.new(attr, value)
+    end
+
+    # Gets attribute's value from the given name.
+    #
+    # @param name
+    #
+    # @return The attribute's value.
+    def get(name)
+      @attrs[name]
+    end
+
+    # Sets a custom attribute.
+    #
+    # @param name Attribute's name
+    # @param value Attribute's value
+    def set(name, value)
+      @attrs[name] = value
+    end
+
+    # Defines a variable.
+    #
+    # If both value and block are given, only the block will be taken into account.
+    #
+    # @param name The name of the variable
+    # @param value The value of the variable
+    #
+    # @yield a block that will resolve the variable's value
+    def var(name, value = nil, &block)
+      if block_given?
+        @vars[name] = block
+      else
+        @vars[name] = lambda { value }
+      end
+    end
+
+    # Evaluates all conditions.
+    #
+    # @return [true] When all conditions succeeds
+    # @return [false] Otherwise
+    def call(ctx)
+      success = @conditions.take_while do |condition|
+        condition.call(ctx)
+      end
+
+      success.length == @conditions.length
+    rescue NoMethodError
+      false
+    end
+
+    def ==(o)
+      o.kind_of?(Rule) &&
+        conditions == o.conditions &&
+        vars.keys == o.vars.keys
+    end
+
+    private
+
+    # Getter method for rules params. It returns all the params without nil objects
+    #
+    # @return [Array<Object>]
+    def params
+      @params.compact
+    end
+
+  end
+end

data/lib/ruy/rule_storage.rb

@@ -0,0 +1,36 @@
+module Ruy
+  class RuleStorage
+    attr_writer :adapter
+
+    def initialize(adapter, rules = [])
+      @adapter = adapter
+      @rules = rules
+    end
+
+    # Evaluate the given context against all the loaded rules
+    #
+    # @param [Hash] ctx
+    # @return [Array<Object>]
+    def evaluate_all(ctx)
+      @rules.map { |rule| rule.call(ctx) }.compact
+    end
+
+    # The first rule that apply will return the method
+    #
+    # @param [Hash] ctx
+    # @return [Object]
+    def evaluate_first(ctx)
+      @rules.each do |rule|
+        result = rule.call(ctx)
+        return result if rule.apply?
+      end
+    end
+
+    # Load all the rules from the adapter
+    #
+    def load_rules(params = {}, &block)
+      @rules = @adapter.load_rules(params, &block)
+    end
+    alias_method :relaod, :load_rules
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruy
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Moove-IT
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-04 00:00:00.000000000 Z
+date: 2014-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -24,14 +24,46 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 4.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 4.12.0
 description: 
 email: 
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- README.md
-homepage: 
+- lib/ruy/adapters/file_adapter.rb
+- lib/ruy/adapters/sequel_adapter.rb
+- lib/ruy/adapters.rb
+- lib/ruy/conditions/all.rb
+- lib/ruy/conditions/any.rb
+- lib/ruy/conditions/assert.rb
+- lib/ruy/conditions/between.rb
+- lib/ruy/conditions/cond.rb
+- lib/ruy/conditions/eq.rb
+- lib/ruy/conditions/except.rb
+- lib/ruy/conditions/greater_than_or_equal.rb
+- lib/ruy/conditions/include.rb
+- lib/ruy/conditions/included.rb
+- lib/ruy/conditions/less_than.rb
+- lib/ruy/conditions/less_than_or_equal.rb
+- lib/ruy/conditions.rb
+- lib/ruy/rule.rb
+- lib/ruy/rule_storage.rb
+- lib/ruy.rb
+homepage: https://github.com/Moove-it/ruy
 licenses:
 - MIT
 metadata: {}

data/README.md

@@ -1 +0,0 @@
-ruy comming soon