golden-objects 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4854525e660454fcdcd717c48e05addb718eb6571e7ee2203068587968bc570d
+  data.tar.gz: b12b5850a5da5b637fe56005acf318a22085347dd9a22483dfc52bd24204978e
+SHA512:
+  metadata.gz: ab570549fa989c52516de15a1c87a2439f3aba9928ef5563f9c9e02e82daa270c88f8c55cbd9936eaff22c23a6147a731d3bb3299f56b96fc17cbf50fb50324d
+  data.tar.gz: d149d32f6989842cb7407323d56a160651cb820f030f5b9ce5b649bfefa6ca7202ed5892e18e23745b3a9bb7c9fc9c6d6826e0088904ce0bf877bdc57bee693c

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/Gemfile.lock

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Change Logs
+
+### v0.1.0
+
+* Initial release.

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in golden-objects.gemspec
+gemspec
+
+gem 'rake', '~> 12.0'

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Tse-Ching Ho
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,101 @@
+# Golden::Objects
+
+Provide ruby classes and modules help you build business logics as ruby components.
+
+Let's compose business logics as ruby components to improve efficiency of maintenance.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'golden-objects'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install golden-objects
+
+## Usage
+
+Create your class and inherite appropriate golden object directly or thought another class.
+
+```
+class ApplicationPresenter < Golden::ApplicationPresenter
+  include Rails.application.routes.url_helpers
+end
+
+class CartPresenter < ApplicationPresenter
+  attr_accessor :product_variants
+
+  def line_items_presenter
+    @line_items_presenter ||= CartLineItemPresenter.all(product_variants: product_variants)
+  end
+end
+```
+
+And put into suggested pathes.
+
+* business logic classes => app/components
+* data model logic classes => app/objects
+
+Grouping classes by multi layers of folders are also suggested.
+
+```
+app/components/[major business logic]/[secondary business logic]/xxx_xxx.rb
+app/objects/[major data model logic]/[secondary data model logic]/xxx_xxx.rb
+```
+
+For example:
+
+```
+app/components/identity/profile/update_form.rb
+app/components/frontend/popup_cart/main_presenter.rb
+app/objects/orders/line_item/create_operator.rb
+app/objects/orders/create_operator.rb
+```
+
+## Modules
+
+3 kinds of modules are provied.
+
+* attribute accessors
+* active model concerns
+* active record concerns
+
+## Objects
+
+3 groups of objects are provied.
+
+* Application objects
+  * Golden::ApplicationCalculator
+  * Golden::ApplicationContext
+  * Golden::ApplicationForm
+  * Golden::ApplicationGenerator
+  * Golden::ApplicationOperator
+  * Golden::ApplicationPresenter
+  * Golden::ApplicationService
+  * Golden::ApplicationTransformer
+* Form objects
+  * Golden::ActionFormOperator
+  * Golden::ActiveRecordForm
+  * Golden::SingleFormPresenter
+* Query objects
+  * Golden::QueryContext
+  * Golden::QueryForm
+  * Golden::QueryFormOperator
+  * Golden::QueryResultPresenter
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/goldenio/golden-objects.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler/gem_tasks'
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'golden/objects'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require 'pry'
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/golden-objects.gemspec

