rails-patterns 0.7.3 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffa6ee8fff6415c7271eb4a38172148881cdd8866d0279e59abffd452b54f591
-  data.tar.gz: a8e077bf276d9a6a3a05f345d09085561ccb5f06996b7c7a8a01f4082cf329b5
+  metadata.gz: bbe1da3d0914915666930f116e9d74b0c20cd5f75184f3d4e5304231fdb98784
+  data.tar.gz: 60f796148cfcb353aa5071936ecf9203bd8895183feccc14a80baaa31705eeef
 SHA512:
-  metadata.gz: d4e616146039004e697d7a2b3fc3ef89eaaaaf11779af4744a605d2102b967b8b4b9856147a1b111db5c801fde833ca19c0c5ba067a246977a14c14d7f9c2f54
-  data.tar.gz: 1e883e3cbfc21fc4e7135acc9b23dc4db7e05b2a4671cfe6d618f04b5df4d672c7ac8f76487ae34cce503fd2fdc51e2a0952dffbc66964943c85b8136a0dd509
+  metadata.gz: 4c53d800f009d26c834a88d672a6f6461cd88d16b3e13d086d1da40d20c88e6f457a878f40b297a22ffab921081863f6c29002b032fefb02d8fd890ba7a51f69
+  data.tar.gz: e3a6563d3a5e6c081491be1e4d2839d6d5a7f17d5f5af2980ffac2732fc9cd15bd00976ca68f99322e3d6ba559d70bbab56c2168880dc89c03ed29f1c39511e5

data/Gemfile

@@ -11,7 +11,7 @@ gem "ruby2_keywords"
 group :development do
   gem "rspec"
   gem "bundler", "~> 2.0"
-  gem "juwelier", "~> 2.1.0"
+  gem "juwelier"
 end
 
 group "test" do

data/Gemfile.lock

@@ -1,134 +1,156 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    actionpack (6.0.3.1)
-      actionview (= 6.0.3.1)
-      activesupport (= 6.0.3.1)
-      rack (~> 2.0, >= 2.0.8)
+    actionpack (6.1.4.1)
+      actionview (= 6.1.4.1)
+      activesupport (= 6.1.4.1)
+      rack (~> 2.0, >= 2.0.9)
       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.1.4.1)
+      activesupport (= 6.1.4.1)
       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.1.4.1)
+      activesupport (= 6.1.4.1)
+    activerecord (6.1.4.1)
+      activemodel (= 6.1.4.1)
+      activesupport (= 6.1.4.1)
+    activesupport (6.1.4.1)
       concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-      zeitwerk (~> 2.2, >= 2.2.2)
-    addressable (2.7.0)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    addressable (2.8.0)
       public_suffix (>= 2.0.2, < 5.0)
     axiom-types (0.1.1)
       descendants_tracker (~> 0.0.4)
       ice_nine (~> 0.11.0)
       thread_safe (~> 0.3, >= 0.3.1)
     builder (3.2.4)
-    coderay (1.1.2)
+    coderay (1.1.3)
     coercible (1.0.0)
       descendants_tracker (~> 0.0.1)
-    concurrent-ruby (1.1.6)
+    concurrent-ruby (1.1.9)
     crass (1.0.6)
     descendants_tracker (0.0.4)
       thread_safe (~> 0.3, >= 0.3.1)
-    diff-lcs (1.3)
-    equalizer (0.0.11)
-    erubi (1.9.0)
-    faraday (0.17.3)
+    diff-lcs (1.4.4)
+    erubi (1.10.0)
+    faraday (1.8.0)
+      faraday-em_http (~> 1.0)
+      faraday-em_synchrony (~> 1.0)
+      faraday-excon (~> 1.1)
+      faraday-httpclient (~> 1.0.1)
+      faraday-net_http (~> 1.0)
+      faraday-net_http_persistent (~> 1.1)
+      faraday-patron (~> 1.0)
+      faraday-rack (~> 1.0)
       multipart-post (>= 1.2, < 3)
