luna_park 0.11.0

data/lib/luna_park/extensions/dsl/attributes.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require 'luna_park/extensions/comparable'
+require 'luna_park/extensions/serializable'
+require 'luna_park/extensions/predicate_attr_accessor'
+require 'luna_park/extensions/typed_attr_accessor'
+
+module LunaPark
+  module Extensions
+    module Dsl
+      ##
+      # class-level mixin
+      #
+      # @example
+      #   class Elephant
+      #     include LunaPark::Extensions::Comparable   # required for Dsl::Attributes
+      #     include LunaPark::Extensions::Serializable # required for Dsl::Attributes
+      #     extend  LunaPark::Extensions::Dsl::Attributes
+      #
+      #     # ...
+      #
+      #     attr  :eyes_count                        # simple accessor registered as serializable and comparable attribute
+      #     attr  :ears, Ears, :new                  # :new or any other class method that will construct Ear object
+      #     attr  :defeat_enemies, comparable: false # will not be used in compasrion via `#==``
+      #     attr? :alive                             # will add predicate? method
+      #
+      #     attr_accessor :smuggler
+      #
+      #     # ...
+      #   end
+      #
+      #   e1 = Elephant.new(eyes_count: 1, ears: { left: true, right: true }, defeat_enemies: 228, alive: true, smuggler: true)
+      #   e2 = Elephant.new(eyes_count: 1, ears: { left: true, right: true }, defeat_enemies: 0, alive: true, smuggler: false)
+      #   e3 = Elephant.new(eyes_count: 2, ears: { left: true, right: true }, defeat_enemies: 0, alive: true, smuggler: true)
+      #
+      #   e1 == e2 # => true  (comparsion disabled for #defeat_enemies and not registered for #smuggler)
+      #   e1 == e3 # => false (missmatch of #eyes_count)
+      #
+      #   e1.to_h # => { eyes_count: 1, ears: { left: true, right: true }, defeat_enemies: 228, alive: true }
+      #           #    (omit #smuggler cause it's not registered for serialization)
+      #
+      #   e1.ears # => #<Ears left=true right=true>
+      #   e1.ears = { left: true, right: false }
+      #   e1.ears # => #<Ears left=true right=false>
+      #
+      #   e1.alive? # => true
+      module Attributes
+        DEFAULT_TYPE_METH = :call
+        private_constant :DEFAULT_TYPE_METH
+
+        include PredicateAttrAccessor
+        include TypedAttrAccessor
+
+        ##
+        # .attr that also adds `reader?`
+        #
+        # @return [Array of Hash(Symbol => Symbol)] Hash of defined methods
+        def attrs?(*args, **options)
+          defined_methods_arr = attrs(*args, **options)
+          getter_names = defined_methods_arr.map { |r| r[:getter] }
+
+          protected(*getter_names)
+          attr_reader?(*getter_names)
+
+          defined_methods_arr.map { |r| r.merge(predicate: :"#{r[:getter]}?") }
+        end
+
+        ##
+        # .attrs that also adds `reader?`
+        #   return Hash of defined methods `{ getter: :foo, setter: :foo=, predicate }`
+        #
+        # @return [Hash(Symbol => Symbol)] Hash of defined methods
+        def attr?(*args, **options)
+          defined_methods = attr(*args, **options)
+          getter_name = defined_methods[:getter]
+
+          protected(getter_name)
+          attr_reader?(getter_name)
+
+          defined_methods.merge(predicate: :"#{getter_name}?")
+        end
+
+        ##
+        # .attr with mass defining
+        #
+        # @example
+        #   attrs name1, name2, name3, **attr_options
+        #   attrs name1, name2, name3, CallableType, **attr_options
+        #   attrs name1, name2, name3, Type, :type_method, **attr_options
+        #
+        # @return [Array of Hash(Symbol => Symbol)] Hash of defined methods
+        def attrs(*args, **options) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+          *names, type, type_meth = if args.all? { |arg| arg.is_a?(Symbol) }
+                                      [*args, nil, nil]
+                                    elsif args[0..-2].all? { |arg| arg.is_a?(Symbol) }
+                                      [*args, DEFAULT_TYPE_METH]
+                                    elsif args[0..-3].all? { |arg| arg.is_a?(Symbol) } && args.last.is_a?(Symbol)
+                                      args
+                                    else
+                                      raise ArgumentError, 'must be (*names) | ' \
+                                        '(*names, type) | (*names, type, type_meth)'
+                                    end
+
+          names.map { |name| attr name, type, type_meth, **options }
+        end
+
+        ##
+        # define typed attr_accessor, register it for Extenions::Comparable, Extenions::Serializable
+        #   so it will be comparable using `#==`, `#eql?` and serializable using `#to_h`, `#serialize`
+        #   return Hash of defined methods `{ getter: :foo, setter: :foo= }`
+        #
+        # @param name [Symbol]
+        # @param type [Object] any object that responds to method described in next param. Skip if you dont need stypification
+        # @param type_meth [Symbol] (call)
+        # @option options [Bool] comparable (true)
+        # @option options [Bool] array (false)
+        # @option options [Bool] private_setter (false)
+        #
+        # @return [Hash(Symbol => Symbol)]
+        #   Hash of defined methods { :method_role => :method_name }; `{ getter: :foo }`
+        def attr(name, type = nil, type_meth = nil, comparable: true, array: false)
+          type_meth ||= DEFAULT_TYPE_METH
+          attr_reader(name)
+
+          serializable_attributes(name) if include?(Serializable)
+          comparable_attributes(name)   if comparable && include?(Comparable)
+
+          typed_attr_writer(name, type&.method(type_meth), is_array: array)
+
+          { getter: name, setter: :"#{name}=" }
+        end
+      end
+    end
+  end
+end

