rails-patterns 0.6.0 → 0.10.0

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.6.0 ruby lib
+# stub: rails-patterns 0.10.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "rails-patterns".freeze
-  s.version = "0.6.0"
+  s.version = "0.10.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 = "2018-01-18"
+  s.date = "2021-12-10"
   s.description = "A collection of lightweight, standardized, rails-oriented patterns.".freeze
   s.email = "b.kosmowski@selleo.com".freeze
   s.extra_rdoc_files = [
@@ -20,6 +20,7 @@ Gem::Specification.new do |s|
   ]
   s.files = [
     ".document",
+    ".github/workflows/ruby.yml",
     ".rspec",
     "Gemfile",
     "Gemfile.lock",
@@ -32,19 +33,29 @@ 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",
+    "spec/helpers/custom_calculation_script.rb",
+    "spec/helpers/rails_redis_cache_mock.rb",
     "spec/patterns/calculation_spec.rb",
     "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.rubygems_version = "2.6.10".freeze
+  s.required_ruby_version = Gem::Requirement.new(">= 2.5.0".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
@@ -54,24 +65,27 @@ Gem::Specification.new do |s|
       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, ["~> 1.0"])
-      s.add_development_dependency(%q<juwelier>.freeze, ["~> 2.1.0"])
+      s.add_development_dependency(%q<bundler>.freeze, ["~> 2.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"])
       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, ["~> 1.0"])
-      s.add_dependency(%q<juwelier>.freeze, ["~> 2.1.0"])
+      s.add_dependency(%q<bundler>.freeze, ["~> 2.0"])
+      s.add_dependency(%q<juwelier>.freeze, [">= 0"])
     end
   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, ["~> 1.0"])
-    s.add_dependency(%q<juwelier>.freeze, ["~> 2.1.0"])
+    s.add_dependency(%q<bundler>.freeze, ["~> 2.0"])
+    s.add_dependency(%q<juwelier>.freeze, [">= 0"])
   end
 end
 

data/spec/helpers/custom_calculation.rb

@@ -0,0 +1,16 @@
+require 'active_support/all'
+require 'active_support/testing/time_helpers'
+require_relative 'rails_redis_cache_mock'
+require_relative '../../lib/patterns/calculation'
+
+CustomCalculation = Class.new(Patterns::Calculation) do
+  set_cache_expiry_every 1.hour
+  class_attribute :counter
+  self.counter = 0
+
+  private
+
+  def result
+    self.class.counter += 1
+  end
+end

data/spec/helpers/custom_calculation_script.rb

@@ -0,0 +1,4 @@
+require_relative 'rails_redis_cache_mock'
+require_relative 'custom_calculation'
+
+CustomCalculation.result

data/spec/helpers/rails_redis_cache_mock.rb

@@ -0,0 +1,5 @@
+class Rails
+  def self.cache
+    @cache ||= ActiveSupport::Cache::RedisCacheStore.new
+  end
+end

data/spec/patterns/calculation_spec.rb

@@ -14,6 +14,7 @@ RSpec.describe Patterns::Calculation do
   after do
     Object.send(:remove_const, :CustomCalculation) if defined?(CustomCalculation)
     Rails.cache.clear
+    ActiveSupport::Cache::RedisCacheStore.new.clear
   end
 
   describe ".result" do
@@ -59,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
@@ -159,5 +172,41 @@ RSpec.describe Patterns::Calculation do
       expect(CustomCalculation.result).to eq 1
       expect(CustomCalculation.result).to eq 2
     end
+
+    describe "when RedisCacheStore is used" do
+      it "does not store data in cache if 'cache_expiry_period' is not set" do
+        client = Redis.new
+        class Rails
+          def self.cache
+            @cache ||= ActiveSupport::Cache::RedisCacheStore.new
+          end
+        end
+
+        CustomCalculation = Class.new(Patterns::Calculation) do
+          class_attribute :counter
+          self.counter = 0
+
+          private
+
+          def result
+            self.class.counter += 1
+          end
+        end
+
+        expect(CustomCalculation.result).to eq 1
+        expect(CustomCalculation.result).to eq 2
+        expect(client.keys).to be_empty
+      end
+    end
+
+    it "uses cache keys consistent between processes" do
+      `bundle exec ruby spec/helpers/custom_calculation.rb`
+      Process.spawn('bundle exec ruby spec/helpers/custom_calculation_script.rb')
+      Process.spawn('bundle exec ruby spec/helpers/custom_calculation_script.rb')
+      Process.spawn('bundle exec ruby spec/helpers/custom_calculation_script.rb')
+      Process.waitall
+
+      expect(Redis.new.keys.length).to eq 1
+    end
   end
 end

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,260 @@
+RSpec.describe Patterns::Ruleset do
+  context 'when empty ruleset is initialized' do
+    it 'raises an error' do
+      empty_ruleset_klass = Class.new(Patterns::Ruleset)
+      custom_ruleset_klass = Class.new(Patterns::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 Patterns::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(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
+  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/service_spec.rb

@@ -10,7 +10,7 @@ RSpec.describe Patterns::Service do
       expect(DoSomething.call).to be_kind_of(DoSomething)
     end
 
-    it "instantiates service object passing arguments to constructor" do
+    it "instantiates service object passing keyword arguments to constructor" do
       DoSomething = Class.new(Patterns::Service) do
         def initialize(argument_1:, argument_2:); end
         def call; end
@@ -25,6 +25,21 @@ RSpec.describe Patterns::Service do
       }.not_to raise_error
     end
 
+    it "instantiates service object passing positional arguments to constructor" do
+      DoSomething = Class.new(Patterns::Service) do
+        def initialize(argument_1, argument_2); end
+        def call; end
+      end
+
+      expect {
+        DoSomething.call
+      }.to raise_error ArgumentError
+
+      expect {
+        DoSomething.call(10, 20)
+      }.not_to raise_error
+    end
+
     it "calls #call method on service object instance" do
       Spy = Class.new do
         def self.some_method; 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

data/spec/spec_helper.rb

@@ -20,6 +20,7 @@
 require "active_support/all"
 require "active_support/testing/time_helpers"
 require "pry"
+require "redis"
 require "rails-patterns"
 
 RSpec.configure do |config|