rails-patterns 0.7.3 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffa6ee8fff6415c7271eb4a38172148881cdd8866d0279e59abffd452b54f591
-  data.tar.gz: a8e077bf276d9a6a3a05f345d09085561ccb5f06996b7c7a8a01f4082cf329b5
+  metadata.gz: 738d61388a1488705037348a76d42d69b4b92a83cdd6753a2d14d061768302a1
+  data.tar.gz: 9dcc97a76fa682b76ff8910e4146da62eff304c3a7f511343e31d7b8ed222c36
 SHA512:
-  metadata.gz: d4e616146039004e697d7a2b3fc3ef89eaaaaf11779af4744a605d2102b967b8b4b9856147a1b111db5c801fde833ca19c0c5ba067a246977a14c14d7f9c2f54
-  data.tar.gz: 1e883e3cbfc21fc4e7135acc9b23dc4db7e05b2a4671cfe6d618f04b5df4d672c7ac8f76487ae34cce503fd2fdc51e2a0952dffbc66964943c85b8136a0dd509
+  metadata.gz: 9961fcdafa85dca7ef1a91641c4867fa348cdeb20a30abda8e8a91ab3a33c9d3ae456d57a2761615c127bf656b793c8bda94e7cc21371a42bd413e57336babfc
+  data.tar.gz: 7a570f8a7836ff4a3404525d41323697850c46c4dae447512ab517acf036799afd7c14a57028f374a5cea8aa8b489d134e32a3bd8278563039242d33546a8f0a

data/Gemfile.lock

@@ -1,25 +1,25 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    actionpack (6.0.3.1)
-      actionview (= 6.0.3.1)
-      activesupport (= 6.0.3.1)
+    actionpack (6.0.3.2)
+      actionview (= 6.0.3.2)
+      activesupport (= 6.0.3.2)
       rack (~> 2.0, >= 2.0.8)
       rack-test (>= 0.6.3)
       rails-dom-testing (~> 2.0)
       rails-html-sanitizer (~> 1.0, >= 1.2.0)
-    actionview (6.0.3.1)
-      activesupport (= 6.0.3.1)
+    actionview (6.0.3.2)
+      activesupport (= 6.0.3.2)
       builder (~> 3.1)
       erubi (~> 1.4)
       rails-dom-testing (~> 2.0)
       rails-html-sanitizer (~> 1.1, >= 1.2.0)
-    activemodel (6.0.3.1)
-      activesupport (= 6.0.3.1)
-    activerecord (6.0.3.1)
-      activemodel (= 6.0.3.1)
-      activesupport (= 6.0.3.1)
-    activesupport (6.0.3.1)
+    activemodel (6.0.3.2)
+      activesupport (= 6.0.3.2)
+    activerecord (6.0.3.2)
+      activemodel (= 6.0.3.2)
+      activesupport (= 6.0.3.2)
+    activesupport (6.0.3.2)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
@@ -54,7 +54,7 @@ GEM
       oauth2 (~> 1.0)
     hashie (3.6.0)
     highline (2.0.3)
-    i18n (1.8.2)
+    i18n (1.8.3)
       concurrent-ruby (~> 1.0)
     ice_nine (0.11.2)
     juwelier (2.1.3)
@@ -68,7 +68,7 @@ GEM
       rdoc
       semver
     jwt (2.2.1)
-    loofah (2.5.0)
+    loofah (2.6.0)
       crass (~> 1.0.2)
       nokogiri (>= 1.5.9)
     method_source (0.9.0)
@@ -91,7 +91,7 @@ GEM
     pry-rails (0.3.6)
       pry (>= 0.10.4)
     public_suffix (4.0.5)
-    rack (2.2.2)
+    rack (2.2.3)
     rack-test (1.1.0)
       rack (>= 1.0, < 3)
     rails-dom-testing (2.0.3)

data/README.md

