strategize 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 42524de68454e2ad718b1849668425b46440fbac
-  data.tar.gz: 0191dd00cce17dbc790d18f14646ffa56a43dada
+  metadata.gz: d0c40c7d4e864ff616e141efe128f8a6f8f083cd
+  data.tar.gz: d63ed781fda44b7d40c094f76a8fc11fcda7b2e2
 SHA512:
-  metadata.gz: 6cf723d3e305c0f90fdce8cb878f51bd688477101f20bf82daa3b340e95de8c2146274a592860b6106492bfb1a9fcf9f3586ec27f856645a5d2135aa348e009d
-  data.tar.gz: ac6bd23200464784123842b3c84c7986f90cdfc96fa3b7e597a6ee17e50be42e4cb3b41fa37de51befb9acf2db48e88f3b3de2f46138441127e90fca2d6f1fb8
+  metadata.gz: e58b4dfaffbd76b72bf1a611e94a7fb09d163d8d36050db150f9113bf64d10c718d2d3d530c768cca975d6189da4ba84ff62b5043087eb62dbb9552e341bf47e
+  data.tar.gz: 0b7c23d50adc27568b82ae98034ce230fc57df357bf671bd9f917744a73ab3d35ca3efef31709a31ea1c0420ad8232851666d22107c1370a38e15075e15f6f87

data/lib/strategize.rb

@@ -1,20 +1,54 @@
 module Strategize
   # 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'
+  autoload :Rule,                    'strategize/rules/rule'
+  autoload :RuleGroup,               'strategize/rules/rule_group'
+  autoload :RuleEvaluation,          'strategize/rules/rule_evaluation'
+  autoload :RuleEvaluationDigest,    'strategize/rules/rule_evaluation_digest'
 
   # 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'
+  autoload :Policy,                  'strategize/policies/policy'
+  autoload :PolicyGroup,             'strategize/policies/policy_group'
+  autoload :PolicyEvaluation,        'strategize/policies/policy_evaluation'
+  autoload :PolicyEvaluationDigest,  'strategize/policies/policy_evaluation_digest'
+
+  # Evaluators
+  autoload :RuleEvaluator,           'strategize/evaluators/rule_evaluator'
+  autoload :PolicyEvaluator,         'strategize/evaluators/policy_evaluator'
 
   # Operations
-  autoload :Operation,                  'strategize/operations/operation'
-  autoload :OperationGroup,             'strategize/operations/operation_group'
+  autoload :Operation,               'strategize/operations/operation'
+  autoload :OperationGroup,          'strategize/operations/operation_group'
 
   # Exceptions
-  autoload :NotPolicyError,             'strategize/exceptions'
+  autoload :NotPolicyError,          'strategize/exceptions'
+  autoload :InvalidPredicateError,   'strategize/exceptions'
+  autoload :InvalidFunctionError,    'strategize/exceptions'
+  autoload :InvalidRuleEvaluator,    'strategize/exceptions'
+  autoload :InvalidPolicyEvaluator,  'strategize/exceptions'
+
+  # Configuration
+  autoload :Configuration,           'strategize/configuration'
+
+  class << self
+    # Get the configuration object for Strategize
+    #
+    # @return [Configuration]
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    # Overwrite the current [Configuration] object
+    # with a new [Configuration] instance, which
+    # returns everything to default
+    def reset_configuration
+      @configuration = Configuration.new
+    end
+
+    # Pass a block of code that is executed against the
+    # [Configuration] instance
+    def configure
+      configuration = self.configuration
+      yield(configuration)
+    end
+  end
 end

data/lib/strategize/configuration.rb

