luna_park 0.11.0

data/lib/luna_park/extensions/injector/dependencies.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module LunaPark
+  module Extensions
+    module Injector
+      ##
+      # Hash for define dependencies in {Injector} extension.
+      #
+      # Main difference between Hash and Dependencies it is memorization;
+      #
+      #   # hash example
+      #   i = 0
+      #
+      #   hash = { i: -> { i += 1 } }
+      #   hash[:i].call # => 1
+      #   hash[:i].call # => 2
+      #
+      #   # dependencies
+      #   i = 0
+      #
+      #   dependencies =  Dependencies.wrap(i: -> { i += 1 })
+      #   dependencies.call_with_cache(:i) # => 1
+      #   dependencies.call_with_cache(:i) # => 1
+      #
+      class Dependencies < Hash
+        class << self
+          ##
+          # Dependencies.try_convert(obj) -> hash or nil
+          #
+          # Try to convert obj into a hash, using to_hash method.
+          # Returns converted hash or nil if obj cannot be converted
+          # for any reason.
+          #
+          # See {Hash.try_convert}[https://ruby-doc.org/core-2.7.2/Hash.html#method-c-try_convert]
+          #
+          #    Dependencies.try_convert({1=>2})   # => {1=>2}
+          #    Dependencies.try_convert("1=>2")   # => nil
+          def try_convert(obj)
+            super.nil? ? nil : new.replace(super)
+          end
+
+          alias wrap try_convert
+        end
+
+        ##
+        #  Run dependency code and cache result.
+        #
+        #    use_case.dependencies[:messenger] # => #<Proc:0x0000564a0d90d438@t.rb:34>
+        #    use_case.dependencies.call_with_cache(:messenger) # => 'Foobar'
+        def call_with_cache(key)
+          cache[key] ||= self[key].call
+        end
+
+        def []=(key, _val)
+          cache[key] = nil
+          super
+        end
+
+        private
+
+        def cache
+          @cache ||= {}
+        end
+      end
+
+      # @!parse include Injector::ClassMethods
+      # @!parse extend Injector::InstanceMethods
+      def self.included(base)
+        base.extend ClassMethods
+        base.include InstanceMethods
+      end
+    end
+  end
+end

data/lib/luna_park/extensions/predicate_attr_accessor.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module LunaPark
+  module Extensions
+    module PredicateAttrAccessor
+      def predicate_attr_accessor(*names)
+        attr_writer(*names)
+        attr_reader?(*names)
+      end
+
+      alias attr_accessor? predicate_attr_accessor
+
+      def predicate_attr_reader(*names)
+        names.each do |name|
+          ivar = :"@#{name}"
+          define_method(:"#{name}?") { instance_variable_get(ivar) }
+        end
+      end
+
+      alias attr_reader? predicate_attr_reader
+    end
+  end
+end

data/lib/luna_park/extensions/repositories/postgres/create.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module LunaPark
+  module Extensions
+    module Repositories
+      module Postgres
+        module Create
+          def create(input)
+            entity = wrap(input)
+            row    = to_row(entity)
+            new_row = dataset.returning.insert(row).first
+            new_attrs = from_row(new_row)
+            entity.set_attributes(new_attrs)
+            entity
+          end
+        end
+      end
+    end
+  end
+end

data/lib/luna_park/extensions/repositories/postgres/delete.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module LunaPark
+  module Extensions
+    module Repositories
+      module Postgres
+        module Delete
+          def delete(uid)
+            dataset.returning.where(primary_key => uid).delete
+          end
+        end
+      end
+    end
+  end
+end