@@ -9,6 +9,7 @@ A collection of lightweight, standardized, rails-oriented patterns used by [Ruby
 - [Collection - when in need to add a method that relates to the collection as whole](#collection)
 - [Form - when you need a place for callbacks, want to replace strong parameters or handle virtual/composite resources](#form)
 - [Calculation - when you need a place for calculating a simple value (numeric, array, hash) and/or cache it](#calculation)
+- [Rule and Ruleset - when you need a place for conditional logic](#rule-and-ruleset)
 
 ## Installation
 
@@ -347,6 +348,85 @@ TotalCurrentRevenue.calculate
 AverageDailyRevenue.result
 ```
 
+## Rule and Ruleset
+
+### When to use it
+
+Rule objects provide a place for dislocating/extracting conditional logic.
+
+Use it when:
+- given complex condition is duplicated in multiple places in your codebase
+- part of condition logic can be reused in some other place
+- there is a need to instantiate condition itself for some reason (i.e. to represent it in the interface)
+- responsibility of your class is blurred by complex conditional logic, and as a result...
+- ...tests for your class require multiple condition branches / nested contexts
+
+### Assumptions and rules
+
+* Rule has `#satisfied?`, `#applicable?`, `#not_applicable?` and `#forceable?` methods available.
+* Rule has to implement at least `#satisfied?` method. `#not_applicable?` and `#forceable?` are meant to be overridable.
+* `#forceable?` makes sense in scenario where condition is capable of being force-satisfied regardless if its actually satisfied or not. Is `true` by default.
+* Override `#not_applicable?` when method is applicable only under some specific conditions. Is `false` by default.
+* Rule requires a subject as first argument.
+* Multiple rules and rulesets can be combined into new ruleset as both share same interface and can be used interchangeably (composite pattern).
+
+#### Forcing rules
+
+On some occasions there is a situation in which some condition should be overridable.
+Let's say we may want send shipping notification even though given order was not paid for and under regular circumstances such notification should not be sent.
+In this case, while regular logic with some automated process would not trigger delivery, an action triggered by user from UI could do it, by passing `force: true` option to `#satisified?` methods.
+
+It might be good idea to test for `#forceable?` on the UI level to control visibility of such link/button.
+
+Overriding `#forceable` can be useful to prevent some edge cases, i.e. `ContactInformationProvidedRule` might check if customer for given order has provided any contact means by which a notification could be delivered.
+If not, ruleset containing such rule (and the rule itself) would not be "forceable" and UI could reflect that by querying `#forceable?`.
+
+#### Regular and strong rulesets
+
+While regular `Ruleset` can be satisfied or forced if any of its rules in not applicable, the
+`StrongRuleset` is not satisfied and not "forceable" if any of its rules is not applicable.
+
+#### `#not_applicable?` vs `#applicable?`
+
+It might be surprising that is is the negated version of the `#applicable?` predicate methods that is overridable.
+However, from the actual usage perspective, it usually easier to conceptually define when condition makes no sense than other way around.
+
+### Examples
+
+#### Declaration
+
+```ruby
+class OrderIsSentRule < Rule
+  def satisfied?
+    subject.sent?
+  end
+end
+
+class OrderIsPaidRule < Rule
+  def satisfied?
+    subject.paid?
+  end
+
+  def forceable?
+    true
+  end
+end
+
+OrderCompletedNotificationRuleset = Class.new(Ruleset)
+OrderCompletedNotificationRuleset.
+  add_rule(:order_is_sent_rule).
+  add_rule(:order_is_paid_rule)
+```
+
+#### Usage
+
+```ruby
+OrderIsPaidRule.new(order).satisfied?
+OrderCompletedNotificationRuleset.new(order).satisfied?
+
+ResendOrderNotification.call(order) if OrderCompletedNotificationRuleset.new(order).satisfied?(force: true)
+```
+
 ## Further reading
 
 * [7 ways to decompose fat active record models](http://blog.codeclimate.com/blog/2012/10/17/7-ways-to-decompose-fat-activerecord-models/)

data/VERSION

@@ -1 +1 @@
-0.7.3
+0.8.0

data/lib/patterns/rule.rb

@@ -0,0 +1,25 @@
+class Rule
+  def initialize(subject)
+    @subject = subject
+  end
+
+  def satisfied?
+    raise NotImplementedError
+  end
+
+  def not_applicable?
+    false
+  end
+
+  def applicable?
+    !not_applicable?
+  end
+
+  def forceable?
+    true
+  end
+
+  private
+
+  attr_reader :subject
+end

data/lib/patterns/ruleset.rb

@@ -0,0 +1,69 @@
+class Ruleset
+  class EmptyRuleset < StandardError; end
+
+  class << self
+    attr_accessor :rule_names
+  end
+
+  def self.rules
+    (rule_names || []).map do |rule_name|
+      rule_name.to_s.classify.constantize
+    end
+  end
+
+  def self.add_rule(rule_name)
+    self.rule_names ||= []
+    self.rule_names << rule_name.to_sym
+    self
+  end
+
+  def initialize(subject = nil)
+    raise EmptyRuleset if self.class.rules.empty?
+
+    @rules = self.class.rules.map { |rule| rule.new(subject) }
+  end
+
+  def satisfied?(force: false)
+    rules.all? do |rule|
+      rule.satisfied? ||
+        rule.not_applicable? ||
+        (force && rule.forceable?)
+    end
+  end
+
+  def not_satisfied?
+    !satisfied?
+  end
+
+  def applicable?
+    !not_applicable?
+  end
+
+  def not_applicable?
+    rules.all?(&:not_applicable?)
+  end
+
+  def forceable?
+    rules.all? do |rule|
+      rule.forceable? ||
+        rule.not_applicable? ||
+        rule.satisfied?
+    end
+  end
+
+  def each(&block)
+    return enum_for(:each) unless block_given?
+
+    rules.each do |rule_or_ruleset|
+      if rule_or_ruleset.is_a?(Ruleset)
+        rule_or_ruleset.each(&block)
+      else
+        yield rule_or_ruleset
+      end
+    end
+  end
+
+  private
+
+  attr_reader :rules
+end

data/lib/patterns/strong_ruleset.rb

@@ -0,0 +1,19 @@
+# StrongRuleset is not satisfied and not forceable if any of rules is not applicable
+
+class StrongRuleset < Ruleset
+  def satisfied?(force: false)
+    rules.all? do |rule|
+      (rule.applicable? && rule.satisfied?) || (force && rule.forceable?)
+    end
+  end
+
+  def not_applicable?
+    rules.any?(&:not_applicable?)
+  end
+
+  def forceable?
+    rules.all? do |rule|
+      (rule.applicable? && rule.forceable?) || rule.satisfied?
+    end
+  end
+end

data/lib/rails-patterns.rb

@@ -4,3 +4,6 @@ require "patterns/service"
 require "patterns/collection"
 require "patterns/calculation"
 require "patterns/form"
+require "patterns/rule"
+require "patterns/ruleset"
+require "patterns/strong_ruleset"

data/rails-patterns.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Juwelier::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: rails-patterns 0.7.3 ruby lib
+# stub: rails-patterns 0.8.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "rails-patterns".freeze
-  s.version = "0.7.3"
+  s.version = "0.8.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Stevo".freeze]
-  s.date = "2020-06-12"
+  s.date = "2020-09-01"
   s.description = "A collection of lightweight, standardized, rails-oriented patterns.".freeze
   s.email = "b.kosmowski@selleo.com".freeze
   s.extra_rdoc_files = [
@@ -33,7 +33,10 @@ Gem::Specification.new do |s|
     "lib/patterns/collection.rb",
     "lib/patterns/form.rb",
     "lib/patterns/query.rb",
+    "lib/patterns/rule.rb",
+    "lib/patterns/ruleset.rb",
     "lib/patterns/service.rb",
+    "lib/patterns/strong_ruleset.rb",
     "lib/rails-patterns.rb",
     "rails-patterns.gemspec",
     "spec/helpers/custom_calculation.rb",
@@ -43,35 +46,30 @@ Gem::Specification.new do |s|
     "spec/patterns/collection_spec.rb",
     "spec/patterns/form_spec.rb",
     "spec/patterns/query_spec.rb",
+    "spec/patterns/rule_spec.rb",
+    "spec/patterns/ruleset_spec.rb",
     "spec/patterns/service_spec.rb",
+    "spec/patterns/strong_ruleset_spec.rb",
     "spec/spec_helper.rb"
   ]
   s.homepage = "http://github.com/selleo/pattern".freeze
   s.licenses = ["MIT".freeze]
   s.required_ruby_version = Gem::Requirement.new(">= 2.5.0".freeze)
-  s.rubygems_version = "2.7.6.2".freeze
+  s.rubygems_version = "3.1.2".freeze
   s.summary = "A collection of lightweight, standardized, rails-oriented patterns.".freeze
 
   if s.respond_to? :specification_version then
     s.specification_version = 4
+  end
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activerecord>.freeze, [">= 4.2.6"])
-      s.add_runtime_dependency(%q<actionpack>.freeze, [">= 4.2.6"])
-      s.add_runtime_dependency(%q<virtus>.freeze, [">= 0"])
-      s.add_runtime_dependency(%q<ruby2_keywords>.freeze, [">= 0"])
-      s.add_development_dependency(%q<rspec>.freeze, [">= 0"])
-      s.add_development_dependency(%q<bundler>.freeze, ["~> 2.0"])
-      s.add_development_dependency(%q<juwelier>.freeze, ["~> 2.1.0"])
-    else
-      s.add_dependency(%q<activerecord>.freeze, [">= 4.2.6"])
-      s.add_dependency(%q<actionpack>.freeze, [">= 4.2.6"])
-      s.add_dependency(%q<virtus>.freeze, [">= 0"])
-      s.add_dependency(%q<ruby2_keywords>.freeze, [">= 0"])
-      s.add_dependency(%q<rspec>.freeze, [">= 0"])
-      s.add_dependency(%q<bundler>.freeze, ["~> 2.0"])
-      s.add_dependency(%q<juwelier>.freeze, ["~> 2.1.0"])
-    end
+  if s.respond_to? :add_runtime_dependency then
+    s.add_runtime_dependency(%q<activerecord>.freeze, [">= 4.2.6"])
+    s.add_runtime_dependency(%q<actionpack>.freeze, [">= 4.2.6"])
+    s.add_runtime_dependency(%q<virtus>.freeze, [">= 0"])
+    s.add_runtime_dependency(%q<ruby2_keywords>.freeze, [">= 0"])
+    s.add_development_dependency(%q<rspec>.freeze, [">= 0"])
+    s.add_development_dependency(%q<bundler>.freeze, ["~> 2.0"])
+    s.add_development_dependency(%q<juwelier>.freeze, ["~> 2.1.0"])
   else
     s.add_dependency(%q<activerecord>.freeze, [">= 4.2.6"])
     s.add_dependency(%q<actionpack>.freeze, [">= 4.2.6"])

data/spec/patterns/rule_spec.rb

@@ -0,0 +1,44 @@
+RSpec.describe Rule do
+  after(:each) do
+    Object.send(:remove_const, :CustomRule) if defined?(CustomRule)
+  end
+
+  it 'requires subject as the first argument' do
+    CustomRule = Class.new(Rule)
+
+    expect { CustomRule.new }.to raise_error ArgumentError
+    expect { CustomRule.new(Object.new) }.not_to raise_error
+  end
+
+  it 'requires #satisfied? method to be defined' do
+    InvalidCustomRule = Class.new(Rule)
+    CustomRule = Class.new(Rule) do
+      def satisfied?
+        true
+      end
+    end
+
+    expect { InvalidCustomRule.new(Object.new).satisfied? }.to raise_error NotImplementedError
+    expect { CustomRule.new(Object.new).satisfied? }.not_to raise_error
+  end
+
+  describe '#satisfied?' do
+    context 'when subject meets the conditions' do
+      it 'returns true' do
+        article = OpenStruct.new('published?' => true, 'deleted?' => false)
+
+        ArticleIsPublishedRule = Class.new(Rule) do
+          def satisfied?
+            subject.published?
+          end
+
+          def not_applicable?
+            subject.deleted?
+          end
+        end
+
+        expect(ArticleIsPublishedRule.new(article).satisfied?).to eq true
+      end
+    end
+  end
+end

data/spec/patterns/ruleset_spec.rb

@@ -0,0 +1,260 @@
+RSpec.describe Ruleset do
+  context 'when empty ruleset is initialized' do
+    it 'raises an error' do
+      empty_ruleset_klass = Class.new(Ruleset)
+      custom_ruleset_klass = Class.new(Ruleset)
+      subject = double
+
+      with_mocked_rules do |rules|
+        rules << mock_rule(:rule_1)
+        custom_ruleset_klass.add_rule(:rule_1)
+
+        expect { custom_ruleset_klass.new(subject) }.not_to raise_error
+      end
+
+      expect { empty_ruleset_klass.new(subject) }.to raise_error Ruleset::EmptyRuleset
+    end
+  end
+
+  describe '#forceable?' do
+    context 'all rules are forceable' do
+      it 'returns true' do
+        with_mocked_rules do |rules|
+          subject = double
+          rules << mock_rule(:rule_1, is_forceable: true)
+          rules << mock_rule(:rule_2, is_forceable: true)
+
+          custom_ruleset_klass = Class.new(Ruleset)
+          custom_ruleset_klass.add_rule(:rule_1)
+          custom_ruleset_klass.add_rule(:rule_2)
+
+          expect(custom_ruleset_klass.new(subject).forceable?).to eq true
+        end
+      end
+    end
+
+    context 'at least one rule is not forceable' do
+      it 'returns false' do
+        with_mocked_rules do |rules|
+          subject = double
+          rules << mock_rule(:rule_1, is_forceable: false, is_satisfied: false, is_applicable: true)
+          rules << mock_rule(:rule_2, is_forceable: true)
+
+          custom_ruleset_klass = Class.new(Ruleset)
+          custom_ruleset_klass.add_rule(:rule_1)
+          custom_ruleset_klass.add_rule(:rule_2)
+
+          expect(custom_ruleset_klass.new(subject).forceable?).to eq false
+        end
+      end
+
+      context 'and rule is satisfied' do
+        it 'returns true' do
+          with_mocked_rules do |rules|
+            subject = double
+            rules << mock_rule(
+              :rule_1,
+              is_forceable: false,
+              is_satisfied: true,
+              is_applicable: true
+            )
+            rules << mock_rule(:rule_2, is_forceable: true)
+
+            custom_ruleset_klass = Class.new(Ruleset)
+            custom_ruleset_klass.add_rule(:rule_1)
+            custom_ruleset_klass.add_rule(:rule_2)
+
+            expect(custom_ruleset_klass.new(subject).forceable?).to eq true
+          end
+        end
+      end
+
+      context 'and rule is not applicable' do
+        it 'returns true' do
+          with_mocked_rules do |rules|
+            subject = double
+            rules << mock_rule(
+              :rule_1,
+              is_forceable: false,
+              is_satisfied: false,
+              is_applicable: false
+            )
+            rules << mock_rule(:rule_2, is_forceable: true)
+
+            custom_ruleset_klass = Class.new(Ruleset)
+            custom_ruleset_klass.add_rule(:rule_1)
+            custom_ruleset_klass.add_rule(:rule_2)
+
+            expect(custom_ruleset_klass.new(subject).forceable?).to eq true
+          end
+        end
+      end
+    end
+  end
+
+  describe '#not_applicable?' do
+    context 'all rules are not applicable' do
+      it 'returns true' do
+        with_mocked_rules do |rules|
+          subject = double
+          rules << mock_rule(:rule_1, is_applicable: false)
+          rules << mock_rule(:rule_2, is_applicable: false)
+
+          custom_ruleset_klass = Class.new(Ruleset)
+          custom_ruleset_klass.add_rule(:rule_1)
+          custom_ruleset_klass.add_rule(:rule_2)
+
+          expect(custom_ruleset_klass.new(subject).not_applicable?).to eq true
+        end
+      end
+    end
+
+    context 'at least one rule is applicable' do
+      it 'returns false' do
+        with_mocked_rules do |rules|
+          subject = double
+          rules << mock_rule(:rule_1, is_applicable: false)
+          rules << mock_rule(:rule_2, is_applicable: true)
+
+          custom_ruleset_klass = Class.new(Ruleset)
+          custom_ruleset_klass.add_rule(:rule_1)
+          custom_ruleset_klass.add_rule(:rule_2)
+
+          expect(custom_ruleset_klass.new(subject).not_applicable?).to eq false
+        end
+      end
+    end
+  end
+
+  describe '#satisfied?' do
+    context 'all rules are satisfied' do
+      it 'returns true' do
+        with_mocked_rules do |rules|
+          subject = double
+          rules << mock_rule(:rule_1)
+          rules << mock_rule(:rule_2)
+
+          custom_ruleset_klass = Class.new(Ruleset)
+          custom_ruleset_klass.add_rule(:rule_1)
+          custom_ruleset_klass.add_rule(:rule_2)
+
+          expect(custom_ruleset_klass.new(subject).satisfied?).to eq true
+        end
+      end
+    end
+
+    context 'at least one rule is not satisfied' do
+      it 'returns false' do
+        with_mocked_rules do |rules|
+          subject = double
+          rules << mock_rule(:rule_1)
+          rules << mock_rule(:rule_2, is_satisfied: false)
+
+          custom_ruleset_klass = Class.new(Ruleset)
+          custom_ruleset_klass.add_rule(:rule_1)
+          custom_ruleset_klass.add_rule(:rule_2)
+
+          expect(custom_ruleset_klass.new(subject).satisfied?).to eq false
+        end
+      end
+
+      context 'when rule is not applicable' do
+        it 'returns true' do
+          with_mocked_rules do |rules|
+            subject = double
+            rules << mock_rule(:rule_1)
+            rules << mock_rule(:rule_2, is_satisfied: false, is_applicable: false)
+
+            custom_ruleset_klass = Class.new(Ruleset)
+            custom_ruleset_klass.add_rule(:rule_1)
+            custom_ruleset_klass.add_rule(:rule_2)
+
+            expect(custom_ruleset_klass.new(subject).satisfied?).to eq true
+          end
+        end
+      end
+
+      context 'when provided with force: true' do
+        context 'when rule is forceable' do
+          it 'returns true' do
+            with_mocked_rules do |rules|
+              subject = double
+              rules << mock_rule(:rule_1)
+              rules << mock_rule(:rule_2, is_satisfied: false, is_forceable: true)
+
+              custom_ruleset_klass = Class.new(Ruleset)
+              custom_ruleset_klass.add_rule(:rule_1)
+              custom_ruleset_klass.add_rule(:rule_2)
+
+              expect(custom_ruleset_klass.new(subject).satisfied?(force: true)).to eq true
+            end
+          end
+        end
+
+        context 'when rule is not forceable' do
+          it 'returns false' do
+            with_mocked_rules do |rules|
+              subject = double
+              rules << mock_rule(:rule_1)
+              rules << mock_rule(:rule_2, is_satisfied: false, is_forceable: false)
+
+              custom_ruleset_klass = Class.new(Ruleset)
+              custom_ruleset_klass.add_rule(:rule_1)
+              custom_ruleset_klass.add_rule(:rule_2)
+
+              expect(custom_ruleset_klass.new(subject).satisfied?(force: true)).to eq false
+            end
+          end
+        end
+      end
+    end
+  end
+
+  describe '#each' do
+    it 'yields all rules for ruleset' do
+      with_mocked_rules do |rules|
+        rules << (_, rule_1 = mock_rule(:rule_1))
+        rules << (_, rule_2 = mock_rule(:rule_2))
+        rules << (_, rule_3 = mock_rule(:rule_3))
+        custom_ruleset_klass_1 = Class.new(Ruleset)
+        custom_ruleset_klass_1.add_rule(:rule_1)
+        custom_ruleset_klass_1.add_rule(:rule_2)
+        Ruleset2 = Class.new(Ruleset)
+        Ruleset2.add_rule(:rule_3)
+        custom_ruleset_klass_1.add_rule(:ruleset_2)
+
+        ruleset = custom_ruleset_klass_1.new(double)
+
+        expect { |b| ruleset.each(&b) }.to yield_successive_args(rule_1, rule_2, rule_3)
+      ensure
+        remove_class(Ruleset2)
+      end
+    end
+  end
+
+  private
+
+  def mock_rule(rule_name, is_applicable: true, is_satisfied: true, is_forceable: true)
+    klass = Object.const_set(rule_name.to_s.classify, Class.new(Rule))
+    rule = double(
+      not_applicable?: !is_applicable,
+      satisfied?: is_satisfied,
+      forceable?: is_forceable
+    )
+    allow(klass).to receive(:new).with(anything) { rule }
+    [klass, rule]
+  end
+
+  def with_mocked_rules
+    rules_storage = []
+    yield rules_storage
+  ensure
+    rules_storage.each do |rule_klass, _rule_instance|
+      remove_class(rule_klass)
+    end
+  end
+
+  def remove_class(klass)
+    Object.send(:remove_const, klass.name.to_sym)
+  end
+end

data/spec/patterns/strong_ruleset_spec.rb

@@ -0,0 +1,79 @@
+RSpec.describe StrongRuleset do
+  it 'inherites from Ruleset' do
+    custom_strong_ruleset_klass = Class.new(StrongRuleset)
+    expect(custom_strong_ruleset_klass.ancestors).to include Ruleset
+  end
+
+  context 'when any of rules is not applicable' do
+    it 'is not satisfied' do
+      with_mocked_rules do |rules|
+        subject = double
+        rules << mock_rule(:rule_1, is_applicable: false)
+        rules << mock_rule(:rule_2)
+
+        custom_ruleset_klass = Class.new(StrongRuleset)
+        custom_ruleset_klass.add_rule(:rule_1)
+        custom_ruleset_klass.add_rule(:rule_2)
+
+        expect(custom_ruleset_klass.new(subject).satisfied?).to eq false
+      end
+    end
+
+    context 'when not applicable rule is not satisfied' do
+      it 'is not forceable' do
+        with_mocked_rules do |rules|
+          subject = double
+          rules << mock_rule(:rule_1, is_applicable: false, is_satisfied: false)
+          rules << mock_rule(:rule_2)
+
+          custom_ruleset_klass = Class.new(StrongRuleset)
+          custom_ruleset_klass.add_rule(:rule_1)
+          custom_ruleset_klass.add_rule(:rule_2)
+
+          expect(custom_ruleset_klass.new(subject).forceable?).to eq false
+        end
+      end
+    end
+
+    it 'is not applicable' do
+      with_mocked_rules do |rules|
+        subject = double
+        rules << mock_rule(:rule_1, is_applicable: false)
+        rules << mock_rule(:rule_2)
+
+        custom_ruleset_klass = Class.new(StrongRuleset)
+        custom_ruleset_klass.add_rule(:rule_1)
+        custom_ruleset_klass.add_rule(:rule_2)
+
+        expect(custom_ruleset_klass.new(subject).applicable?).to eq false
+      end
+    end
+  end
+
+  private
+
+  def mock_rule(rule_name, is_applicable: true, is_satisfied: true, is_forceable: true)
+    klass = Object.const_set(rule_name.to_s.classify, Class.new(Rule))
+    rule = double(
+      not_applicable?: !is_applicable,
+      applicable?: is_applicable,
+      satisfied?: is_satisfied,
+      forceable?: is_forceable
+    )
+    allow(klass).to receive(:new).with(anything) { rule }
+    [klass, rule]
+  end
+
+  def with_mocked_rules
+    rules_storage = []
+    yield rules_storage
+  ensure
+    rules_storage.each do |rule_klass, _rule_instance|
+      remove_class(rule_klass)
+    end
+  end
+
+  def remove_class(klass)
+    Object.send(:remove_const, klass.name.to_sym)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rails-patterns
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.8.0
 platform: ruby
 authors:
 - Stevo
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-12 00:00:00.000000000 Z
+date: 2020-09-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -130,7 +130,10 @@ files:
 - lib/patterns/collection.rb
 - lib/patterns/form.rb
 - lib/patterns/query.rb
+- lib/patterns/rule.rb
+- lib/patterns/ruleset.rb
 - lib/patterns/service.rb
+- lib/patterns/strong_ruleset.rb
 - lib/rails-patterns.rb
 - rails-patterns.gemspec
 - spec/helpers/custom_calculation.rb
@@ -140,13 +143,16 @@ files:
 - spec/patterns/collection_spec.rb
 - spec/patterns/form_spec.rb
 - spec/patterns/query_spec.rb
+- spec/patterns/rule_spec.rb
+- spec/patterns/ruleset_spec.rb
 - spec/patterns/service_spec.rb
+- spec/patterns/strong_ruleset_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/selleo/pattern
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -161,9 +167,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6.2
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: A collection of lightweight, standardized, rails-oriented patterns.
 test_files: []