@@ -0,0 +1,62 @@
+module Strategize
+  class Configuration
+    attr_reader :rule_evaluator, :policy_evaluator
+
+    # Create a new instance of [Configuration] class.
+    def initialize
+      @rule_evaluator = Strategize::RuleEvaluator
+      @policy_evaluator = Strategize::PolicyEvaluator
+    end
+
+    # Set the default class that is responsible for evaluating
+    # a [Rule]. The class must implement a method named evaluate
+    # that takes a subject and an array of rules.
+    #
+    # @param evaluator [Object] implements evaluate method
+    def rule_evaluator=(evaluator)
+      unless evaluator.new.respond_to?(:evaluate)
+        raise Strategize::InvalidRuleEvaluator, 'no evaluate method found'
+      end
+
+      @rule_evaluator = evaluator
+    end
+
+    # Set the default class that is responsible for evaluating
+    # a [Policy]. The class must implement a method named evaluate
+    # that takes a subject and an array of policies.
+    #
+    # @param evaluator [Object] implements evaluate method
+    def policy_evaluator=(evaluator)
+      unless evaluator.new(rule_evaluator).respond_to?(:evaluate)
+        raise Strategize::InvalidPolicyEvaluator, 'no evaluate method found'
+      end
+
+      @policy_evaluator = evaluator
+    end
+
+    # Get a hash of all the policies groups that have been defined
+    #
+    # @return [Hash]
+    def policy_groups
+      @policy_groups ||= {}
+    end
+
+    # Add a policy group to the policy_groups hash
+    #
+    # @param name [Symbol] a descriptive name for the [PolicyGroup]
+    # @param [Proc] the block of code detailing which [Policy] to add
+    def add_policy_group(name)
+      policy_groups[name] = PolicyGroup.new unless policy_groups.key?(name)
+      policy_group = policy_groups[name]
+      yield(policy_group)
+    end
+
+    # Get a specific [PolicyGroup] that has been defined in [Configuration]
+    #
+    # @param name [Symbol] the name of the policy-group that you want
+    # @return [PolicyGroup]
+    def policy_group(name)
+      policy_groups[name]
+    end
+  end
+end

data/lib/strategize/evaluators/policy_evaluator.rb

@@ -0,0 +1,17 @@
+module Strategize
+  class PolicyEvaluator
+    def initialize(rule_evaluator)
+      @rule_evaluator = rule_evaluator
+    end
+
+    def evaluate(*policies, subject)
+      policies.flatten!
+      results = policies.map do |policy|
+        rules = policy.rule_group.rules
+        rule_digest = @rule_evaluator.evaluate(subject, rules)
+        PolicyEvaluation.new(policy, rule_digest)
+      end
+      PolicyEvaluationDigest.new(results, subject)
+    end
+  end
+end

data/lib/strategize/evaluators/rule_evaluator.rb

@@ -0,0 +1,16 @@
+module Strategize
+  class RuleEvaluator
+    # Given an array of rules, evaluates each rule and returns
+    # the results
+    #
+    # @param rules [Array<Rule>] rules to be evaluated
+    # @param subject [Object] the object to evaluate rules against
+    def evaluate(subject, *rules)
+      rules.flatten!
+      results = rules.map do |rule|
+        RuleEvaluation.new(rule, rule.evaluate(subject))
+      end
+      RuleEvaluationDigest.new(results, subject)
+    end
+  end
+end

data/lib/strategize/exceptions.rb

@@ -1,5 +1,16 @@
 module Strategize
   # Raised when a class does not include
-  # the Stategize::Policy module. 
+  # the Stategize::Policy module.
   NotPolicyError = Class.new(RuntimeError)
+
+  # Raised when an object that does not respond to
+  # call is provided in [Rule] initialization.
+  InvalidPredicateError = Class.new(RuntimeError)
+
+  # Raised when an object that does not respond to
+  # call is provided in [Operation] initialization.
+  InvalidFunctionError = Class.new(RuntimeError)
+
+  InvalidRuleEvaluator = Class.new(RuntimeError)
+  InvalidPolicyEvaluator = Class.new(RuntimeError)
 end

data/lib/strategize/operations/operation.rb

@@ -18,6 +18,10 @@ module Strategize
     # @param function [Proc] the code to be executed
     # @return [Operation]
     def initialize(name, function)
