ruler_coaster 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 80db58713844c8cb30db6f810310015911d49bfa
+  data.tar.gz: b740b937df58c288825fe409caf4e60f281dfb37
+SHA512:
+  metadata.gz: decf550e775f6c84c184c03cbdc9b09739dd62dd297851d5b15b86b9b48a2e30913b0640b1a72962ecfac191e281044ff7c12200cc3767f388f76bd000a14c81
+  data.tar.gz: 77a6c4c91a9981ed7f1d849432c77de64986f41635933fa76d98886368520aa76d08fdb677ac8bb2b306c19a23268be09655d99c5a491b783d3c7620ddb2508d

data/README.md

@@ -0,0 +1,90 @@
+# RulerCoaster
+Rule engine
+
+[![Code Climate](https://codeclimate.com/github/Streetbees/ruler/badges/gpa.svg)](https://codeclimate.com/github/Streetbees/ruler)
+[![Test Coverage](https://codeclimate.com/github/Streetbees/ruler/badges/coverage.svg)](https://codeclimate.com/github/Streetbees/ruler/coverage)
+[![Build Status](https://travis-ci.org/Streetbees/RulerCoaster.svg?branch=master)](https://travis-ci.org/Streetbees/ruler)
+## Usage
+
+```ruby
+json_rule = {
+  type: "and",
+  left: {
+    type: "and",
+    left: {
+      type: "and",
+      left: {
+        type: "rule",
+        path: "user.gender",
+        operator: {
+          type: "equal",
+          value: "m"
+        }
+      },
+      right: {
+        type: "rule",
+        path: "user.location.city",
+        operator: {
+          type: "equal",
+          value: "London"
+        }
+      }
+    },
+    right: {
+      type: "rule",
+      path: "user.location.country",
+      operator: {
+        type: "equal",
+        value: "UK"
+      }
+    }
+  },
+  right: {
+    type: "rule",
+    path: "user.age",
+    operator: {
+      type: "equal",
+      value: 20
+    }
+  }
+}
+```
+
+```ruby
+data = {
+  user: {
+    gender: "m",
+    age: 20,
+    location: {
+      city: "London",
+      country: "UK"
+    }
+  }
+}
+```
+
+```ruby
+rules = RulerCoaster.parse(json_rule)
+
+result = ruler.(data)
+
+if result.success?
+  # continue
+else
+  result.input # input from that failed
+  result.rule # first rule that failed
+end
+```
+
+## Instalation
+
+Add this to your Gemfile:
+```
+gem 'ruler_coaster'
+```
+
+And then execute:
+
+```
+$> bundle install
+```

data/lib/ruler_coaster.rb

@@ -0,0 +1,13 @@
+require 'ruler_coaster/parser'
+require 'ruler_coaster/operator/base'
+require 'ruler_coaster/logic/base'
+require 'ruler_coaster/rule'
+require 'ruler_coaster/result'
+require 'ruler_coaster/no_result'
+require 'ruler_coaster/attributes/base'
+
+module RulerCoaster
+  class NavigationError < StandardError; end
+
+  extend Parser
+end

data/lib/ruler_coaster/attributes/base.rb

@@ -0,0 +1,52 @@
+require 'ruler_coaster/attributes/result'
+
+module RulerCoaster
+  module Attributes
+    class Base
+      attr_reader :rules
+
+      def initialize(rules)
+        @rules = rules
+      end
+
+      def call(object)
+        errors = {}
+        blocked = []
+
+        each_attr_rule_result(object) do |attr, result|
+          if result.is_a?(RulerCoaster::NoResult)
+            blocked = block(blocked, attr)
+          elsif !result.success?
+            errors = hell(errors, attr, 'is invalid')
+          end
+        end
+
+        RulerCoaster::Attributes::Result.new(rules, object, errors, blocked)
+      end
+
+      private
+
+      def each_attr_rule_result(object)
+        rules.each do |attr, attr_rules|
+          attr_rules.each do |rule|
+            yield(attr, rule.call(object))
+          end
+        end
+      end
+
+      def hell(errors, attr, message)
+        attr_errors = errors[attr] ||= []
+
+        attr_errors << 'is invalid' unless attr_errors.include?(message)
+
+        errors[attr] = attr_errors
+        errors
+      end
+
+      def block(blocked, attr)
+        blocked << attr unless blocked.include?(attr)
+        blocked
+      end
+    end
+  end
+end

data/lib/ruler_coaster/attributes/result.rb

@@ -0,0 +1,21 @@
+module RulerCoaster
+  module Attributes
+    class Result
+      attr_reader :rules,
+                  :input,
+                  :errors,
+                  :blocked
+
+      def initialize(rules, input, errors, blocked = {})
+        @rules = rules
+        @input = input
+        @errors = errors
+        @blocked = blocked
+      end
+
+      def success?
+        @errors.keys.empty? && @blocked.empty?
+      end
+    end
+  end
+end

data/lib/ruler_coaster/logic/and.rb

@@ -0,0 +1,15 @@
+module RulerCoaster
+  module Logic
+    class And < Base
+      def call(object)
+        result = left.call(object)
+
+        if result.success?
+          right.call(object)
+        else
+          result
+        end
+      end
+    end
+  end
+end

data/lib/ruler_coaster/logic/base.rb

@@ -0,0 +1,22 @@
+require 'ruler_coaster/logic/mixin'
+
+module RulerCoaster
+  module Logic
+    class Base
+      include Mixin
+
+      attr_reader :left,
+                  :right
+
+      def initialize(left, right)
+        @left = left
+        @right = right
+      end
+    end
+  end
+end
+
+require 'ruler_coaster/logic/and'
+require 'ruler_coaster/logic/or'
+require 'ruler_coaster/logic/not'
+require 'ruler_coaster/logic/nor'

data/lib/ruler_coaster/logic/mixin.rb

@@ -0,0 +1,21 @@
+module RulerCoaster
+  module Logic
+    module Mixin
+      def and(right)
+        Logic::And.new(self, right)
+      end
+
+      def or(right)
+        Logic::Or.new(self, right)
+      end
+
+      def not(right)
+        Logic::Not.new(self, right)
+      end
+
+      def nor(right)
+        Logic::Nor.new(self, right)
+      end
+    end
+  end
+end

data/lib/ruler_coaster/logic/nor.rb

@@ -0,0 +1,15 @@
+module RulerCoaster
+  module Logic
+    class Nor < Base
+      def call(object)
+        result = left.call(object)
+
+        if !result.success?
+          right.call(object).negation
+        else
+          result.negation
+        end
+      end
+    end
+  end
+end

data/lib/ruler_coaster/logic/not.rb

@@ -0,0 +1,15 @@
+module RulerCoaster
+  module Logic
+    class Not < Base
+      def call(object)
+        result = left.call(object)
+
+        if result.success?
+          right.call(object).negation
+        else
+          result.negation
+        end
+      end
+    end
+  end
+end

data/lib/ruler_coaster/logic/or.rb

@@ -0,0 +1,15 @@
+module RulerCoaster
+  module Logic
+    class Or < Base
+      def call(object)
+        result = left.call(object)
+
+        if !result.success?
+          right.call(object)
+        else
+          result
+        end
+      end
+    end
+  end
+end

data/lib/ruler_coaster/no_result.rb

@@ -0,0 +1,14 @@
+module RulerCoaster
+  class NoResult < Result
+    attr_reader :rule,
+                :input
+
+    def initialize(rule, input)
+      super(rule, input, false)
+    end
+
+    def negation
+      self
+    end
+  end
+end

data/lib/ruler_coaster/operator/base.rb

@@ -0,0 +1,20 @@
+module RulerCoaster
+  module Operator
+    class Base
+      attr_reader :assert_value
+
+      def initialize(assert_value)
+        @assert_value = assert_value
+      end
+    end
+  end
+end
+
+require 'ruler_coaster/operator/contain'
+require 'ruler_coaster/operator/empty'
+require 'ruler_coaster/operator/equal'
+require 'ruler_coaster/operator/greater_than'
+require 'ruler_coaster/operator/less_than'
+require 'ruler_coaster/operator/not_contain'
+require 'ruler_coaster/operator/not_empty'
+require 'ruler_coaster/operator/not_equal'

data/lib/ruler_coaster/operator/contain.rb

@@ -0,0 +1,9 @@
+module RulerCoaster
+  module Operator
+    class Contain < Base
+      def call(value)
+        assert_value.map(&:to_s).map(&:downcase).include?(value.to_s.downcase)
+      end
+    end
+  end
+end

data/lib/ruler_coaster/operator/empty.rb

@@ -0,0 +1,13 @@
+module RulerCoaster
+  module Operator
+    class Empty < Base
+      def initialize(*_args)
+        super(nil)
+      end
+
+      def call(value)
+        value.to_s.empty?
+      end
+    end
+  end
+end

data/lib/ruler_coaster/operator/equal.rb

@@ -0,0 +1,9 @@
+module RulerCoaster
+  module Operator
+    class Equal < Base
+      def call(value)
+        assert_value.casecmp(value.to_s) == 0
+      end
+    end
+  end
+end

data/lib/ruler_coaster/operator/greater_than.rb

@@ -0,0 +1,9 @@
+module RulerCoaster
+  module Operator
+    class GreaterThan < Base
+      def call(value)
+        value > assert_value
+      end
+    end
+  end
+end

data/lib/ruler_coaster/operator/less_than.rb

@@ -0,0 +1,9 @@
+module RulerCoaster
+  module Operator
+    class LessThan < GreaterThan
+      def call(value)
+        !super
+      end
+    end
+  end
+end

data/lib/ruler_coaster/operator/not_contain.rb

@@ -0,0 +1,9 @@
+module RulerCoaster
+  module Operator
+    class NotContain < Contain
+      def call(value)
+        !super
+      end
+    end
+  end
+end

data/lib/ruler_coaster/operator/not_empty.rb

@@ -0,0 +1,9 @@
+module RulerCoaster
+  module Operator
+    class NotEmpty < Empty
+      def call(value)
+        !super(value)
+      end
+    end
+  end
+end

data/lib/ruler_coaster/operator/not_equal.rb

@@ -0,0 +1,9 @@
+module RulerCoaster
+  module Operator
+    class NotEqual < Equal
+      def call(value)
+        !super
+      end
+    end
+  end
+end

data/lib/ruler_coaster/parser.rb

@@ -0,0 +1,78 @@
+module RulerCoaster
+  module Parser
+    def parse(root)
+      visit(symbolyze_keys(root))
+    end
+
+    def visit(node)
+      send("visit_#{node[:type]}", node)
+    end
+
+    def visit_and(node)
+      Logic::And.new(visit(node[:left]), visit(node[:right]))
+    end
+
+    def visit_not(node)
+      Logic::Not.new(visit(node[:left]), visit(node[:right]))
+    end
+
+    def visit_or(node)
+      Logic::Or.new(visit(node[:left]), visit(node[:right]))
+    end
+
+    def visit_nor(node)
+      Logic::Nor.new(visit(node[:left]), visit(node[:right]))
+    end
+
+    def visit_rule(node)
+      Rule.new(node[:path], visit(node[:operator]))
+    end
+
+    def visit_equal(node)
+      Operator::Equal.new(node[:value])
+    end
+
+    def visit_not_equal(node)
+      Operator::NotEqual.new(node[:value])
+    end
+
+    def visit_greater_than(node)
+      Operator::GreaterThan.new(node[:value])
+    end
+
+    def visit_less_than(node)
+      Operator::LessThan.new(node[:value])
+    end
+
+    def visit_contain(node)
+      Operator::Contain.new(node[:value])
+    end
+
+    def visit_not_contain(node)
+      Operator::NotContain.new(node[:value])
+    end
+
+    def visit_empty(node)
+      Operator::Empty.new(node[:value])
+    end
+
+    def visit_not_empty(node)
+      Operator::NotEmpty.new(node[:value])
+    end
+
+    module_function
+
+    def symbolyze_keys(hash)
+      {}.tap do |symbolyzed_hash|
+        hash.each do |key, value|
+          symbolyzed_hash[key.to_sym] = \
+            if value.is_a?(Hash)
+              symbolyze_keys(value)
+            else
+              value
+            end
+        end
+      end
+    end
+  end
+end

data/lib/ruler_coaster/result.rb

@@ -0,0 +1,22 @@
+module RulerCoaster
+  class Result
+    attr_reader :rule,
+                :input
+
+    def initialize(rule, input, success)
+      @rule = rule
+      @input = input
+      @success = success
+    end
+
+    def success?
+      @success == true
+    end
+
+    def negation
+      @success = !@success
+
+      self
+    end
+  end
+end

data/lib/ruler_coaster/rule.rb

@@ -0,0 +1,41 @@
+module RulerCoaster
+  class Rule
+    include Logic::Mixin
+
+    attr_reader :path,
+                :operator
+
+    def initialize(path, operator)
+      @path = path.split('.')
+      @operator = operator
+    end
+
+    def call(object)
+      input = navigate(object, path)
+
+      if input.nil? && !operator.is_a?(Operator::Empty)
+        NoResult.new(self, input)
+      else
+        Result.new(self, input, operator.call(input))
+      end
+    end
+
+    private
+
+    def navigate(object, navigation_path)
+      object = RulerCoaster::Parser.symbolyze_keys(object)
+
+      navigation_path = navigation_path.dup
+
+      next_key = navigation_path.shift.to_sym
+
+      if !navigation_path.empty?
+        navigate(object[next_key], navigation_path)
+      else
+        object[next_key]
+      end
+    rescue
+      raise NavigationError, "cannot navigate to #{path} on #{object.inspect}"
+    end
+  end
+end

data/lib/ruler_coaster/version.rb

@@ -0,0 +1,3 @@
+module RulerCoaster
+  VERSION = '1.0.1'.freeze
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: ruler_coaster
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Streetbees Dev Team
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.37.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.37.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+description: RulerCoaster
+email:
+- dev@streetbees.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/ruler_coaster.rb
+- lib/ruler_coaster/attributes/base.rb
+- lib/ruler_coaster/attributes/result.rb
+- lib/ruler_coaster/logic/and.rb
+- lib/ruler_coaster/logic/base.rb
+- lib/ruler_coaster/logic/mixin.rb
+- lib/ruler_coaster/logic/nor.rb
+- lib/ruler_coaster/logic/not.rb
+- lib/ruler_coaster/logic/or.rb
+- lib/ruler_coaster/no_result.rb
+- lib/ruler_coaster/operator/base.rb
+- lib/ruler_coaster/operator/contain.rb
+- lib/ruler_coaster/operator/empty.rb
+- lib/ruler_coaster/operator/equal.rb
+- lib/ruler_coaster/operator/greater_than.rb
+- lib/ruler_coaster/operator/less_than.rb
+- lib/ruler_coaster/operator/not_contain.rb
+- lib/ruler_coaster/operator/not_empty.rb
+- lib/ruler_coaster/operator/not_equal.rb
+- lib/ruler_coaster/parser.rb
+- lib/ruler_coaster/result.rb
+- lib/ruler_coaster/rule.rb
+- lib/ruler_coaster/version.rb
+homepage: https://github.com/streetbees/rule-coaster
+licenses: []
+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.4.6
+signing_key: 
+specification_version: 4
+summary: Rule engine
+test_files: []