rulezilla 0.1.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0a5437383cf683007f42c90a096f3428103cdc46
+  data.tar.gz: 0e3366b7fee344c1d5c1958ee1f8ffd54a2b402b
+SHA512:
+  metadata.gz: abb77e8d80423a511e1ea78a0c4600bb103f628879268033e653573c5e264840aaacebe52512334597853991b9aee9e66b51ea49511c8cb4f7e2e65d58cd4271
+  data.tar.gz: 2c0100529a1032e5b02b12c522effc33d44cd8753cdfbd3541b9f1d83ab197e5864a098f44eab8238c9347f3657d1e0601d12dc2bf2ea17554b70f1d63fc034d

data/.gitignore

@@ -0,0 +1 @@
+.bundle

data/.rspec

@@ -0,0 +1,2 @@
+--colour --order rand
+-r turnip/rspec

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+gemspec
+
+gem 'rspec'
+gem 'turnip'
+gem 'pry'

data/Gemfile.lock

@@ -0,0 +1,44 @@
+PATH
+  remote: .
+  specs:
+    rulezilla (0.1.4)
+      gherkin
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.0)
+    diff-lcs (1.2.5)
+    gherkin (2.12.2)
+      multi_json (~> 1.3)
+    method_source (0.8.2)
+    multi_json (1.10.1)
+    pry (0.9.12.6)
+      coderay (~> 1.0)
+      method_source (~> 0.8)
+      slop (~> 3.4)
+    rspec (3.0.0)
+      rspec-core (~> 3.0.0)
+      rspec-expectations (~> 3.0.0)
+      rspec-mocks (~> 3.0.0)
+    rspec-core (3.0.3)
+      rspec-support (~> 3.0.0)
+    rspec-expectations (3.0.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.0.0)
+    rspec-mocks (3.0.3)
+      rspec-support (~> 3.0.0)
+    rspec-support (3.0.3)
+    slop (3.5.0)
+    turnip (1.2.2)
+      gherkin (>= 2.5)
+      rspec (>= 2.0, < 4.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  pry
+  rspec
+  rulezilla!
+  turnip

data/README.md

@@ -0,0 +1,109 @@
+[![Semaphore](https://semaphoreapp.com/api/v1/projects/e488365d-9c57-4431-916a-72aea091d1b5/229083/shields_badge.png)](https://semaphoreapp.com/simplybusiness/rulezilla)
+[![Code Climate](https://codeclimate.com/repos/53ecc0416956800c1d01f6bf/badges/76b47eaeffc33e312508/gpa.svg)](https://codeclimate.com/repos/53ecc0416956800c1d01f6bf/feed)
+
+
+rulezilla
+=========
+
+This provide a DSL to implement rules for various tasks. In the current version we are still rely user to have a certain level of Ruby knowledge to be able to use this DSL. The ultimate goal is for people without prior Ruby knowledge can change and even write the Rule.
+
+
+# Installation
+
+    gem 'rulezilla', git: 'git@github.com:simplybusiness/rulezilla.git'
+
+## Implementation
+
+### Rules
+
+#### Gherkin (Beta)
+
+rulezilla Gherkin has only very limited support now
+
+First set the path of which rulezilla can load the feature files from:
+
+    Rulezilla.gherkin_rules_path = 'absolute path'
+
+The filename will then converted to the name of the class, e.g. `invalid_number_rule.feature` will generate `Rulezilla::InvalidNumberRule` class
+
+We currently only support a very limited steps, please refer to:
+
+[True / False](spec/features/gherkin_rules/animal_rule.feature)
+
+[Duration](spec/features/gherkin_rules/duration_rule.feature)
+
+
+#### Ruby
+
+Please refer to the [feature](spec/features/rulezilla_dsl_framwork.feature) for further details
+
+To use rulezilla, please include `Rulezilla::DSL` in your class:
+
+    class RoboticsRule
+      include Rulezilla::DSL
+
+      group :may_not_injure_human do
+        condition { not_injure_human? }
+
+        group :obey_human do
+          condition { do_as_human_told? }
+
+          define :protect_its_own_existence do
+            condition { protect_itself? }
+            result(true)
+          end
+        end
+      end
+
+      default(false)
+
+    end
+
+### Support Module
+
+The support module will be automatically included if its name is `"#{rule_class_name}Support"`
+
+e.g. if the rule class name is `RoboticsRule`, then the support would be `RoboticsRuleSupport`
+
+    module RoboticsRuleSupport
+      def protect_itself?
+        in_danger? && not_letting_itself_be_detroyed?
+      end
+    end
+
+### How to execute the rule
+
+if the entity is:
+
+    {
+      not_injure_human?: true,
+      do_as_human_told?: true,
+      in_danger?:        true,
+      not_letting_itself_be_detroyed?: true
+    }
+
+#### To get the first matching result
+
+    RoboticsRule.apply(entity) #=> true
+
+#### To get all matching results
+
+    RoboticsRule.all(entity) #=> [true]
+
+#### To get the trace of all node
+
+    RoboticsRule.trace(entity)
+    #=> all the nodes instance: [root, may_not_injure_human, obey_human, protect_its_own_existence] in sequence order.
+
+#### To get all results from the Rule
+
+    RoboticsRule.results #=> [true, false]
+
+
+# Syntax
+
+Please refer to the features for DSL syntax:
+
+[DSL Feature](spec/features/rulezilla_dsl_framwork.feature),
+
+[Default Support Methods Feature](spec/features/default_support_methods.feature)

data/lib/rulezilla.rb

@@ -0,0 +1,35 @@
+require 'rulezilla/node'
+require 'rulezilla/tree'
+require 'rulezilla/basic_support'
+require 'rulezilla/dsl'
+require 'rulezilla/rule_builder'
+
+module Rulezilla
+  extend self
+
+  attr_accessor :gherkin_rules_path
+
+  def const_missing(name)
+    raise 'Missing Gherkin Rule Path' if gherkin_rules_path.nil?
+
+    matching_file = Dir.glob(File.join(gherkin_rules_path, '**', '*')).detect do |file|
+      File.basename(file, ".*") == underscore(name.to_s)
+    end
+
+    if matching_file.nil?
+      super
+    else
+      Rulezilla::RuleBuilder.from_file(name, matching_file).build
+    end
+  end
+
+  private
+  def underscore(camel_string)
+    camel_string.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+
+end

data/lib/rulezilla/basic_support.rb

@@ -0,0 +1,11 @@
+module Rulezilla
+  module BasicSupport
+
+    def does_not?(value)
+      value == false
+    end
+
+    alias_method :is_not?, :does_not?
+
+  end
+end

data/lib/rulezilla/dsl.rb

@@ -0,0 +1,120 @@
+module Rulezilla
+  module DSL
+    def self.included(base)
+      base.extend ClassMethods
+      create_klass(base)
+    end
+
+    def self.get_super(klass)
+      Object.const_get (['Object'] + klass.name.split('::'))[0..-2].join('::')
+    end
+
+    def self.demodulize_klass_name(klass_name)
+      klass_name.split('::').last
+    end
+
+    def self.create_klass(parent_klass)
+      klass_name = parent_klass.name
+
+      klass = get_super(parent_klass).const_set("#{demodulize_klass_name(klass_name)}Record", Class.new)
+
+      klass.class_eval do
+        include Rulezilla::BasicSupport
+        include Object.const_get("#{klass_name}Support") rescue NameError
+
+        attr_reader :record
+
+        define_method(:initialize) do |record|
+          record = OpenStruct.new(record) if record.is_a?(Hash)
+          instance_variable_set('@record', record)
+        end
+
+        define_method(:method_missing) do |meth, *args, &block|
+          record.send(meth, *args, &block)
+        end
+      end
+
+      private_class_method :create_klass, :get_super, :demodulize_klass_name
+    end
+
+    module ClassMethods
+      def mandatory_attributes
+        @mandatory_attributes ||= []
+      end
+
+      def apply(record={})
+        result_node = trace(record).last
+
+        result_node.nil? ? nil : result_node.result(record_klass_instance(record))
+      end
+
+      def all(record={})
+        validate_missing_attributes(record)
+        result_node = tree.find_all(record_klass_instance(record))
+
+        result_node.nil? ? nil : result_node.map { |node| node.result(record_klass_instance(record)) }
+      end
+
+      def results(record=nil)
+        tree.all_results(record_klass_instance(record)).uniq
+      end
+
+      def trace(record=nil)
+        validate_missing_attributes(record)
+
+        tree.trace(record_klass_instance(record))
+      end
+
+      def include_rule(rule)
+        if rule.ancestors.include?(Rulezilla::DSL)
+          tree.clone_and_append_children(rule.tree.root_node.children)
+        else
+          raise "#{rule.name} is not a Rulezilla class"
+        end
+      end
+
+      def tree
+        @tree ||= Tree.new(Node.new())
+      end
+
+      private
+
+      def record_klass_instance(record)
+        Object.const_get("#{self.name}Record").new(record)
+      end
+
+      def missing_attributes(record)
+        record = OpenStruct.new(record) if record.is_a?(Hash)
+        mandatory_attributes.map(&:to_sym) - record.methods
+      end
+
+      def validate_missing_attributes(record)
+        raise "Missing #{missing_attributes(record).join(', ')} attributes from: #{record}" unless missing_attributes(record).empty?
+      end
+
+      # DSL methods
+      def validate_attributes_presence(*fields)
+        @mandatory_attributes = mandatory_attributes | fields
+      end
+
+      def define(name=nil, &block)
+        tree.create_and_move_to_child(name)
+
+        instance_eval(&block)
+        tree.go_up
+      end
+      alias_method :group, :define
+
+      def condition(&block)
+        tree.current_node.condition = block
+      end
+
+      def result(value=nil, &block)
+        tree.current_node.result = value.nil? ? block : value
+      end
+      alias_method :default, :result
+
+      # End of DSL methods
+    end
+  end
+end

data/lib/rulezilla/node.rb

@@ -0,0 +1,44 @@
+module Rulezilla
+  class Node
+    attr_accessor :parent, :children
+    attr_reader   :condition, :default, :name
+
+    def initialize
+      @children = []
+    end
+
+    def has_children?
+      children.any?
+    end
+
+    def has_result?
+      !@result.nil?
+    end
+
+    def applies?(record)
+      return true if condition.nil?
+      record.instance_eval(&condition)
+    end
+
+    def result(record)
+      @result.is_a?(Proc) ? record.instance_eval(&@result) : @result
+    end
+
+    def condition=(block)
+      @condition = block
+    end
+
+    def name=(value)
+      @name = value.to_s
+    end
+
+    def result=(block)
+      @result = block
+    end
+
+    def add_child(node)
+      node.parent = self
+      children << node
+    end
+  end
+end

data/lib/rulezilla/rule_builder.rb

@@ -0,0 +1,101 @@
+require 'gherkin/parser/parser'
+require 'gherkin/formatter/json_formatter'
+require 'stringio'
+require 'json'
+require 'rulezilla/rule_builder/gherkin_to_result_rule'
+require 'rulezilla/rule_builder/gherkin_to_condition_rule'
+
+module Rulezilla
+  class RuleBuilder
+
+    def self.from_file(name, file)
+      new(name, IO.read(file))
+    end
+
+    attr_reader :name, :content
+
+    def initialize(name, content)
+      @name    = name
+      @content = content
+    end
+
+    def build
+      klass_definition = rules.map do |rule|
+        rule = RuleDefinition.new(rule, step_keyword)
+
+        condition_definition = rule.conditions.empty? ? "" : "condition { #{rule.conditions} }"
+
+        """
+          define \"#{rule.name}\" do
+            #{condition_definition}
+            result(#{rule.result})
+          end
+        """
+      end.join("\n")
+
+      klass = Rulezilla.const_set(name, Class.new)
+
+      klass.class_eval('include Rulezilla::DSL')
+      klass.class_eval(klass_definition)
+
+      klass
+    end
+
+
+    private
+
+    def step_keyword
+      gherkin_json.first['name'].gsub(/\s?rule/i, '')
+    end
+
+    def rules
+      gherkin_json.first['elements']
+    end
+
+    def gherkin_json
+      @gherkin_json ||= begin
+        io        = StringIO.new
+        formatter = Gherkin::Formatter::JSONFormatter.new(io)
+        parser    = Gherkin::Parser::Parser.new(formatter)
+
+        parser.parse(content, content, 0)
+        formatter.done
+
+        JSON.parse(io.string)
+      end
+    end
+
+
+    class RuleDefinition
+      def initialize(gherkin_json, step_keyword)
+        @gherkin_json = gherkin_json
+        @step_keyword = step_keyword
+      end
+
+      def name
+        @gherkin_json['name']
+      end
+
+      def conditions
+        condition_steps = steps.reject{|step| step['keyword'].strip.downcase == 'then'}
+        conditions = condition_steps.map do |step|
+          ::Rulezilla::RuleBuilder::GherkinToConditionRule.apply(record(step))
+        end.reject{|condition| condition == Rulezilla::RuleBuilder::DefaultCondition}.join(' && ')
+      end
+
+      def result
+        ::Rulezilla::RuleBuilder::GherkinToResultRule.apply record(steps.detect{|step| step['keyword'].strip.downcase == 'then'})
+      end
+
+      private
+
+      def steps
+        @steps ||= @gherkin_json['steps']
+      end
+
+      def record(step)
+        step.merge(step_keyword: @step_keyword)
+      end
+    end
+  end
+end