composable-core 0.0.4 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a9bcadd807c77480fa834c65abcccdb7ec5cf1ea2808575c6c2137ca331d07c
-  data.tar.gz: 4ebebe834f4807f3c7b641724a7199bc0f6c19adcbde352a49b6520215249f41
+  metadata.gz: 7d56d2c41394ea626296bdcfef8a547e272e7202c872972d6ea4b749ebcff538
+  data.tar.gz: b9f1d63e63db227c16cb45d5e702d32df51c1774fff1dc8c7ed8e002fae36f8b
 SHA512:
-  metadata.gz: 815641fddf905a9348f40afc64d0ed62c2bc286fa34e0be0cf0d0785c52bc57e2d39a8655897d75a84a17121dfa3c8548cb1967a30857837e6dc93268097e350
-  data.tar.gz: 8374f9fdd9724d97e1e7eef2ab21fbb39e33ef36b6ce0e77970371fc5b16552ac95542173fbe17aadd5da36852cdb223087a8709a178eb8913bff640b12ea9b4
+  metadata.gz: e0f79489b8c6c33dfe0d0bdb8d76fe8ee08be37a00749ebb5fe4c7050ff4d336e3f3f7af56224f049f1334d9933095e3a5e23e458aca516e5b047ac7f2018614
+  data.tar.gz: 415dfb4b81b6c069a9fb8c80b0a53b3c52be68423f9063e3da35e2d98e768227b134ba5ffc708aadf444fb1c6b832c316b468c4d1bb6896268ea4812505fabac

data/lib/composable/core/attribute_dsl.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Composable
+  module Core
+    module AttributeDSL
+      extend ActiveSupport::Concern
+      include InheritableAttributes
+
+      included do
+        inheritable_attributes :attributes, default: Set.new
+        inheritable_attributes :_attribute_options, default: {}
+      end
+
+      def initialize(options = {})
+        unless options.respond_to?(:has_key?)
+          raise ArgumentError, "When assigning attributes, you must pass a hash" \
+                               " as an argument, #{options.class} passed."
+        end
+
+        attributes.each do |attribute|
+          # Try a `string` key if `symbol` key does not exist
+          value = options.fetch(attribute.to_sym, options[attribute.to_s])
+          send("#{attribute}=", value) unless value.nil?
+        end
+      end
+
+      def attributes
+        self.class.attributes
+      end
+
+      def params
+        attributes.each_with_object({}) do |attribute, hash|
+          hash[attribute] = send(attribute)
+        end
+      end
+
+      module ClassMethods
+        def attribute(*attrs)
+          options = attrs.extract_options!
+
+          return attributes if attrs.empty?
+
+          attrs.each do |attribute|
+            _save_options_for(attribute, **options)
+
+            next if attributes.include?(attribute.to_sym)
+
+            _define_getter(attribute)
+            _define_setter(attribute)
+            _define_question_mark_method(attribute)
+            attributes << attribute.to_sym
+          end
+        end
+
+        private
+
+        def _define_getter(attribute)
+          define_method(attribute) do
+            options = self.class._attribute_options.fetch(attribute.to_sym, {})
+            value = if instance_variable_defined?("@#{attribute}")
+              instance_variable_get("@#{attribute}")
+            else
+              instance_variable_set("@#{attribute}", options[:default].deep_dup)
+            end
+
+            options[:type] ? options[:type].cast(value) : value
+          end
+        end
+
+        def _define_setter(attribute)
+          define_method("#{attribute}=") do |value|
+            options = self.class._attribute_options.fetch(attribute.to_sym, {})
+            instance_variable_set("@#{attribute}", options[:type] ? options[:type].cast(value) : value)
+          end
+        end
+
+        def _define_question_mark_method(attribute)
+          define_method("#{attribute}?") do
+            send(attribute).present?
+          end
+        end
+
+        def _save_options_for(attribute, type: nil, default: nil, **typed_options)
+          options = _attribute_options[attribute.to_sym] ||= {}
+          options[:default] = default unless default.nil?
+          options[:type] = ActiveModel::Type.lookup(type, **typed_options) unless type.nil?
+        end
+      end
+    end
+  end
+end

