rails-patterns 0.3.0 → 0.7.3

data/Rakefile

@@ -21,6 +21,7 @@ Juwelier::Tasks.new do |gem|
   gem.description = "A collection of lightweight, standardized, rails-oriented patterns."
   gem.email = "b.kosmowski@selleo.com"
   gem.authors = ["Stevo"]
+  gem.required_ruby_version = ">= 2.5.0"
 
   # dependencies defined in Gemfile
 end

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.7.3

data/lib/patterns/calculation.rb

@@ -0,0 +1,59 @@
+require 'digest'
+
+module Patterns
+  class Calculation
+    class_attribute :cache_expiry_every
+
+    def initialize(*args)
+      @options = args.extract_options!
+      @subject = args.first
+    end
+
+    def self.result(*args)
+      new(*args).cached_result
+    end
+
+    class << self
+      alias_method :result_for, :result
+      alias_method :calculate, :result
+    end
+
+    def self.set_cache_expiry_every(period)
+      self.cache_expiry_every = period
+    end
+
+    def cached_result
+      if cache_expiry_period.blank?
+        result
+      else
+        Rails.cache.fetch(cache_key, expires_in: cache_expiry_period) do
+          result
+        end
+      end
+    end
+
+    private
+
+    attr_reader :subject, :options
+
+    def result
+      raise NotImplementedError
+    end
+
+    def cache_key
+      "#{self.class.name}_#{hash_of(subject, options)}"
+    end
+
+    def self.hash_of(*args)
+      Digest::SHA1.hexdigest(args.map(&:to_s).join(':'))
+    end
+
+    def hash_of(*args)
+      self.class.hash_of(*args)
+    end
+
+    def cache_expiry_period
+      self.class.cache_expiry_every
+    end
+  end
+end

data/lib/patterns/form.rb

@@ -0,0 +1,117 @@
+require "virtus"
+require "action_controller/metal/strong_parameters"
+
+module Patterns
+  class Form
+    include Virtus.model
+    include ActiveModel::Validations
+
+    Error = Class.new(StandardError)
+    Invalid = Class.new(Error)
+    NoParamKey = Class.new(Error)
+
+    def initialize(*args)
+      attributes = args.extract_options!
+
+      if attributes.blank? && args.last.is_a?(ActionController::Parameters)
+        attributes = args.pop.to_unsafe_h
+      end
+
+      @resource = args.first
+
+      super(build_original_attributes.merge(attributes))
+    end
+
+    def save
+      valid? ? persist : false
+    end
+
+    def save!
+      save.tap do |saved|
+        raise Invalid unless saved
+      end
+    end
+
+    def as(form_owner)
+      @form_owner = form_owner
+      self
+    end
+
+    def to_key
+      nil
+    end
+
+    def to_partial_path
+      nil
+    end
+
+    def to_model
+      self
+    end
+
+    def to_param
+      if resource.present? && resource.respond_to?(:to_param)
+        resource.to_param
+      else
+        nil
+      end
+    end
+
+    def persisted?
+      if resource.present? && resource.respond_to?(:persisted?)
+        resource.persisted?
+      else
+        false
+      end
+    end
+
+    def model_name
+      @model_name ||= OpenStruct.new(model_name_attributes)
+    end
+
+    def self.param_key(key = nil)
+      if key.nil?
+        @param_key
+      else
+        @param_key = key
+      end
+    end
+
+    private
+
+    attr_reader :resource, :form_owner
+
+    def model_name_attributes
+      if self.class.param_key.present?
+        {
+          param_key: self.class.param_key,
+          route_key: self.class.param_key.pluralize,
+          singular_route_key: self.class.param_key
+        }
+      elsif resource.present? && resource.respond_to?(:model_name)
+        {
+          param_key: resource.model_name.param_key,
+          route_key: resource.model_name.route_key,
+          singular_route_key: resource.model_name.singular_route_key
+        }
+      else
+        raise NoParamKey
+      end
+    end
+    
+    def build_original_attributes
+      return {} if resource.nil?
+      base_attributes = resource.respond_to?(:attributes) && resource.attributes.symbolize_keys
+
+      self.class.attribute_set.each_with_object(base_attributes || {}) do |attribute, result|
+        if result[attribute.name].blank? && resource.respond_to?(attribute.name)
+          result[attribute.name] = resource.public_send(attribute.name)
+        end
+      end
+    end
+
+    def persist
+      raise NotImplementedError, "#persist has to be implemented"
+    end
+  end
+end