data/lib/luna_park/extensions/repositories/postgres/read.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module LunaPark
+  module Extensions
+    module Repositories
+      module Postgres
+        module Read
+          def find!(pk_value, for_update: false)
+            ds = dataset.where(primary_key => pk_value)
+            read_one!(ds, for_update: for_update, not_found_meta: pk_value)
+          end
+
+          def find(pk_value, for_update: false)
+            ds = dataset.where(primary_key => pk_value)
+            read_one(ds, for_update: for_update)
+          end
+
+          def lock!(pk_value)
+            lock(pk_value) || raise(Errors::NotFound, "#{short_class_name} (#{pk_value})")
+          end
+
+          def lock(pk_value)
+            dataset.for_update.select(primary_key).where(primary_key => pk_value).first ? true : false
+          end
+
+          def count
+            dataset.count
+          end
+
+          def all
+            read_all(dataset.order { created_at.desc })
+          end
+
+          def last
+            to_entity from_row dataset.order(:created_at).last
+          end
+
+          private
+
+          def read_one!(dataset, for_update: false, not_found_meta:)
+            read_one(dataset, for_update: for_update).tap do |entity|
+              raise Errors::NotFound, "#{short_class_name} (#{not_found_meta})" if entity.nil?
+            end
+          end
+
+          def read_one(dataset, for_update: false)
+            dataset = dataset.for_update if for_update
+            row = dataset.first
+            to_entity from_row(row)
+          end
+
+          def read_all(dataset)
+            to_entities from_rows(dataset)
+          end
+
+          def short_class_name
+            @short_class_name ||= self.class.name[/::(\w+)\z/, 1]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/luna_park/extensions/repositories/postgres/update.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module LunaPark
+  module Extensions
+    module Repositories
+      module Postgres
+        module Update
+          def save(input)
+            entity = wrap(input)
+            entity.updated_at = Time.now.utc
+            row = to_row(entity)
+            new_row = dataset.returning.where(primary_key => row[primary_key]).update(row).first
+            new_attrs = from_row(new_row)
+            entity.set_attributes(new_attrs)
+            entity
+          end
+        end
+      end
+    end
+  end
+end