data/lib/composable/core/callbacks.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Composable
+  module Core
+    module Callbacks
+      extend ActiveSupport::Concern
+
+      included do
+        extend ActiveModel::Callbacks
+
+        define_model_callbacks :save
+      end
+    end
+  end
+end

data/lib/composable/core/command.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Composable
+  module Core
+    module Command
+      class NotImplementedError < ::StandardError; end
+
+      attr_reader :result
+
+      module ClassMethods
+        def call(*args, **kwargs)
+          new(*args, **kwargs).call
+        end
+
+        def call!(*args, **kwargs)
+          new(*args, **kwargs).call(raise_exception: true)
+        end
+      end
+
+      def self.prepended(base)
+        base.extend ClassMethods
+
+        base.include ActiveModel::Validations
+        base.include ActiveSupport::Rescuable
+      end
+
+      def call(raise_exception: false)
+        fail NotImplementedError unless defined?(super)
+
+        @called = true
+        @result = super()
+
+        raise Error, errors.full_messages.to_sentence if raise_exception && failure?
+
+        self
+      rescue Exception => exception
+        raise if raise_exception || !rescue_with_handler(exception)
+
+        self
+      end
+
+      def success?
+        called? && !failure?
+      end
+
+      def failure?
+        called? && errors.any?
+      end
+
+      private
+
+      def called?
+        @called ||= false
+      end
+    end
+  end
+end