data/lib/patterns/query.rb

@@ -6,17 +6,17 @@ module Patterns
 
     def initialize(*args)
       @options = args.extract_options!
-      @relation = args.first || self.class.base_relation
+      @relation = args.first || base_relation
 
       if relation.nil?
         raise(
-            RelationRequired,
-            "Queries require a base relation defined. Use .queries method to define relation."
+          RelationRequired,
+          "Queries require a base relation defined. Use .queries method to define relation."
         )
       elsif !relation.is_a?(ActiveRecord::Relation)
         raise(
-            RelationRequired,
-            "Queries accept only ActiveRecord::Relation as input"
+          RelationRequired,
+          "Queries accept only ActiveRecord::Relation as input"
         )
       end
     end
@@ -29,20 +29,25 @@ module Patterns
       query.tap do |relation|
         unless relation.is_a?(ActiveRecord::Relation)
           raise(
-              RelationRequired,
-              "#query method should return object of ActiveRecord::Relation class"
+            RelationRequired,
+            "#query method should return object of ActiveRecord::Relation class"
           )
         end
       end
     end
 
     def self.queries(subject)
-      self.base_relation =
-        if subject.is_a?(ActiveRecord::Relation)
-          subject
-        elsif subject < ActiveRecord::Base
-          subject.all
-        end
+      self.base_relation = subject
+    end
+
+    def base_relation
+      return nil if self.class.base_relation.nil?
+
+      if self.class.base_relation.is_a?(ActiveRecord::Relation)
+        self.class.base_relation
+      elsif self.class.base_relation < ActiveRecord::Base
+        self.class.base_relation.all
+      end
     end
 
     private
@@ -55,8 +60,8 @@ module Patterns
 
     def query
       raise(
-          NotImplementedError,
-          "You need to implement #query method which returns ActiveRecord::Relation object"
+        NotImplementedError,
+        "You need to implement #query method which returns ActiveRecord::Relation object"
       )
     end
   end

data/lib/patterns/service.rb

@@ -1,13 +1,17 @@
+require 'ruby2_keywords'
+
 module Patterns
   class Service
     attr_reader :result
 
-    def self.call(*args)
-      new(*args).tap do |service|
-        service.instance_variable_set(
-          "@result",
-          service.call
-        )
+    class << self
+      ruby2_keywords def call(*args)
+        new(*args).tap do |service|
+          service.instance_variable_set(
+            "@result",
+            service.call
+          )
+        end
       end
     end
 

data/lib/rails-patterns.rb

@@ -2,3 +2,5 @@ require "patterns"
 require "patterns/query"
 require "patterns/service"
 require "patterns/collection"
+require "patterns/calculation"
+require "patterns/form"

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.3.0 ruby lib
+# stub: rails-patterns 0.7.3 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "rails-patterns".freeze
-  s.version = "0.3.0"
+  s.version = "0.7.3"
 
   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 = "2017-04-19"
+  s.date = "2020-06-12"
   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",
@@ -28,19 +29,27 @@ Gem::Specification.new do |s|
     "Rakefile",
     "VERSION",
     "lib/patterns.rb",
+    "lib/patterns/calculation.rb",
     "lib/patterns/collection.rb",
+    "lib/patterns/form.rb",
     "lib/patterns/query.rb",
     "lib/patterns/service.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/service_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 = "2.7.6.2".freeze
   s.summary = "A collection of lightweight, standardized, rails-oriented patterns.".freeze
 
   if s.respond_to? :specification_version then