-    git (1.7.0)
+      ruby2_keywords (>= 0.0.4)
+    faraday-em_http (1.0.0)
+    faraday-em_synchrony (1.0.0)
+    faraday-excon (1.1.0)
+    faraday-httpclient (1.0.1)
+    faraday-net_http (1.0.1)
+    faraday-net_http_persistent (1.2.0)
+    faraday-patron (1.0.0)
+    faraday-rack (1.0.0)
+    git (1.9.1)
       rchardet (~> 1.8)
-    github_api (0.18.2)
+    github_api (0.19.0)
       addressable (~> 2.4)
       descendants_tracker (~> 0.0.4)
-      faraday (~> 0.8)
+      faraday (>= 0.8, < 2)
       hashie (~> 3.5, >= 3.5.2)
       oauth2 (~> 1.0)
     hashie (3.6.0)
     highline (2.0.3)
-    i18n (1.8.2)
+    i18n (1.8.11)
       concurrent-ruby (~> 1.0)
     ice_nine (0.11.2)
-    juwelier (2.1.3)
+    juwelier (2.4.9)
       builder
-      bundler (>= 1.13)
-      git (>= 1.2.5)
+      bundler
+      git
       github_api
-      highline (>= 1.6.15)
-      nokogiri (>= 1.5.10)
+      highline
+      kamelcase (~> 0)
+      nokogiri
+      psych
       rake
       rdoc
-      semver
-    jwt (2.2.1)
-    loofah (2.5.0)
+      semver2
+    jwt (2.3.0)
+    kamelcase (0.0.2)
+      semver2 (~> 3)
+    loofah (2.13.0)
       crass (~> 1.0.2)
       nokogiri (>= 1.5.9)
-    method_source (0.9.0)
-    mini_portile2 (2.4.0)
-    minitest (5.14.1)
-    multi_json (1.14.1)
+    method_source (1.0.0)
+    mini_portile2 (2.6.1)
+    minitest (5.14.4)
+    multi_json (1.15.0)
     multi_xml (0.6.0)
     multipart-post (2.1.1)
-    nokogiri (1.10.9)
-      mini_portile2 (~> 2.4.0)
-    oauth2 (1.4.4)
+    nokogiri (1.12.5)
+      mini_portile2 (~> 2.6.1)
+      racc (~> 1.4)
+    oauth2 (1.4.7)
       faraday (>= 0.8, < 2.0)
       jwt (>= 1.0, < 3.0)
       multi_json (~> 1.3)
       multi_xml (~> 0.5)
       rack (>= 1.2, < 3)
-    pry (0.11.3)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
-    pry-rails (0.3.6)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-rails (0.3.9)
       pry (>= 0.10.4)
-    public_suffix (4.0.5)
-    rack (2.2.2)
+    psych (4.0.2)
+    public_suffix (4.0.6)
+    racc (1.6.0)
+    rack (2.2.3)
     rack-test (1.1.0)
       rack (>= 1.0, < 3)
     rails-dom-testing (2.0.3)
       activesupport (>= 4.2.0)
       nokogiri (>= 1.6)
-    rails-html-sanitizer (1.3.0)
+    rails-html-sanitizer (1.4.2)
       loofah (~> 2.3)
-    rake (13.0.1)
+    rake (13.0.6)
     rchardet (1.8.0)
-    rdoc (6.2.1)
-    redis (4.1.4)
-    rspec (3.7.0)
-      rspec-core (~> 3.7.0)
-      rspec-expectations (~> 3.7.0)
-      rspec-mocks (~> 3.7.0)
-    rspec-core (3.7.1)
-      rspec-support (~> 3.7.0)
-    rspec-expectations (3.7.0)
+    rdoc (6.3.3)
+    redis (4.5.1)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.7.0)
-    rspec-mocks (3.7.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.2)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.7.0)
-    rspec-support (3.7.1)
-    rspec_junit_formatter (0.3.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.3)
+    rspec_junit_formatter (0.4.1)
       rspec-core (>= 2, < 4, != 2.12.0)