data/lib/luna_park/extensions/serializable.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+require 'luna_park/errors'
+
+module LunaPark
+  module Extensions
+    # @example
+    #   class Money
+    #     include LunaPark::Extensions::Comparable
+    #
+    #     attr_accessor :amount, :currency, :meta
+    #
+    #     serializable_attributes :amount, :currency
+    #   end
+    #
+    #   money = Money.new
+    #   money.to_h             # => {}
+    #   money.amount = 1
+    #   money.to_h             # => { amount: 1 }
+    #   money.currency = 'USD'
+    #   money.meta     = 'meta'
+    #   money.to_h             # => { amount: 1, currency: 'USD' }
+    module Serializable
+      def self.included(base)
+        base.extend  ClassMethods
+        base.include InstanceMethods
+      end
+
+      module ClassMethods
+        ##
+        # Describe methods list that will be used for serialization via `#to_h` and `#serialize` methods
+        def serializable_attributes(*names)
+          raise 'No attributes given' if names.compact.empty?
+
+          @serializable_attributes_list ||= []
+          @serializable_attributes_list |= names
+        end
+
+        ##
+        # List of methods that will be used for serialization via `#to_h` and `#serialize` methods
+        def serializable_attributes_list
+          return @serializable_attributes_list if @serializable_attributes_list
+
+          raise Errors::NotConfigured,
+                "You must set at least one serializable attribute using #{self}.serializable_attributes(*names)"
+        end
+
+        private
+
+        def inherited(child)
+          super
+          child.instance_variable_set(:@serializable_attributes_list, @serializable_attributes_list&.dup)
+        end
+      end
+
+      module InstanceMethods
+        ##
+        # Serialize object using methods, described with `::comparable_attributes` method
+        def serialize
+          self.class
+              .serializable_attributes_list
+              .each_with_object({}) do |field, output|
+            next unless instance_variable_defined?(:"@#{field}")
+
+            output[field] = serialize_value__(send(field))
+          end
+        end
+
+        ##
+        # For powerfull polymorphism with Hashes
+        alias to_h serialize
+
+        def inspect
+          attrs = self.class.serializable_attributes_list.map do |attr|
+            value = instance_variable_get(:"@#{attr}")
+            "#{attr}=#{value.inspect}" if value
+          end
+          "#<#{self.class.name} #{attrs.compact.join(' ')}>"
+        end
+
+        private
+
+        SERIALIZABLE = ->(o) { o.respond_to?(:serialize) }.freeze
+        HASHABLE     = ->(o) { o.respond_to?(:to_h) }.freeze
+
+        def serialize_value__(value) # rubocop:disable Metrics/CyclomaticComplexity
+          case value
+          when Array then value.map              { |v| serialize_value__(v) } # TODO: work with Array (wrap values)
+          when Hash  then value.transform_values { |v| serialize_value__(v) }
+          when nil   then nil
+          when SERIALIZABLE then value.serialize
+          when HASHABLE     then value.to_h
+          else value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/luna_park/extensions/severity_levels.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module LunaPark
+  module Extensions
+    module SeverityLevels
+      # This is class  define interface for loggers and notifiers behavior.
+      # In main idea it based on rfc5424 https://tools.ietf.org/html/rfc5424, but
+      # in fact default ruby logger does not define all severities, and we use only
+      # most important:
+      #  - unknown: an unknown message that should always be logged
+      #  - fatal: An unhandleable error that results in a program crash
+      #  - error: system work incorrectly, and maintainer should know about that immediately
+      #  - warning: warning conditions, and maintainer should know about that, but not immediately
+      #  - info: informational messages, maintainer should know about that, if they want to analyse logs
+      #  - debug: debug messages, for developers don't use it on production
+      #
+      # @example
+      #   class ChattyLogger < LunaPark::Notifiers::Abstract
+      #     def message(obj, _details:, lvl:)
+      #       puts "{lvl.upcase}: #{message}"
+      #     end
+      #   end
+      #
+      #   logger = ChattyLogger.new min_lvl: :warning
+      #   logger.unknown 'Do not do that.' # => 'UNKNOWN: Do not do that.'
+      #   logger.fatal 'Do not do that.'   # => 'FATAL: Do not do that.'
+      #   logger.error 'Do not do that.'   # => 'ERROR: Do not do that.'
+      #   logger.warning 'Do not do that.' # => 'WARNING: Do not do that.'
+      #   logger.info 'Do not do that.'    # => nil
+      #   logger.debug 'Do not do that.'   # => nil
+      LEVELS = %i[debug info warning error fatal unknown].freeze
+
+      # Defined minimum severity level
+      def min_lvl
+        @min_lvl ||= :debug
+      end
+
+      def min_lvl=(value)
+        raise ArgumentError, 'Undefined severity level' unless LEVELS.include? value
+
+        @min_lvl = value
+      end
+
+      # rubocop:disable Style/GuardClause
+
+      # Post message with UNKNOWN severity level
+      #
+      # @param msg [String,Exception]
+      # @param details [Hash]
+      def unknown(msg = '', **details)
+        message = block_given? ? yield : msg
+        post message, lvl: :unknown, **details
+      end
+
+      # Post message with FATAL severity level
+      #
+      # @param msg [String,Exception]
+      # @param details [Hash]
+      def fatal(msg = '', **details)
+        if %i[debug info warning error fatal].include? min_lvl
+          message = block_given? ? yield : msg
+          post message, lvl: :fatal, **details
+        end
+      end
+
+      # Post message with ERROR severity level
+      #
+      # @param msg [String,Exception]
+      # @param details [Hash]
+      def error(msg = '', **details)
+        if %i[debug info warning error].include? min_lvl
+          message = block_given? ? yield : msg
+          post message, lvl: :error, **details
+        end
+      end
+
+      # Post stdout message with WARNING severity level
+      #
+      # @param msg [String,Exception]
+      # @param details [Hash]
+      def warning(msg = '', **details)
+        if %i[debug info warning].include? min_lvl
+          message = block_given? ? yield : msg
+          post message, lvl: :warning, **details
+        end
+      end
+
+      # Post message with INFO  severity level
+      #
+      # @example
+      #
+      # @param msg [String,Exception]
+      # @param details [Hash]
+      def info(msg = '', **details)
+        if %i[debug info].include? min_lvl
+          message = block_given? ? yield : msg
+          post message, lvl: :info, **details
+        end
+      end
+
+      # Post message with DEBUG severity level
+      #
+      # @param msg [String,Exception]
+      # @param details [Hash]
+      def debug(msg = '', **details)
+        if min_lvl == :debug
+          message = block_given? ? yield : msg
+          post message, lvl: :debug, **details
+        end
+      end
+
+      # rubocop:enable Style/GuardClause
+
+      # @abstract
+      def post(_msg = '', _lvl:, **_details)
+        raise Errors::AbstractMethod
+      end
+    end
+  end
+end