strategize 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 87efd0ffdecd640f1522ccbd34bb1ea15c733d99
-  data.tar.gz: 417c5296430434f94ed464c2606f8dfa45130f60
+  metadata.gz: 42524de68454e2ad718b1849668425b46440fbac
+  data.tar.gz: 0191dd00cce17dbc790d18f14646ffa56a43dada
 SHA512:
-  metadata.gz: f1f3b54f43c019a1a4e1810bcff8d1d4ad049dfa2ff5fc4c599973eafebef4b0a5843b2d2f83de67026db2ccdebc6943d11aa54b4e0ac73e73615dcd3a631f21
-  data.tar.gz: ea04d4dc1a8ad2e00cbf7c9fc76c7620932b99c364863b1f41f3784ac3c1f55c43f8da16d9d10b282a006b0f8b16b96f339e8cf70da538a93295f0818d2c34b9
+  metadata.gz: 6cf723d3e305c0f90fdce8cb878f51bd688477101f20bf82daa3b340e95de8c2146274a592860b6106492bfb1a9fcf9f3586ec27f856645a5d2135aa348e009d
+  data.tar.gz: ac6bd23200464784123842b3c84c7986f90cdfc96fa3b7e597a6ee17e50be42e4cb3b41fa37de51befb9acf2db48e88f3b3de2f46138441127e90fca2d6f1fb8

data/lib/strategize.rb

@@ -1,7 +1,20 @@
 module Strategize
-  autoload :Rule,               'strategize/rule'
-  autoload :RuleGroup,          'strategize/rule_group'
-  autoload :Policy,             'strategize/policy'
-  autoload :Operation,          'strategize/operation'
-  autoload :PolicyGroup,        'strategize/policy_group'
+  # Rules
+  autoload :Rule,                       'strategize/rules/rule'
+  autoload :RuleGroup,                  'strategize/rules/rule_group'
+  autoload :RuleResult,                 'strategize/rules/rule_result'
+  autoload :RuleResultCollection,       'strategize/rules/rule_result_collection'
+
+  # Policies
+  autoload :Policy,                     'strategize/policies/policy'
+  autoload :PolicyGroup,                'strategize/policies/policy_group'
+  autoload :PolicyResult,               'strategize/policies/policy_result'
+  autoload :PolicyResultCollection,     'strategize/policies/policy_result_collection'
+
+  # Operations
+  autoload :Operation,                  'strategize/operations/operation'
+  autoload :OperationGroup,             'strategize/operations/operation_group'
+
+  # Exceptions
+  autoload :NotPolicyError,             'strategize/exceptions'
 end

data/lib/strategize/exceptions.rb

@@ -0,0 +1,5 @@
+module Strategize
+  # Raised when a class does not include
+  # the Stategize::Policy module. 
+  NotPolicyError = Class.new(RuntimeError)
+end

data/lib/strategize/operations/operation.rb

@@ -0,0 +1,33 @@
+module Strategize
+  # Operations let you define a block of code that you would like to
+  # execute, and by calling process with a subject you can tell the
+  # operation what object you would like to execute the code against.
+  #
+  # Operations are similar to Rules, but the block of code that you
+  # pass in the constuctor does not have to be a predicate function.
+  class Operation
+    # @attr_reader name a descriptive name for the operation
+    attr_reader :name
+
+    # @attr_reader function A Proc or Lambda describing the code to be executed
+    attr_reader :function
+
+    # Create a new instance of Operation
+    #
+    # @param name [Symbol] a descriptive name for the operation
+    # @param function [Proc] the code to be executed
+    # @return [Operation]
+    def initialize(name, function)
+      @name = name
+      @function = function
+    end
+
+    # Execute the function against a specific object
+    #
+    # @param subject [Object] will become self when executing the function
+    # @return [void]
+    def process(subject)
+      subject.instance_exec(&@function)
+    end
+  end
+end

data/lib/strategize/operations/operation_group.rb