@@ -0,0 +1,32 @@
+require_relative 'lib/golden/objects/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'golden-objects'
+  spec.version       = Golden::Objects::VERSION
+  spec.authors       = ['Tse-Ching Ho']
+  spec.email         = ['tsechingho@gmail.com']
+
+  spec.summary       = %q{Provide ruby classes and modules help you build business logics as ruby components.}
+  spec.description   = %q{Let's compose business logics as ruby components to improve efficiency of maintenance.}
+  spec.homepage      = 'https://github.com/goldenio/golden-objects'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
+
+  # spec.metadata['allowed_push_host'] = 'https://github.com'
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/goldenio/golden-objects.git'
+  spec.metadata['changelog_uri'] = 'https://github.com/goldenio/golden-objects/CHANGELOG.md'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activesupport', '>= 5.2'
+  spec.add_dependency 'activemodel', '>= 5.2'
+  spec.add_dependency 'activerecord', '>= 5.2'
+end

data/lib/golden/active_model_concerns/datepicker_concern.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Golden
+  module DatepickerConcern
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def permit_datepicker_of(fields, attrs)
+        fields.each do |field|
+          attrs.delete(field)
+          attrs.push(field => [])
+        end
+      end
+    end
+
+    def filter_dates_of_datepicker(fields, attrs)
+      fields.each do |field|
+        dates = attrs.delete(field)
+        attrs[field] = date_of_datepicker(dates)
+      end
+    end
+
+    def filter_duration_of_datepicker(field, attrs)
+      return [] unless attrs.key? field
+
+      dates = attrs.delete(field)
+      duration_of_datepicker(dates)
+    end
+
+    private
+
+    def date_of_datepicker(values)
+      values.is_a?(Array) ? (values.first || '') : values
+    end
+
+    def duration_of_datepicker(values)
+      first_date = values.is_a?(Array) ? (values.first || '') : values
+      last_date = values.is_a?(Array) && values.size > 1 ? (values.last || '') : ''
+      [first_date, last_date]
+    end
+  end
+end

data/lib/golden/active_model_concerns/has_persisted_record_concern.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Golden
+  module HasPersistedRecordConcern
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # Outcome:
+      #   * xxx_id
+      #   * xxx_id=
+      #   * xxx
+      #   * xxx=
+      #   * load_persisted_attributes_of_xxx_by
+      #   * load_persisted_attributes_of_xxx
+      #
+      # Add validation if needed
+      #   validates :xxx, presence: true
+      #
+      # rubocop:disable Naming/PredicateName
+      def has_persisted_record(name, class_name: nil)
+        class_name ||= name.to_s.classify
+        klass = class_name.constantize
+        attr_accessor "#{name}_id"
+        attr_writer name
+
+        define_method name do
+          if instance_variable_get(:"@#{name}").blank?
+            object = klass.find_by id: instance_variable_get(:"@#{name}_id")
+            instance_variable_set(:"@#{name}", object) unless object.nil?
+          end
+          instance_variable_get(:"@#{name}")
+        end
+
+        define_method :"load_persisted_attributes_of_#{name}_by" do |id:|
+          instance_variable_set(:"@#{name}_id", id)
+          object = send(name)
+          send(:"load_persisted_attributes_of_#{name}", object)
+        end
+
+        define_method :"load_persisted_attributes_of_#{name}" do |object|
+          return {} if object.nil?
+
+          instance_variable_set(:"@#{name}", object) if instance_variable_get(:"@#{name}").blank?
+
+          attrs = object.attributes.symbolize_keys
+          return attrs unless self.class.respond_to? :permits
+
+          attrs.slice(*self.class.permits)
+        end
+      end
+      # rubocop:enable Naming/PredicateName
+    end
+  end
+end

data/lib/golden/active_model_concerns/yaml_coder_concern.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Golden
+  module YamlCoderConcern
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def load(yaml)
+        obj = YAML.safe_load(yaml, [Symbol]) if yaml.is_a?(String) && /^---/.match?(yaml)
+        obj.is_a?(Hash) ? new(obj || {}) : obj
+      end
+
+      def dump(obj)
+        return if obj.nil?
+
+        if obj.respond_to? :to_h
+          YAML.dump obj.to_h
+        else
+          assert_valid_value(obj, action: 'dump')
+          YAML.dump obj
+        end
+      end
+
+      private
+
+      def assert_valid_value(obj, action:)
+        return if obj.nil? || obj.is_a?(self)
+
+        error = %(
+          can't #{action}: was supposed to be a #{name},
+          but was a #{obj.class.name}. -- #{obj.inspect}
+        ).gsub(/\s+/, ' ').strip
+
+        if ::Object.const_defined? 'ActiveRecord'
+          raise ::ActiveRecord::SerializationTypeMismatch, error
+        else
+          raise ::Golden::Objects::Error, error
+        end
+      end
+    end
+  end
+end

data/lib/golden/active_model_concerns.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'golden/active_model_concerns/has_persisted_record_concern'
+require 'golden/active_model_concerns/yaml_coder_concern'
+require 'golden/active_model_concerns/datepicker_concern'
+
+module Golden
+  module ActiveModelConcerns
+  end
+end

data/lib/golden/active_record_concerns/deleted_at_concern.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Golden
+  module DeletedAtConcern
+    extend ActiveSupport::Concern
+
+    included do
+      scope :undeleted, -> { where(deleted_at: nil) }
+      scope :deleted, -> { where.not(deleted_at: nil) }
+    end
+
+    def soft_destroy!
+      update deleted_at: Time.zone.now
+    end
+
+    def deleted?
+      deleted_at?
+    end
+
+    def undeleted?
+      !deleted?
+    end
+  end
+end

data/lib/golden/active_record_concerns/disabled_at_concern.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Golden
+  module DisabledAtConcern
+    extend ActiveSupport::Concern
+
+    included do
+      scope :enabled, -> { where(disabled_at: nil) }
+      scope :disabled, -> { where.not(disabled_at: nil) }
+    end
+
+    def disable!
+      update disabled_at: Time.zone.now
+    end
+
+    def enable!
+      update disabled_at: nil
+    end
+
+    def disabled?
+      disabled_at?
+    end
+
+    def enabled?
+      !disabled?
+    end
+  end
+end

data/lib/golden/active_record_concerns/enum_value_concern.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Golden
+  module EnumValueConcern
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def human_attribute_enum_value(attribute_name, value)
+        return if value.blank?
+
+        human_attribute_name("#{attribute_name}.#{value}")
+      end
+
+      def enum_options_for_select(attribute_name)
+        enums = send(attribute_name.to_s.pluralize)
+        enums.values.uniq.map do |value|
+          key = enums.key(value)
+          [human_attribute_enum_value(attribute_name, key), key]
+        end.to_h
+      end
+    end
+
+    def human_attribute_enum(attribute_name)
+      self.class.human_attribute_enum_value(attribute_name, send(attribute_name))
+    end
+  end
+end

data/lib/golden/active_record_concerns/rejected_at_concern.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Golden
+  module RejectedAtConcern
+    extend ActiveSupport::Concern
+
+    included do
+      scope :not_rejected, -> { where(rejected_at: nil) }
+      scope :rejected, -> { where.not(rejected_at: nil) }
+    end
+
+    def cancel_reject!
+      update rejected_at: nil, rejected_by: nil
+    end
+
+    def rejected?
+      rejected_at?
+    end
+
+    def not_rejected?
+      !rejected?
+    end
+  end
+end

data/lib/golden/active_record_concerns.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'golden/active_record_concerns/enum_value_concern'
+require 'golden/active_record_concerns/deleted_at_concern'
+require 'golden/active_record_concerns/disabled_at_concern'
+require 'golden/active_record_concerns/rejected_at_concern'
+
+module Golden
+  module ActiveRecordConcerns
+  end
+end

data/lib/golden/attribute_accessors/boolean_accessor.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Golden
+  module BooleanAccessor
+    extend ActiveSupport::Concern
+
+    TRUE_VALUES = [
+      true, 1, '1',
+      'true', 'TRUE', 'True', 't', 'T',
+      'yes', 'YES', 'Yes', 'y', 'Y'
+    ].freeze
+
+    class_methods do
+      def boolean_accessor(*attributes, allow_nil: false)
+        [*attributes].uniq.each do |attribute_name|
+          attr_accessor attribute_name
+
+          class_eval do
+            define_method("#{attribute_name}?") do
+              instance_variable_get("@#{attribute_name}")
+            end
+
+            define_method("#{attribute_name}=") do |value|
+              boolean = TRUE_VALUES.include?(value)
+              boolean = nil if allow_nil && value.is_a?(String) && value.blank?
+              boolean = nil if allow_nil && value.is_a?(NilClass)
+              instance_variable_set("@#{attribute_name}", boolean)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/golden/attribute_accessors/date_time_accessor.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'active_support/time_with_zone'
+
+module Golden
+  module DateTimeAccessor
+    extend ActiveSupport::Concern
+
+    class_methods do
+      # rubocop:disable Metrics/CyclomaticComplexity
+      def datetime_accessor(*attributes, date_only: false)
+        [*attributes].uniq.each do |attribute_name|
+          attr_accessor attribute_name
+
+          class_eval do
+            define_method("#{attribute_name}?") do
+              instance_variable_get("@#{attribute_name}")
+            end
+
+            define_method("#{attribute_name}=") do |value|
+              case value
+              when ActiveSupport::TimeWithZone
+                time = value
+              when Date, Time, DateTime
+                time = value
+              when String
+                time = parse_time(value)
+              when NilClass
+                time = nil
+              else
+                raise "#{value.class} is unsupported!"
+              end
+              time = time.to_date if time && date_only
+              instance_variable_set("@#{attribute_name}", time)
+            end
+          end
+        end
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity
+
+      def date_accessor(*attributes)
+        datetime_accessor(*attributes, date_only: true)
+      end
+    end
+
+    def parse_time(string, zone: Golden::AttributeAccessors.default_zone)
+      ActiveSupport::TimeZone.new(zone)&.parse(string)
+    rescue StandardError
+      nil
+    end
+  end
+end

data/lib/golden/attribute_accessors/enum_accessor.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Golden
+  module EnumAccessor
+    extend ActiveSupport::Concern
+
+    class_methods do
+      def enum_accessor(*attributes, model:)
+        [*attributes].uniq.each do |attribute_name|
+          plural_name = attribute_name.to_s.pluralize
+          model = model.constantize unless model.is_a?(Class)
+
+          attr_accessor attribute_name
+
+          define_singleton_method(plural_name) do
+            alias_name = "#{plural_name}_alias"
+            values = model.send(plural_name).clone
+            values.merge!(model.send(alias_name)) if model.respond_to?(alias_name)
+            values
+          end
+
+          class_eval do
+            define_method("#{attribute_name}=") do |value|
+              enum_value = self.class.send(plural_name)[value]
+              enum_key = model.send(plural_name).key(enum_value)
+              instance_variable_set("@#{attribute_name}", enum_key)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/golden/attribute_accessors/extended_attr_accessor.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Golden
+  module ExtendedAttrAccessor
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :attribute_accessors, instance_accessor: false, default: []
+    end
+
+    class_methods do
+      def attr_accessor(*attrs)
+        self.attribute_accessors += attrs.map(&:to_sym)
+        self.attribute_accessors.uniq!
+        super(*attrs)
+      end
+
+      def accessor_attributes
+        @accessor_attributes ||= attribute_accessors.dup
+      end
+      alias_method :attributes, :accessor_attributes unless respond_to? :attributes
+
+      private
+
+      def merge_attributes!(*attrs)
+        accessor_attributes.concat(attrs.map(&:to_sym)).uniq!
+      end
+
+      def delete_attributes!(*attrs)
+        attrs.each { |attr| accessor_attributes.delete(attr) }
+      end
+    end
+
+    # NOTE: conflict with ActiveModel::Attributes#attributes
+    def attributes
+      self.class.attributes.inject({}) do |hash, attribute|
+        hash.merge(attribute => public_send(attribute))
+      end.with_indifferent_access
+    end
+
+    def strip_attributes(attrs)
+      attrs.transform_values do |value|
+        value.respond_to?(:strip) ? value.strip : value
+      end
+    end
+
+    def strip_attributes!(attrs)
+      attrs.transform_values do |value|
+        value.respond_to?(:strip!) ? value.strip! : value
+      end
+    end
+  end
+end