data/lib/composable/core/composable_dsl.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+module Composable
+  module Core
+    module ComposableDSL
+      extend ActiveSupport::Concern
+      include InheritableAttributes
+
+      included do
+        inheritable_attributes :composables, default: {}
+      end
+
+      module ClassMethods
+        def composable(attribute, **options, &block)
+          composables[attribute.to_sym] ||= Composable.new(attribute)
+          composables[attribute.to_sym].evaluate(**options, &block)
+
+          return if attributes.include?(attribute.to_sym)
+
+          attribute attribute
+
+          alias_method "#{attribute}_original_setter=", "#{attribute}="
+
+          define_method("#{attribute}=") do |value|
+            send("#{attribute}_original_setter=", value)
+            composables[attribute.to_sym].sync_attributes(
+              self, composable_record_for(attribute), reverse: true
+            )
+          end
+        end
+      end
+
+      # In order to prevent attribute values passed in at initialize from being
+      # overridden by composable_record values, composable_record mapping methods
+      # have to be synced first.
+      def initialize(options = {})
+        composable_keys.each do |attribute|
+          value = options.delete(attribute) || options.delete(attribute.to_s)
+          send("#{attribute}=", value) if value
+        end
+
+        super
+      end
+
+      def composables
+        self.class.composables
+      end
+
+      def save_composables
+        multi_db_transaction do
+          sync_composable_records
+          save_composable_records
+
+          yield if block_given?
+        end
+      end
+
+      private
+
+      def sync_composable_records
+        composables.each do |attribute, composable|
+          record = composable_record_for(attribute)
+          composable.sync_attributes(self, record) if composable.valid?(self, record)
+        end
+      end
+
+      def save_composable_records
+        composables.each do |attribute, composable|
+          record = composable_record_for(attribute)
+          record.save! if composable.valid?(self, record)
+        end
+      end
+
+      # Ensures `save!` queries are wrapped within multiple db transactions.
+      # It might be the case that our service is working with several composable
+      # objects that are gonna be saved into diffent databases, if there is an
+      # error, all transactions are gonna be rollback regardless of the DB.
+      def multi_db_transaction(attribute: composable_keys.first, &block)
+        return yield if attribute.nil?
+
+        index = composable_keys.index(attribute)
+        record = composable_record_for(attribute)
+
+        multi_db_transaction(attribute: composable_keys[index + 1]) do
+          record.respond_to?(:transaction) ? record.transaction(&block) : yield
+        end
+      end
+
+      def composable_keys
+        @composable_keys ||= composables.keys.freeze
+      end
+
+      def composable_record_for(attribute)
+        send(attribute) or
+          raise ArgumentError, "required composable argument: #{attribute}"
+      end
+
+      class Composable
+        attr_reader :attribute, :mapping, :conditions
+
+        def initialize(attribute)
+          @attribute = attribute
+          @mapping = {}
+          @conditions = Conditions.new
+        end
+
+        def initialize_copy(original_object)
+          @mapping = original_object.mapping.deep_dup
+          @conditions = original_object.conditions.deep_dup
+        end
+
+        def evaluate(**options, &block)
+          conditions.merge(**options)
+
+          instance_eval(&block) if block
+        end
+
+        def sync_attributes(form, record, reverse: false)
+          mapping.each_value do |instance|
+            instance.sync(form, record, reverse: reverse)
+          end
+        end
+
+        def valid?(...)
+          conditions.valid?(...)
+        end
+
+        private
+
+        # DSL method
+        def sync(*args, to: nil, **options)
+          args.extract_options!
+
+          args.compact.uniq.each do |name|
+            mapping[name.to_sym] ||= Sync.new(from: name)
+            mapping[name.to_sym].merge(to: (to || name), **options)
+          end
+        end
+
+        class Sync
+          attr_reader :from, :to, :conditions
+
+          def initialize(from:)
+            @from = from.to_sym
+            @conditions = Conditions.new
+          end
+
+          def initialize_copy(original_object)
+            @conditions = original_object.conditions.deep_dup
+          end
+
+          def merge(to:, **options)
+            @to = to.to_sym
+
+            conditions.merge(**options)
+          end
+
+          def sync(form, record, reverse: false)
+            if reverse
+              form.send("#{from}=", record.send(to))
+            else
+              value = form.send(from)
+              record.send("#{to}=", value) if conditions.valid?(form, record)
+            end
+          end
+        end
+
+        class Conditions
+          attr_reader :conditions
+
+          def initialize
+            @conditions = {}
+          end
+
+          def initialize_copy(original_object)
+            @conditions = original_object.conditions.deep_dup
+          end
+
+          def merge(**options)
+            options.symbolize_keys.slice(:if, :unless).each do |statement, condition|
+              conditions[statement] = Condition.new(statement, condition)
+            end
+          end
+
+          def valid?(form, record)
+            conditions.values.all? { |condition| condition.call(form, record) }
+          end
+        end
+
+        class Condition
+          attr_reader :condition, :statement, :callable
+
+          def initialize(statement, condition)
+            @statement = statement.to_sym
+            @condition = condition
+            @callable = make_lambda
+          end
+
+          def call(form, record)
+            callable.call(form, record).eql?(statement == :if)
+          end
+
+          private
+
+          def make_lambda
+            case condition
+            when Symbol
+              ->(form, _record) { form.send(condition) }
+            when ::Proc
+              lambda { |form, record|
+                form.instance_exec(*[record][0...condition.arity], &condition)
+              }
+            else
+              ->(*) { true }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/composable/core/gem_version.rb

@@ -10,7 +10,7 @@ module Composable
     module VERSION
       MAJOR = 0
       MINOR = 0
-      TINY  = 4
+      TINY  = 7
       PRE   = nil
 
       STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")