@@ -0,0 +1,45 @@
+module Strategize
+  class OperationGroup
+    # @attr_reader operations [Array<Operation>]
+    attr_reader :operations
+
+    # Create a new instance of OperationGroup
+    #
+    # @param operations [Array<Operation>] the operations to be executed
+    def initialize(operations=[])
+      @operations = operations
+    end
+
+    # Add Operation to group
+    #
+    # @param name [Symbol] a descriptive name for the operation
+    # @param operation [Proc] a proc or lambda describing the code to be executed
+    def add(name, function)
+      operation = Operation.new(name, function)
+      @operations.push(operation)
+    end
+
+    # Execute the code definined in each operation against a subject.
+    #
+    # @param subject [Object] a single object which acts as the subject for each operation
+    # @param subject [Hash] a hash of operation names and subjects
+    def run(subjects)
+      the_subjects = subjects
+
+      if !subjects.is_a?(Hash)
+        the_subjects = build_subjects_hash(subjects)
+      end
+
+      @operations.each do |operation|
+        subject = the_subjects[operation.name]
+        operation.process(subject) unless subject.nil?
+      end
+    end
+
+    private
+
+    def build_subjects_hash(subjects)
+      { default: subjects }
+    end
+  end
+end

data/lib/strategize/policies/policy.rb

@@ -0,0 +1,47 @@
+module Strategize
+  # The policy module allows you to define rules and an operation on
+  # any class that it is included on.
+  module Policy
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.send(:attr_reader, :object)
+    end
+
+    # These methods will be placed on the class that includes
+    # the Policy module.
+    module ClassMethods
+      # Get all the rules defined on this policy
+      #
+      # @return [RuleGroup]
+      def rules
+        @rules ||= RuleGroup.new
+      end
+
+      # Get all the operations defined on this policy.
+      #
+      # @return [OperationGroup]
+      def operations
+        @operations ||= OperationGroup.new
+      end
+
+      # Define a rule for a policy
+      #
+      # @param name [Symbol] descriptive name for the rule
+      # @param predicate [Proc] code to execute
+      # @return [void]
+      def rule(name, predicate)
+        rules.add(name, predicate)
+      end
+
+      # Define a block of code to run when you call the process
+      # method
+      #
+      # @param name [Symbol] the name of the context for the operation
+      # @param block [Proc] the code block to execute
+      # @return [void]
+      def operation(name = :default, &block)
+        operations.add(name, block)
+      end
+    end
+  end
+end

data/lib/strategize/policies/policy_group.rb

@@ -0,0 +1,43 @@
+module Strategize
+  # The PolicyGroup allows you to evaluate a subject against
+  # multiple policies.
+  class PolicyGroup
+    attr_reader :policies
+
+    # Create a new PolicyGroup
+    def initialize
+      @policies = []
+    end
+
+    # Add policy to the group
+    #
+    # @param policy [Strategize::Policy] a class that includes the Policy module
+    # @return [void]
+    def add(policy)
+      fail Strategize::NotPolicyError unless policy?(policy)
+      @policies.push(policy)
+    end
+
+    # Evaluate each policy against a given subject.
+    #
+    # @param subject [Object]
+    # @return [PolicyResultCollection]
+    def evaluate(subject)
+      results = @policies.map do |policy|
+        result_collection = policy.rules.evaluate(subject)
+        PolicyResult.new(policy, result_collection)
+      end
+      PolicyResultCollection.new(results, subject)
+    end
+
+    private
+
+    # Check if a policy includes the Policy module
+    #
+    # @private
+    # @param policy [Class] the class to check
+    def policy?(policy)
+      policy.included_modules.include?(Policy)
+    end
+  end
+end

data/lib/strategize/policies/policy_result.rb