+      unless function.respond_to?(:call)
+        raise InvalidFunctionError, 'Invalid function in Operation'
+      end
+
       @name = name
       @function = function
     end

data/lib/strategize/operations/operation_group.rb

@@ -25,10 +25,8 @@ module Strategize
     # @param subject [Hash] a hash of operation names and subjects
     def run(subjects)
       the_subjects = subjects
+      the_subjects = build_subjects_hash(subjects) unless subjects.is_a?(Hash)
 
-      if !subjects.is_a?(Hash)
-        the_subjects = build_subjects_hash(subjects)
-      end
 
       @operations.each do |operation|
         subject = the_subjects[operation.name]

data/lib/strategize/policies/policy.rb

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

data/lib/strategize/policies/policy_evaluation.rb

@@ -0,0 +1,26 @@
+module Strategize
+  # Provides information on a single policy evaluation.
+  # This includes the policy that was evaluated and
+  # the evaluation digest for the rules defined on
+  # the policy.
+  class PolicyEvaluation
+    attr_reader :policy, :rule_digest
+
+    # Create a new PolicyEvaluation
+    #
+    # @param policy [Policy]
+    # @param rule_result_collection [RuleEvaluationDigest]
+    # @return [PolicyResult]
+    def initialize(policy, rule_digest)
+      @policy = policy
+      @rule_digest = rule_digest
+    end
+
+    # Determine if all the rules defined on the policy
+    # evaluated to true.  
+    # @return [Boolean]
+    def result
+      @rule_digest.result
+    end
+  end
+end

data/lib/strategize/policies/policy_evaluation_digest.rb

@@ -0,0 +1,40 @@
+module Strategize
+  # Represents a container for evaluations performed against each
+  # policy provided in the initializer
+  class PolicyEvaluationDigest
+    # @return [Array<PolicyEvaluation>] the evaluation for each policy
+    attr_reader :evaluations
+
+    # @return [Object] the subject the policy was executed against
+    attr_reader :subject
+
+    # Create a new PolicyEvaluationDigest
+    #
+    # @param evaluations [Array<PolicyEvaluation>]
+    # @param subject [Object] the subject the policies were executed against
+    def initialize(evaluations, subject)
+      @evaluations = evaluations
+      @subject = subject
+    end
+
+    # Return all the policies where all the rules defined on the
+    # policy evaluated to true
+    #
+    # @return [Array<Policy>]
+    def passed
+      @evaluations
+        .select { |evaluation| evaluation.result == true }
+        .map(&:policy)
+    end
+
+    # Return all the policies where one or more rules defined on the
+    # policy evaluated to false.
+    #
+    # @return [Array<Policy>]
+    def failed
+      @evaluations
+        .select { |evaluation| evaluation.result == false }
+        .map(&:policy)
+    end
+  end
+end

data/lib/strategize/policies/policy_group.rb

@@ -1,6 +1,5 @@
 module Strategize
-  # The PolicyGroup allows you to evaluate a subject against
-  # multiple policies.
+  # A collection of policies.
   class PolicyGroup
     attr_reader :policies
 
@@ -18,18 +17,6 @@ module Strategize
       @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

data/lib/strategize/rules/rule.rb

@@ -7,7 +7,7 @@ module Strategize
   #
   # Evaluate a rule
   # rule = Rule.new :rule_name, -> { true }
-  # rule.evaluate(nil) #=> true 
+  # rule.evaluate(nil) #=> true
   class Rule
     attr_reader :name, :predicate
 
@@ -16,6 +16,10 @@ module Strategize
     # @param name [Symbol] a descriptive name for the rule
     # @param predicate [Proc] code block to be executed
     def initialize(name, predicate)
+      unless predicate.respond_to?(:call)
+        raise InvalidPredicateError, 'Invalid predicate function passed'
+      end
+
       @name = name
       @predicate = predicate
     end