data/lib/composable/core/inheritable_attributes.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Composable
+  module Core
+    module InheritableAttributes
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def inheritable_attributes(*attributes)
+          options = attributes.extract_options!
+
+          @inheritable_attributes ||= [{attribute: :inheritable_attributes}]
+          attributes.each do |attribute|
+            @inheritable_attributes << {attribute: attribute, default: options[:default]}
+
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              class << self; attr_accessor :#{attribute} end
+            RUBY
+            send("#{attribute}=", options[:default]) unless options[:default].nil?
+          end
+          @inheritable_attributes
+        end
+
+        def uninheritable_attributes(*attributes)
+          options = attributes.extract_options!
+
+          @uninheritable_attributes ||= [{attribute: :uninheritable_attributes}]
+
+          attributes.each do |attribute|
+            @uninheritable_attributes << {attribute: attribute, default: options[:default]}
+
+            class_eval <<-RUBY, __FILE__, __LINE__ + 1
+              class << self; attr_accessor :#{attribute} end
+            RUBY
+            send("#{attribute}=", options[:default]) unless options[:default].nil?
+          end
+
+          @uninheritable_attributes
+        end
+
+        def inherited(subclass)
+          super
+
+          Array(@inheritable_attributes).each do |hash|
+            inheritable_attribute = hash[:attribute]
+            instance_name = "@#{inheritable_attribute}"
+            instance_value = instance_variable_get(instance_name).deep_dup
+            subclass.instance_variable_set(instance_name, instance_value || hash[:default].deep_dup)
+          end
+
+          Array(@uninheritable_attributes).each do |hash|
+            uninheritable_attribute = hash[:attribute]
+            instance_name = "@#{uninheritable_attribute}"
+
+            if instance_name == "@uninheritable_attributes"
+              instance_value = instance_variable_get(instance_name).deep_dup
+              subclass.instance_variable_set(instance_name, instance_value)
+            else
+              subclass.instance_variable_set(instance_name, hash[:default].deep_dup)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/composable/core/record_invalid.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Composable
+  module Core
+    module RecordInvalid
+      extend ActiveSupport::Concern
+      include ActiveSupport::Rescuable
+
+      class ErrorWithRecord < Exception
+        attr_reader :record
+
+        def initialize(record)
+          @record = record
+        end
+      end
+
+      included do
+        prepend ComposableDSLExt
+
+        rescue_from(ErrorWithRecord) do |exception|
+          exception.record.errors.delete(:base)&.each { |m| errors.add(:base, m) }
+          exception.record.errors.each do |error|
+            if error.attribute.to_sym.in?(attributes)
+              errors.add(error.attribute, error.message)
+            else
+              errors.add(:base, exception.record.errors.full_message(error.attribute, error.message))
+            end
+          end
+        end
+      end
+
+      module ComposableDSLExt
+        def save_composable_records
+          super
+        rescue ActiveRecord::RecordInvalid => exception
+          raise ErrorWithRecord.new(exception.record)
+        end
+      end
+    end
+  end
+end
+
+Composable::Core::ComposableDSL.include Composable::Core::RecordInvalid

data/lib/composable/core.rb

@@ -1,9 +1,20 @@
 # frozen_string_literal: true
 
 require_relative "core/version"
+require "active_support"
+require "active_support/core_ext/object/deep_dup"
+require "active_model"
 
 module Composable
   module Core
     class Error < StandardError; end
+
+    autoload :AttributeDSL, "composable/core/attribute_dsl"
+    autoload :Callbacks, "composable/core/callbacks"
+    autoload :Command, "composable/core/command"
+    autoload :ComposableDSL, "composable/core/composable_dsl"
+    autoload :InheritableAttributes, "composable/core/inheritable_attributes"
   end
 end
+
+require "composable/core/record_invalid" if defined?(ActiveRecord)

metadata

@@ -1,15 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: composable-core
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.7
 platform: ruby
 authors:
 - Jairo Vazquez
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-01-25 00:00:00.000000000 Z
-dependencies: []
+date: 2022-08-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
 description: Core composable object to work with ruby services and forms
 email:
 - jairovm20@gmail.com
@@ -21,7 +49,13 @@ files:
 - LICENSE.txt
 - README.md
 - lib/composable/core.rb
+- lib/composable/core/attribute_dsl.rb
+- lib/composable/core/callbacks.rb
+- lib/composable/core/command.rb
+- lib/composable/core/composable_dsl.rb
 - lib/composable/core/gem_version.rb
+- lib/composable/core/inheritable_attributes.rb
+- lib/composable/core/record_invalid.rb
 - lib/composable/core/version.rb
 homepage: https://github.com/jairovm/composables
 licenses:
@@ -45,7 +79,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.17
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: Core Composable Object