@@ -0,0 +1,33 @@
+module Strategize
+  # A PolicyResult is returned when you evaluate
+  # a PolicyGroup and allows you to view the
+  # RuleResultCollection and whether the policy
+  # was valid (all rules returned true)
+  class PolicyResult
+    attr_reader :policy, :rule_group, :subject
+
+    # Create a new PolicyEvaluation
+    #
+    # @param policy [Policy]
+    # @param rule_result_collection [RuleResultCollection]
+    # @return [PolicyResult]
+    def initialize(policy, rule_result_collection)
+      @policy = policy
+      @rule_result_collection = rule_result_collection
+    end
+
+    # Check if all the rules for the policy evaluated to true
+    #
+    # @return [Boolean]
+    def valid?
+      @rule_result_collection.all_valid?
+    end
+
+    # Get the results for rules on the policy
+    #
+    # @return [RuleResultCollection]
+    def rules
+      @rule_result_collection
+    end
+  end
+end

data/lib/strategize/policies/policy_result_collection.rb

@@ -0,0 +1,33 @@
+module Strategize
+  # A wrapper for an array of PolicyResult instances.
+  class PolicyResultCollection
+    # @return [Array<PolicyResult>] the policy results for each policy
+    attr_reader :items
+
+    # @return [Object] the subject the policy was executed against
+    attr_reader :subject
+
+    # Create a new PolicyResultCollection
+    #
+    # @param policy_results [Array<PolicyResult]
+    # @param subject [Object] the subject the policies were executed against
+    def initialize(policy_results, subject)
+      @items = policy_results
+      @subject = subject
+    end
+
+    # Get an array of the PolicyResults that are valid, or return true
+    #
+    # @return [Array<PolicyResult>]
+    def passed
+      @items.select(&:valid)
+    end
+
+    # Get an array of the PolicyResults that are invalid, or return false
+    #
+    # @return [Array<PolicyResult>]
+    def failed
+      @items.select { |rule| !rule.valid? }
+    end
+  end
+end

data/lib/strategize/rules/rule.rb

@@ -0,0 +1,31 @@
+module Strategize
+  # The Rule class represents a predicate function that
+  # can be run against a specific subject.
+  #
+  # Define a new rule
+  # Rule.new :rule_name, -> { code to execute }
+  #
+  # Evaluate a rule
+  # rule = Rule.new :rule_name, -> { true }
+  # rule.evaluate(nil) #=> true 
+  class Rule
+    attr_reader :name, :predicate
+
+    # Create a new rule
+    #
+    # @param name [Symbol] a descriptive name for the rule
+    # @param predicate [Proc] code block to be executed
+    def initialize(name, predicate)
+      @name = name
+      @predicate = predicate
+    end
+
+    # Execute the predicate against the subject
+    #
+    # @param subject [Object]
+    # @return [Boolean]
+    def evaluate(subject)
+      subject.instance_exec(&@predicate)
+    end
+  end
+end

data/lib/strategize/rules/rule_group.rb

@@ -0,0 +1,33 @@
+module Strategize
+  # The RuleGroup allows you evaluate multiple rules against one subject.
+  class RuleGroup
+    attr_reader :rules
+
+    # Create new Rule Group
+    #
+    # @param rules [Array<Rule>] rules to be evaluated
+    def initialize(rules = [])
+      @rules = rules
+    end
+
+    # Add [Rule] to be evaluated
+    #
+    # @param name [Symbol] a descriptive name for the rule
+    # @param predicate [Lambda] a function that returns true or false
+    def add(name, predicate)
+      @rules.push(Rule.new(name, predicate))
+    end
+
+    # Evaluate all rules in group and return a collection
+    # of the results.
+    #
+    # @param subject [Object] object to evaluate rules against
+    # @return [RuleResultCollection] evaluation results
+    def evaluate(subject)
+      results = @rules.map do |rule|
+        RuleResult.new(rule, rule.evaluate(subject))
+      end
+      RuleResultCollection.new(results, subject)
+    end
+  end
+end

data/lib/strategize/rules/rule_result.rb