@@ -48,19 +57,28 @@ Gem::Specification.new do |s|
 
     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, ["~> 1.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, ["~> 1.0"])
+      s.add_dependency(%q<bundler>.freeze, ["~> 2.0"])
       s.add_dependency(%q<juwelier>.freeze, ["~> 2.1.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<bundler>.freeze, ["~> 2.0"])
     s.add_dependency(%q<juwelier>.freeze, ["~> 2.1.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

@@ -0,0 +1,200 @@
+RSpec.describe Patterns::Calculation do
+  before(:all) do
+    class Rails
+      def self.cache
+        @cache ||= ActiveSupport::Cache::MemoryStore.new
+      end
+    end
+  end
+
+  after(:all) do
+    Object.send(:remove_const, :Rails)
+  end
+
+  after do
+    Object.send(:remove_const, :CustomCalculation) if defined?(CustomCalculation)
+    Rails.cache.clear
+    ActiveSupport::Cache::RedisCacheStore.new.clear
+  end
+
+  describe ".result" do
+    it "returns a result of the calculation within a #result method" do
+      CustomCalculation = Class.new(Patterns::Calculation) do
+        private
+
+        def result
+          50
+        end
+      end
+
+      expect(CustomCalculation.result).to eq 50
+    end
+
+    it "#result, #result_for and #calculate are aliases" do
+      CustomCalculation = Class.new(Patterns::Calculation)
+
+      expect(CustomCalculation.method(:result)).to eq CustomCalculation.method(:result_for)
+      expect(CustomCalculation.method(:result)).to eq CustomCalculation.method(:calculate)
+    end
+
+    it "exposes the first argument as a subject" do
+      CustomCalculation = Class.new(Patterns::Calculation) do
+        private
+
+        def result
+          subject
+        end
+      end
+
+      expect(CustomCalculation.result('test')).to eq 'test'
+    end
+
+    it "exposes all keyword arguments using #options" do
+      CustomCalculation = Class.new(Patterns::Calculation) do
+        private
+
+        def result
+          [options[:arg_1], options[:arg_2]]
+        end
+      end
+
+      expect(CustomCalculation.result(nil, arg_1: 20, arg_2: 30)).to eq([20, 30])
+    end
+  end
+
+  describe "caching" do
+    it "caches result for 'set_cache_expiry_every' period" do
+      travel_to DateTime.new(2017, 1, 1, 12, 0) do
+        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
+
+        expect(CustomCalculation.result).to eq 1
+        expect(CustomCalculation.result).to eq 1
+      end
+
+      travel_to DateTime.new(2017, 1, 1, 13, 1) do
+        expect(CustomCalculation.result).to eq 2
+        expect(CustomCalculation.result).to eq 2
+      end
+    end
+
+    it "caches result for every option passed" do
+      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
+
+      expect(CustomCalculation.result(123)).to eq 1
+      expect(CustomCalculation.result(123)).to eq 1
+      expect(CustomCalculation.result(1024)).to eq 2
+      expect(CustomCalculation.result(1024)).to eq 2
+      expect(CustomCalculation.result(1024, arg: 1)).to eq 3
+      expect(CustomCalculation.result(1024, arg: 1)).to eq 3
+    end
+
+    it "caches result for every option passed dependant on the class" do
+      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
+
+      DifferentCalculation = Class.new(Patterns::Calculation) do
+        set_cache_expiry_every 1.hour
+
+        class_attribute :counter
+        self.counter = 100
+
+        private
+
+        def result
+          self.class.counter += 1
+        end
+      end
+
+      expect(CustomCalculation.result(123)).to eq 1
+      expect(CustomCalculation.result(123)).to eq 1
+      expect(DifferentCalculation.result(123)).to eq 101
+      expect(DifferentCalculation.result(123)).to eq 101
+
+      Object.send(:remove_const, :DifferentCalculation)
+    end
+
+    it "does not cache result if 'set_cache_expiry_every' is not set" do
+      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
+    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