-    ruby2_keywords (0.0.2)
-    semver (1.0.1)
+    ruby2_keywords (0.0.5)
+    semver2 (3.4.2)
     thread_safe (0.3.6)
-    tzinfo (1.2.7)
-      thread_safe (~> 0.1)
-    virtus (1.0.5)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    virtus (2.0.0)
       axiom-types (~> 0.1)
       coercible (~> 1.0)
       descendants_tracker (~> 0.0, >= 0.0.3)
-      equalizer (~> 0.0, >= 0.0.9)
-    zeitwerk (2.3.0)
+    zeitwerk (2.5.1)
 
 PLATFORMS
   ruby
@@ -137,7 +159,7 @@ DEPENDENCIES
   actionpack (>= 4.2.6)
   activerecord (>= 4.2.6)
   bundler (~> 2.0)
-  juwelier (~> 2.1.0)
+  juwelier
   pry-rails
   redis
   rspec

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
 
@@ -23,11 +24,11 @@ gem "rails-patterns"
 Then `bundle install`
 
 ## Query
- 
+
 ### When to use it
 
-One should consider using query objects pattern when in need to perform complex querying on active record relation. 
-Usually one should avoid using scopes for such purpose. 
+One should consider using query objects pattern when in need to perform complex querying on active record relation.
+Usually one should avoid using scopes for such purpose.
 As a rule of thumb, if scope interacts with more than one column and/or joins in other tables, it should be moved to query object.
 Also whenever a chain of scopes is to be used, one should consider using query object too.
 Some more information on using query objects can be found in [this article](https://medium.com/@blazejkosmowski/essential-rubyonrails-patterns-part-2-query-objects-4b253f4f4539).
@@ -97,9 +98,9 @@ Service objects are also useful for handling processes involving multiple steps.
 * It is recommended for `#call` method to be the only public method of service object (besides state readers)
 * It is recommended to name service object classes after commands (e.g. `ActivateUser` instead of `UserActivation`)
 
-### Other 
+### Other
 
-A bit higher level of abstraction is provided by [business_process gem](https://github.com/Selleo/business_process). 
+A bit higher level of abstraction is provided by [business_process gem](https://github.com/Selleo/business_process).
 
 ### Examples
 
@@ -347,6 +348,94 @@ 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).
+* By default empty ruleset is satisfied.
+
+#### 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 < Patterns::Rule
+  def satisfied?
+    subject.sent?
+  end
+end
+
+class OrderIsPaidRule < Patterns::Rule
+  def satisfied?
+    subject.paid?
+  end
+
+  def forceable?
+    true
+  end
+end
+
+OrderCompletedNotificationRuleset = Class.new(Patterns::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/)
+
+## About Selleo
+
+![selleo](https://raw.githubusercontent.com/Selleo/selleo-resources/master/public/github_footer.png)
+
+Software development teams with an entrepreneurial sense of ownership at their core delivering great digital products and building culture people want to belong to. We are a community of engaged co-workers passionate about crafting impactful web solutions which transform the way our clients do business.
+
+All names and logos for [Selleo](https://selleo.com/about) are trademark of Selleo Labs Sp. z o.o. (formerly Selleo Sp. z o.o. Sp.k.)

data/VERSION

@@ -1 +1 @@
-0.7.3
+0.11.0

data/lib/patterns/calculation.rb

@@ -9,8 +9,8 @@ module Patterns
       @subject = args.first
     end
 
-    def self.result(*args)
-      new(*args).cached_result
+    def self.result(*args, &block)
+      new(*args).cached_result(&block)
     end
 
     class << self
@@ -22,12 +22,12 @@ module Patterns
       self.cache_expiry_every = period
     end
 
-    def cached_result
+    def cached_result(&block)
       if cache_expiry_period.blank?
-        result
+        result(&block)
       else
         Rails.cache.fetch(cache_key, expires_in: cache_expiry_period) do
-          result
+          result(&block)
         end
       end
     end

data/lib/patterns/rule.rb

@@ -0,0 +1,27 @@
+module Patterns
+  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
+end

data/lib/patterns/ruleset.rb

@@ -0,0 +1,67 @@
+module Patterns
+  class Ruleset
+    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)
+      @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
+end

data/lib/patterns/strong_ruleset.rb

@@ -0,0 +1,21 @@
+# StrongRuleset is not satisfied and not forceable if any of rules is not applicable
+
+module Patterns
+  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
+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.11.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "rails-patterns".freeze
-  s.version = "0.7.3"
+  s.version = "0.11.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 = "2022-02-09"
   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,13 +46,16 @@ 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.0.8".freeze
   s.summary = "A collection of lightweight, standardized, rails-oriented patterns.".freeze
 
   if s.respond_to? :specification_version then
@@ -62,7 +68,7 @@ Gem::Specification.new do |s|
       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"])
+      s.add_development_dependency(%q<juwelier>.freeze, [">= 0"])
     else
       s.add_dependency(%q<activerecord>.freeze, [">= 4.2.6"])
       s.add_dependency(%q<actionpack>.freeze, [">= 4.2.6"])
@@ -70,7 +76,7 @@ Gem::Specification.new do |s|
       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"])
+      s.add_dependency(%q<juwelier>.freeze, [">= 0"])
     end
   else
     s.add_dependency(%q<activerecord>.freeze, [">= 4.2.6"])
@@ -79,7 +85,7 @@ Gem::Specification.new do |s|
     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"])
+    s.add_dependency(%q<juwelier>.freeze, [">= 0"])
   end
 end
 

data/spec/patterns/calculation_spec.rb

@@ -60,6 +60,18 @@ RSpec.describe Patterns::Calculation do
 
       expect(CustomCalculation.result(nil, arg_1: 20, arg_2: 30)).to eq([20, 30])
     end
+
+    it 'executes calculation with given block' do
+      CustomCalculation = Class.new(Patterns::Calculation) do
+        private
+
+        def result
+          yield(subject)
+        end
+      end
+      
+      expect(CustomCalculation.result(5) { |a| a * 3 }).to eq(15)
+    end
   end
 
   describe "caching" do

data/spec/patterns/rule_spec.rb

@@ -0,0 +1,44 @@
+RSpec.describe Patterns::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(Patterns::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(Patterns::Rule)
+    CustomRule = Class.new(Patterns::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(Patterns::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,255 @@
+RSpec.describe Patterns::Ruleset do
+  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(Patterns::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(Patterns::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(Patterns::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(Patterns::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(Patterns::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(Patterns::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(Patterns::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(Patterns::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(Patterns::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(Patterns::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(Patterns::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
+
+    context 'ruleset has no rules' do
+      it 'returns true' do
+        with_mocked_rules do |_rules|
+          subject = double
+
+          custom_ruleset_klass = Class.new(Patterns::Ruleset)
+
+          expect(custom_ruleset_klass.new(subject).satisfied?).to eq true
+        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(Patterns::Ruleset)
+        custom_ruleset_klass_1.add_rule(:rule_1)
+        custom_ruleset_klass_1.add_rule(:rule_2)
+        Ruleset2 = Class.new(Patterns::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(Patterns::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 Patterns::StrongRuleset do
+  it 'inherites from Ruleset' do
+    custom_strong_ruleset_klass = Class.new(Patterns::StrongRuleset)
+    expect(custom_strong_ruleset_klass.ancestors).to include Patterns::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(Patterns::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(Patterns::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(Patterns::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(Patterns::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.11.0
 platform: ruby
 authors:
 - Stevo
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-06-12 00:00:00.000000000 Z
+date: 2022-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -98,16 +98,16 @@ dependencies:
   name: juwelier
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.1.0
+        version: '0'
 description: A collection of lightweight, standardized, rails-oriented patterns.
 email: b.kosmowski@selleo.com
 executables: []
@@ -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.0.8
+signing_key:
 specification_version: 4
 summary: A collection of lightweight, standardized, rails-oriented patterns.
 test_files: []