@@ -0,0 +1,18 @@
+module Strategize
+  # A RuleResult represents the evaluation result, which gives
+  # you access to the Rule and whether it was valid or not.
+  class RuleResult
+    attr_reader :rule, :valid
+
+    # Create a new RuleResult which provides details on
+    # the evaluation of a rule.
+    #
+    # @param rule [Rule] the evaluated rule
+    # @param valid [Boolean] the result of the executed rule
+    # @return [RuleResult]
+    def initialize(rule, valid)
+      @rule = rule
+      @valid = valid
+    end
+  end
+end

data/lib/strategize/rules/rule_result_collection.rb

@@ -0,0 +1,45 @@
+module Strategize
+  # Represents a collection of RuleResults, which lets you see
+  # what rules passed, failed, etc.
+  class RuleResultCollection
+    attr_reader :items, :subject
+
+    # Create a new RuleResultCollection
+    #
+    # @param rule_results [Array<RuleResult>]
+    # @param subject [Object]
+    # @return [RuleResultCollection]
+    def initialize(rule_results, subject)
+      @items = rule_results
+      @subject = subject
+    end
+
+    # Iterate over each [RuleResult] in the items Array.
+    #
+    # @param block [Proc]
+    def each(&block)
+      @items.each { |item| block.call(item) }
+    end
+
+    # Returns if all rules evaluated to true
+    #
+    # @return [Boolean]
+    def all_valid?
+      @items.all?(&:valid)
+    end
+
+    # Returns all rules that evaluated to true
+    #
+    # @return [Array<RuleResult>]
+    def passed
+      @items.select(&:valid)
+    end
+
+    # Returns all rules that evaluated to false
+    #
+    # @return [Array<RuleResult>]
+    def failed
+      @items.select { |rule| !rule.valid }
+    end
+  end
+end

data/test/test_helper.rb

@@ -1,3 +1,10 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/test/'
+  add_group 'Rules',      'lib/strategize/rules'
+  add_group 'Policies',   'lib/strategize/policies'
+end
+
 require 'strategize'
 
 require 'minitest/autorun'
@@ -6,6 +13,4 @@ require 'minitest/reporters'
 test_root = File.dirname(__FILE__)
 Dir["#{test_root}/support/*.rb"]. each { |file| require file }
 
-
-
 Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new(color: true)

metadata

@@ -1,27 +1,41 @@
 --- !ruby/object:Gem::Specification
 name: strategize
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - jdmorlan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-31 00:00:00.000000000 Z
+date: 2016-04-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest-reporters
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: Strategize
@@ -31,16 +45,19 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/strategize.rb
-- lib/strategize/operation.rb
-- lib/strategize/policy.rb
-- lib/strategize/policy_group.rb
-- lib/strategize/rule.rb
-- lib/strategize/rule_group.rb
-- test/policy_group_test.rb
-- test/policy_test.rb
-- test/rule_test.rb
+- lib/strategize/exceptions.rb
+- lib/strategize/operations/operation.rb
+- lib/strategize/operations/operation_group.rb
+- lib/strategize/policies/policy.rb
+- lib/strategize/policies/policy_group.rb
+- lib/strategize/policies/policy_result.rb
+- lib/strategize/policies/policy_result_collection.rb
+- lib/strategize/rules/rule.rb
+- lib/strategize/rules/rule_group.rb
+- lib/strategize/rules/rule_result.rb
+- lib/strategize/rules/rule_result_collection.rb
 - test/test_helper.rb
-homepage: 
+homepage: https://github.com/jdmorlan/strategize
 licenses:
 - MIT
 metadata: {}
@@ -65,8 +82,5 @@ signing_key:
 specification_version: 4
 summary: Validate rules and perform operations
 test_files:
-- test/policy_group_test.rb
-- test/policy_test.rb
-- test/rule_test.rb
 - test/test_helper.rb
 has_rdoc: 

data/lib/strategize/operation.rb