data/lib/luna_park/extensions/dsl/foreign_key.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'luna_park/extensions/comparable'
+require 'luna_park/extensions/serializable'
+
+module LunaPark
+  module Extensions
+    module Dsl
+      # @example
+      #  class Transaction
+      #    # ...
+      #    include LunaPark::Extensions::Dsl::ForeignKey
+      #
+      #    foreign_key :user_uid, :user, primary_key: :uid # `primary_key:` default is `:id`
+      #                                                    # foreign_key points to primary_key
+      #
+      #    # OR alias:
+      #    fk :user_uid, :user, pk: :uid
+      #
+      #    # ...
+      #  end
+      #
+      #  t = Transaction.new
+      #  t1.user # => nil
+      #  t1.user_uid # => nil
+      #
+      #  t1.user = User.new(uid: 42)
+      #  t1.user # => #<User uid=42>
+      #  t1.user_uid # => 42 (changed)
+      #
+      #  t1.user # => #<User uid=42>
+      #  t1.user = nil
+      #  t1.user_uid # => nil (removed)
+      #
+      #  t1.user # => #<User uid=42>
+      #  t1.user_uid = nil
+      #  t1.user # => nil (removed)
+      #
+      #  t1.user # => #<User uid=42>
+      #  t1.user = User.new(uid: 666)
+      #  t1.user_uid # => 666 (changed)
+      #
+      #  t1.user # => #<User uid=42>
+      #  t1.user_uid = 666
+      #  t1.user # => nil (removed cause uid missmatch)
+      module ForeignKey
+        def self.extended(base)
+          base.extend  ClassMethods
+          base.include InstanceMethods
+        end
+
+        module ClassMethods
+          def fk(fk_name, assoc_name, pk: :id)
+            foreign_key(fk_name, assoc_name, primary_key: pk)
+          end
+
+          def foreign_key(fk_name, assoc_name, primary_key: :id) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+            pk_name = primary_key
+            serializable_attributes(fk_name) if include?(Serializable)
+            comparable_attributes(fk_name)   if include?(Comparable)
+
+            attr_reader fk_name, assoc_name
+
+            anonym_mixin = Module.new do
+              define_method(:"#{assoc_name}=") do |new_assoc|
+                new_assoc_pk = extract_pk_value_from_object__(new_assoc, pk_name)
+                instance_variable_set(:"@#{fk_name}", new_assoc_pk)
+                instance_variable_set(:"@#{assoc_name}", new_assoc)
+              end
+
+              define_method(:"#{fk_name}=") do |new_fk|
+                assoc = public_send(assoc_name)
+                instance_variable_set(:"@#{fk_name}", new_fk)
+                return new_fk if assoc.nil?
+
+                current_assoc_pk = extract_pk_value_from_object__(assoc, pk_name)
+                instance_variable_set(:"@#{assoc_name}", nil) unless new_fk == current_assoc_pk
+                new_fk
+              end
+            end
+            include anonym_mixin
+          end
+        end
+
+        module InstanceMethods
+          private
+
+          def extract_pk_value_from_object__(object, pk_name)
+            object.respond_to?(:[]) && object[pk_name] ||
+              object.respond_to?(pk_name) && object.public_send(pk_name) ||
+              nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/luna_park/extensions/exceptions/substitutive.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module LunaPark
+  module Extensions
+    module Exceptions
+      # class-level mixin
+
+      module Substitutive
+        def self.extended(base)
+          base.extend  ClassMethods
+          base.include InstanceMethods
+        end
+
+        module ClassMethods
+          # Substitute original exception with save original backtrace.
+          #
+          # @example bad case
+          #   class MyException < StandardError
+          #     extend LunaPark::Extensions::Exceptions::Substitutive
+          #   end
+          #
+          #     call_exceptional_lib!
+          #   rescue ExceptionalLib::SomeException => e
+          #     raise MyException # => raised MyException with backtrace started from `raise MyException`
+          #                       #      and not contained origin exception backtrace
+          #                       #      that can be very painfull for debug
+          #   end
+          #
+          # @example resolve
+          #   begin
+          #     call_exceptional_lib!
+          #   rescue ExceptionalLib::SomeException => e
+          #     raise MyException.substitute(e) # => raised MyException with backtrace started
+          #                                     #      from library `raise ExceptionalLib::SomeException`
+          #                                     #      so you can easily find out where exception starts
+          #   end
+          def substitute(origin)
+            new = new(origin.message)
+            new.backtrace = origin.backtrace
+            new.origin    = origin
+            new
+          end
+        end
+
+        module InstanceMethods
+          attr_accessor :origin
+          attr_writer :backtrace
+
+          def backtrace
+            super || @backtrace
+          end
+
+          # Cover up trace for current exception
+          #
+          # @example bad case
+          #   begin
+          #     call_exceptional_lib!
+          #   rescue ExceptionalLib::SomeException => e
+          #     send_alert_to_developer
+          #     raise e # => raised `ExceptionalLib::SomeException` with backtrace started
+          #             #      from current line and not contained origin exception backtrace
+          #             #      that can be very painful for debug
+          #   end
+          #
+          # @example resolve
+          #     begin
+          #       call_exceptional_lib!
+          #     rescue ExceptionalLib::SomeException => e
+          #       send_alert_to_developer
+          #       raise e.cover_up_backtrace # => raised `ExceptionalLib::SomeException` with original backtrace
+          #                                  #       so you can easily find out where exception starts
+          #     end
+          def cover_up_backtrace
+            new = dup
+            new.backtrace = backtrace
+            new.origin    = self
+            new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/luna_park/extensions/has_errors.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require 'luna_park/errors/business'
+require 'luna_park/errors/system'
+
+module LunaPark
+  module Extensions
+    ##
+    # This is syntax sugar for define exception class
+    # in UseCase layer
+    #
+    # @example without sugar
+    #   class Service
+    #     class UserNotExists < LunaPark::Errors::Business
+    #       message 'Sorry but user does not exists'
+    #     end
+    #
+    #     def call
+    #        raise UserNotExists if something_wrong
+    #     end
+    #   end
+    #
+    # @example with sugar
+    #   class Service
+    #     include LunaPark::Extensions::HasErrors
+    #     error :user_not_exists, 'Sorry but user does not exists'
+    #
+    #     def call
+    #       error :user_not_exists if something_wrong
+    #     end
+    #   end
+    module HasErrors
+      def self.included(base)
+        base.extend  ClassMethods
+        base.include InstanceMethods
+      end
+
+      module InstanceMethods
+        ##
+        # Raise error defined in class
+        #
+        # @example
+        #   class Service
+        #     include LunaPark::Extensions::HasErrors
+        #
+        #     class CustomError < LunaPark::Errors::Business; end
+        #   end
+        #
+        #   Service.new.error :custom_error # => raise CustomError
+        #
+        # @param title [Symbol|String] - Title of error
+        # @param msg [String] - Message of error
+        # @param **attrs - See @LunaPark::Errors::Base#new
+        def error(title, msg = nil, **attrs)
+          class_name = self.class.error_class_name(title)
+          raise self.class.const_get(class_name).new msg, **attrs
+        end
+      end
+
+      module ClassMethods
+        ##
+        # Define business error
+        #
+        # @example
+        #   class Service
+        #     include LunaPark::Extensions::HasErrors
+        #
+        #     business_error :logic_error, { (1 + 1).to_s }
+        #   end
+        #
+        #   logic_error = Service::LogicError.new
+        #   logic_error.is_a? LunaPark::Errors::Business # => true
+        #   logic_error.message # => '2'
+        def business_error(title, txt = nil, i18n_key: nil, notify: nil, &default_message_block)
+          error_class = Class.new(Errors::Business)
+          error_class.message(txt, i18n_key: i18n_key, &default_message_block)
+          error_class.notify(notify)
+          const_set(error_class_name(title), error_class)
+        end
+
+        ##
+        # Alias for business error
+        alias error business_error
+
+        ##
+        # Define business error
+        #
+        # @example
+        #   class Service
+        #     include LunaPark::Extensions::HasErrors
+        #
+        #     system_error :tech_error, 'Custom message'
+        #   end
+        #
+        #   tech_error = Service::TechError.new
+        #   tech_error.is_a? LunaPark::Errors::System # => true
+        #   tech_error.message # => 'Custom message'
+        def system_error(title, txt = nil, i18n_key: nil, notify: nil, &default_message_block)
+          error_class = Class.new(Errors::System)
+          error_class.message(txt, i18n_key: i18n_key, &default_message_block)
+          error_class.notify(notify)
+          const_set(error_class_name(title), error_class)
+        end
+
+        ##
+        # Get error class name
+        #
+        # @example when title is string
+        #   error_class_name('CamelCase') # => 'CamelCase'
+        #
+        # @example when title is symbol
+        #   error_class_name(:snake_case) # => 'SnakeCase'
+        #
+        # @param [String|Symbol] title - short alias for error
+        def error_class_name(title)
+          case title
+          when String then title
+          when Symbol then title.to_s.split('_').collect!(&:capitalize).join
+          else raise ArgumentError, "Unknown type `#{title}` for error title"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/luna_park/extensions/injector.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require 'luna_park/extensions/injector/dependencies'
+
+module LunaPark
+  module Extensions
+    # The main goal of the injector is a help developer with
+    # dependency injection technique.
+    #
+    # @example Dependency injection
+    #   class Messenger
+    #     def self.post(to:, msg:); end
+    #   end
+    #
+    #   module Users
+    #     class Entity
+    #       def active!; end
+    #       def full_name;end
+    #     end
+    #
+    #     class PgRepo
+    #       def find(id); end
+    #       def save(user); end
+    #     end
+    #
+    #     # In this example, you can see the relationship between
+    #     # the business layer and the data layer, and between the
+    #     # business layer and external libraries.
+    #
+    #     class SetActive < LunaPark::UseCases::Scenario
+    #       include LunaPark::Extensions::Injector
+    #
+    #       attr_accessor :user_id
+    #
+    #       def call!
+    #         repo = Users::PgRepo.new # <- dependency from data layer
+    #         user = repo.find(user_id)
+    #         user.active!
+    #         repo.save user
+    #
+    #         Messenger.post(to: :admin, msg:"User #{user.full_name} is active_now") # <- dependency from external libs
+    #       end
+    #     end
+    #   end
+    #
+    #   # Here, Injector can help remove the dependency technical details from
+    #   # the business layer.
+    #
+    #   class SetActive < LunaPark::Interactors::Scenario
+    #     include LunaPark::Extensions::Injector
+    #
+    #     dependency(:repo)      { Users::PgRepo.new } # You should define dependency in block - like rspec `let`
+    #                                                  # method. That should initialize value only if that needed.
+    #     dependency(:messenger) { Messenger }
+    #
+    #     attr_accessor :user_id
+    #
+    #     def call!
+    #       user = repo.find(user_id)
+    #       user.active!
+    #       repo.save user
+    #
+    #       messenger.post(to: :admin, msg:"User #{user.full_name} is active_now")
+    #     end
+    #   end
+    #
+    #
+    # @example rspec test
+    #   module Users
+    #     RSpec.describe SetActive do
+    #       # We highly dont recommended inject dependencies witch does not call exteranal resources
+    #       let(:user)       { Entity.new id: 1, first_name: 'John', last_name: 'Doe'}
+    #       let(:use_case) { described_class.new(user_id: 1) }
+    #
+    #       before do
+    #         use_case.dependencies = {
+    #           repo: -> { instance_double PgRepo, find: user, save: true },
+    #           messenger: -> { class_double Messenger, post: true }
+    #         }
+    #       end
+    #
+    #       describe '#call!' do
+    #         subject(:set_active!) { use_case.call! }
+    #
+    #         it 'should set user is active' do
+    #           expect{ set_active! }.to change{ user.active? }.from(false).to(true)
+    #         end
+    #
+    #         it 'should save user' do
+    #           expect(use_case.repo).to receive(:save).with(user)
+    #           set_active!
+    #         end
+    #
+    #         it 'should send expected message to admin' do
+    #           text = 'User John Doe is active_now'
+    #           expect(use_case.messenger).to receive(:post).with(to: :admin, msg: text)
+    #           set_active!
+    #         end
+    #       end
+    #     end
+    #   end
+    module Injector
+      # @!parse include Injector::ClassMethods
+      # @!parse extend Injector::InstanceMethods
+      def self.included(base)
+        base.extend ClassMethods
+        base.include InstanceMethods
+      end
+
+      module ClassMethods
+        ##
+        # Set dependency
+        #
+        # @example Set dependency
+        #   class Foo
+        #     include LunaPark::Extensions::Injector
+        #
+        #     dependency(:example) { Bar.new }
+        #   end
+        def dependency(name, &block)
+          dependencies[name] = block
+
+          define_method(name) do
+            dependencies.call_with_cache(name)
+          end
+        end
+
+        ##
+        # List class defined dependencies
+        #
+        # @example get dependency
+        #  class Foo
+        #     include LunaPark::Extensions::Injector
+        #
+        #     dependency(:example) { Bar.new }
+        #   end
+        #
+        #   Foo.dependencies # => {:example=>#<Proc:0x0000560a4fb48fc0@t.rb:77>}
+        def dependencies
+          @dependencies ||= {}
+        end
+      end
+
+      module InstanceMethods
+        ##
+        # List instance defined dependencies, in default it defined in class
+        # methods.
+        #
+        #   class SetActive
+        #     dependency(:repo) { Repo.new(CONFIG[:db_connect]) }
+        #     dependency(:messenger) { Messenger }
+        #   end
+        #
+        #   use_case = SetActive.new(user_id: 1)
+        #
+        #   # All dependencies
+        #   use_case.dependencies             # => {
+        #                                     #   :repo=>#<Proc:0x0000564a0d90d668@t.rb:33>,
+        #                                     #   :messenger=>#<Proc:0x0000564a0d90d438@t.rb:34>
+        #                                     # }
+        #
+        #   # Single dependency
+        #   use_case.dependencies[:messenger] # => #<Proc:0x0000564a0d90d438@t.rb:34>
+        #
+        #   # Dependency value
+        #   use_case.messenger                # => Messenger
+        def dependencies
+          @dependencies ||= Dependencies.wrap(self.class.dependencies)
+        end
+
+        ##
+        # Setter - highly recommended for use in specs so you don't forget
+        # to override <b>all</b> dependencies.
+        #
+        #   use_case.dependencies = {
+        #     repo: -> { Fake::Repo.new }
+        #   }
+        #   use_case.messenger # => Dependency `messenger` is undefined (LunaPark::Errors::DependencyUndefined)
+        #   use_case.call      # => Dependency `messenger` is undefined (LunaPark::Errors::DependencyUndefined)
+        #
+        #   # Redefine single dependency still possible
+        #   use_case.dependencies[:messenger] = -> { Messenger }
+        def dependencies=(value)
+          @dependencies = Dependencies.wrap(value)
+        end
+      end
+    end
+  end
+end