composable-core 0.0.2 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d56d924c8b49a41a1dd25112961b582c628ac71f6f16d4d8bcc39e5a1c1dd657
-  data.tar.gz: e7417b50a4acb0540ecb9f0b4f46556f0db36d74866081dc9451e34dce702f3e
+  metadata.gz: a79063aeae6d1075137b90dd1f4979cd3ce45a217e0060ccdf3dea2653fb5cfe
+  data.tar.gz: 48941772dda21b2f50a0951be88764fe2084eac74447a91fab07c3c42c7e9ed9
 SHA512:
-  metadata.gz: e791a3a17e333488b297be1d3822a2fac9eebd9910ff0d3f4f3038b91087cc36cfe1505213c154b5efa8f7894b8aad7b4832ad2a64642ae4af91d47d85e64147
-  data.tar.gz: c3fe7a0ee96143036adde71194bc38d17d47caea05d662b6672f2f36ebad2296cbc1fc67b78b3f0d962da439c5425a19e45afec317dc92406a69e7ffb649f9e1
+  metadata.gz: a4b2074df7a43304080cdbff56f64b5bcf2bde0fcd6c8f7231ae52f3645ac3f94779b3e651c349c7d572010bbcf459be64b7f7a4b61af08c90d60651c61d24ee
+  data.tar.gz: 752c88d42e650202e19e65a6709dc65dda68b3806d3d52787a08c80f2ffecf0efc93d21dc8c5c7fdb2e13d5908c6233861e48b2153c5815b6cd93a8a2fd6cb77

data/CHANGELOG.md

@@ -1,5 +1,5 @@
 ## [Unreleased]
 
-## [0.1.0] - 2022-01-20
+## [0.0.1] - 2022-01-20
 
 - Initial release

data/README.md

@@ -9,7 +9,7 @@ TODO: Delete this and the text above, and describe your gem
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'core'
+gem 'composable-core'
 ```
 
 And then execute:
@@ -18,7 +18,7 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install core
+    $ gem install composable-core
 
 ## Usage
 
@@ -32,7 +32,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/jairovm/core. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/jairovm/composables/tree/main/core/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/jairovm/composables. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/jairovm/composables/tree/main/CODE_OF_CONDUCT.md).
 
 ## License
 
@@ -40,4 +40,4 @@ The gem is available as open source under the terms of the [MIT License](https:/
 
 ## Code of Conduct
 
-Everyone interacting in the Core project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/jairovm/composables/tree/main/core/CODE_OF_CONDUCT.md).
+Everyone interacting in the Core project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/jairovm/composables/tree/main/CODE_OF_CONDUCT.md).

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  = 2
+      TINY  = 5
       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.2
+  version: 0.0.5
 platform: ruby
 authors:
 - Jairo Vazquez
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-01-22 00:00:00.000000000 Z
-dependencies: []
+date: 2022-04-06 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,15 +49,21 @@ 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:
 - MIT
 metadata:
   homepage_uri: https://github.com/jairovm/composables
-  source_code_uri: https://github.com/jairovm/composables/tree/main/core
-  changelog_uri: https://github.com/jairovm/composables/tree/main/CHANGELOG.md
+  source_code_uri: https://github.com/jairovm/composables/tree/main/composable-core
+  changelog_uri: https://github.com/jairovm/composables/tree/main/composable-core/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -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