@@ -1,18 +0,0 @@
-module Strategize
-  module Operation
-    def self.included(base)
-      base.extend(ClassMethods)
-      base.send(:attr_reader, :object)
-    end
-
-    module ClassMethods
-      def operation(&block)
-        @operation = block
-      end
-
-      def process(subject)
-        subject.instance_exec &@operation
-      end
-    end
-  end
-end

data/lib/strategize/policy.rb

@@ -1,22 +0,0 @@
-module Strategize
-  module Policy
-    def self.included(base)
-      base.extend(ClassMethods)
-      base.send(:attr_reader, :object)
-    end
-
-    module ClassMethods
-      def rules
-        @rules ||= RuleGroup.new
-      end
-
-      def rule(predicate)
-        rules.add(predicate)
-      end
-
-      def evaluate(subject)
-        rules.evaluate(subject)
-      end
-    end
-  end
-end

data/lib/strategize/policy_group.rb

@@ -1,28 +0,0 @@
-module Strategize
-  class PolicyGroup
-    NotPolicyError = Class.new(RuntimeError)
-
-    def initialize
-      @policies = []
-    end
-
-    def add(policy)
-      raise NotPolicyError unless is_policy(policy)
-      @policies.push(policy)
-    end
-
-    def select(subject)
-      @policies.select { |p| p.evaluate(subject) }
-    end
-
-    def find(subject)
-      self.select(subject).first
-    end
-
-    private
-
-    def is_policy(policy)
-      policy.included_modules.include?(Policy)
-    end
-  end
-end

data/lib/strategize/rule.rb

@@ -1,11 +0,0 @@
-module Strategize
-  class Rule
-    def initialize(predicate)
-      @predicate = predicate
-    end
-
-    def evaluate(subject)
-      subject.instance_exec &@predicate
-    end
-  end
-end

data/lib/strategize/rule_group.rb

@@ -1,16 +0,0 @@
-module Strategize
-  class RuleGroup
-    def initialize
-      @rules = []
-    end
-
-    def add(predicate)
-      predicate = Rule.new(predicate) if predicate.is_a?(Proc)
-      @rules.push(predicate)
-    end
-
-    def evaluate(subject)
-      @rules.all? { |r| r.evaluate(subject) }
-    end
-  end
-end

data/test/policy_group_test.rb

@@ -1,21 +0,0 @@
-require 'test_helper'
-
-class PolicyGroupTest < Minitest::Test
-  def setup
-    @group = Strategize::PolicyGroup.new
-    @group.add(CanDrinkPolicy)
-    @group.add(CanSmokePolicy)
-    @group.add(CanVotePolicy)
-  end
-
-  def test_collection_operations_work
-    subject = OpenStruct.new(age: 19)
-    data = OpenStruct.new(permissions: {})
-
-    policies = @group.select(subject)
-    policies.each { |p| p.process(data) }
-
-    assert_equal true, data.permissions[:can_vote]
-    assert_equal true, data.permissions[:can_smoke]
-  end
-end

data/test/policy_test.rb

@@ -1,13 +0,0 @@
-require 'test_helper'
-
-class PolicyTest < Minitest::Test
-  def test_can_drink_is_valid
-    subject = OpenStruct.new(age: 22)
-    CanDrinkPolicy.evaluate(subject)
-  end
-
-  def test_cannot_drink
-    subject = OpenStruct.new(age: 20)
-    CanDrinkPolicy.evaluate(subject)
-  end
-end

data/test/rule_test.rb

@@ -1,18 +0,0 @@
-require 'test_helper'
-
-class RuleTest < Minitest::Test
-  def test_can_create_rule
-    rule = Strategize::Rule.new(-> { true })
-    assert rule.is_a?(Strategize::Rule)
-  end
-
-  def test_rule_is_valid
-    rule = Strategize::Rule.new(-> { true })
-    assert rule.evaluate(nil)
-  end
-
-  def test_rule_is_not_valid
-    rule = Strategize::Rule.new(-> { false })
-    refute rule.evaluate(nil)
-  end
-end