data/lib/strategize/rules/rule_evaluation.rb

@@ -0,0 +1,10 @@
+module Strategize
+  class RuleEvaluation
+    attr_reader :rule, :result
+
+    def initialize(rule, result)
+      @rule = rule
+      @result = result
+    end
+  end
+end

data/lib/strategize/rules/rule_evaluation_digest.rb

@@ -0,0 +1,30 @@
+module Strategize
+  class RuleEvaluationDigest
+    attr_reader :evaluations, :subject
+
+    def initialize(evaluations, subject)
+      @evaluations = evaluations
+      @subject = subject
+    end
+
+    def result
+      @evaluations.all?(&:result)
+    end
+
+    def rules
+      @evaluations.map(&:rule)
+    end
+
+    def passed
+      @evaluations
+        .select { |evaluation| evaluation.result == true }
+        .map(&:rule)
+    end
+
+    def failed
+      @evaluations
+        .select { |evaluation| evaluation.result == false }
+        .map(&:rule)
+    end
+  end
+end

data/lib/strategize/rules/rule_group.rb

@@ -1,5 +1,5 @@
 module Strategize
-  # The RuleGroup allows you evaluate multiple rules against one subject.
+  # A wrapper around an array of rules
   class RuleGroup
     attr_reader :rules
 
@@ -10,7 +10,7 @@ module Strategize
       @rules = rules
     end
 
-    # Add [Rule] to be evaluated
+    # Add [Rule] to the group
     #
     # @param name [Symbol] a descriptive name for the rule
     # @param predicate [Lambda] a function that returns true or false
@@ -18,16 +18,8 @@ module Strategize
       @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)
+    def <<(name, predicate)
+      add(name, predicate)
     end
   end
 end

data/test/configuration_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+class ConfigurationTest < Minitest::Test
+  def test_configuration_is_available
+    config = Strategize.configuration
+    refute config.nil?
+  end
+
+  def test_can_configure_from_block
+    Strategize.configure do |config|
+      config.rule_evaluator = TestRuleEvaluator
+    end
+  end
+
+  def test_can_add_policy_group
+    Strategize.configure do |config|
+      config.add_policy_group(:omniauth) do |group|
+        group.add DummyPolicy
+      end
+    end
+
+    refute Strategize.configuration.policy_groups.empty?
+  end
+
+  def test_can_get_policy_group
+    Strategize.configure do |config|
+      config.add_policy_group(:omniauth) do |group|
+        group.add DummyPolicy
+      end
+    end
+
+    policy_group = Strategize.configuration.policy_group(:omniauth)
+    policies = policy_group.policies
+
+    assert policy_group.is_a?(Strategize::PolicyGroup)
+    assert policies.include?(DummyPolicy)
+  end
+
+  def teardown
+    Strategize.reset_configuration
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: strategize
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - jdmorlan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-02 00:00:00.000000000 Z
+date: 2016-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest-reporters
@@ -45,17 +45,21 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/strategize.rb
+- lib/strategize/configuration.rb
+- lib/strategize/evaluators/policy_evaluator.rb
+- lib/strategize/evaluators/rule_evaluator.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_evaluation.rb
+- lib/strategize/policies/policy_evaluation_digest.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_evaluation.rb
+- lib/strategize/rules/rule_evaluation_digest.rb
 - lib/strategize/rules/rule_group.rb
-- lib/strategize/rules/rule_result.rb
-- lib/strategize/rules/rule_result_collection.rb
+- test/configuration_test.rb
 - test/test_helper.rb
 homepage: https://github.com/jdmorlan/strategize
 licenses:
@@ -82,5 +86,5 @@ signing_key:
 specification_version: 4
 summary: Validate rules and perform operations
 test_files:
+- test/configuration_test.rb
 - test/test_helper.rb
-has_rdoc: 

data/lib/strategize/policies/policy_result.rb

@@ -1,33 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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_result.rb

@@ -1,18 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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