granite-form 0.1.0

data/lib/granite/form/model/localization.rb

@@ -0,0 +1,26 @@
+require 'granite/form/model/attributes/reflections/localized'
+require 'granite/form/model/attributes/localized'
+
+module Granite
+  module Form
+    module Model
+      module Localization
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def localized(*args, &block)
+            add_attribute(Granite::Form::Model::Attributes::Reflections::Localized, *args, &block)
+          end
+
+          def fallbacks(locale)
+            ::I18n.respond_to?(:fallbacks) ? ::I18n.fallbacks[locale] : [locale]
+          end
+
+          def locale
+            I18n.locale
+          end
+        end
+      end
+    end
+  end
+end

data/lib/granite/form/model/persistence.rb

@@ -0,0 +1,59 @@
+module Granite
+  module Form
+    module Model
+      module Persistence
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def instantiate(data)
+            data = data.stringify_keys
+            instance = allocate
+
+            instance.instance_variable_set(:@initial_attributes, data.slice(*attribute_names))
+            instance.send(:mark_persisted!)
+
+            instance
+          end
+
+          def instantiate_collection(data)
+            collection = Array.wrap(data).map { |attrs| instantiate attrs }
+            collection = scope(collection, true) if respond_to?(:scope)
+            collection
+          end
+        end
+
+        def persisted?
+          !!@persisted
+        end
+
+        def destroyed?
+          !!@destroyed
+        end
+
+        def marked_for_destruction?
+          @marked_for_destruction
+        end
+
+        def mark_for_destruction
+          @marked_for_destruction = true
+        end
+
+        def _destroy
+          marked_for_destruction?
+        end
+
+      private
+
+        def mark_persisted!
+          @persisted = true
+          @destroyed = false
+        end
+
+        def mark_destroyed!
+          @persisted = false
+          @destroyed = true
+        end
+      end
+    end
+  end
+end

data/lib/granite/form/model/primary.rb

@@ -0,0 +1,59 @@
+module Granite
+  module Form
+    module Model
+      module Primary
+        extend ActiveSupport::Concern
+        DEFAULT_PRIMARY_ATTRIBUTE_OPTIONS = lambda do
+          {
+            type: Granite::Form::UUID,
+            default: -> { Granite::Form::UUID.random_create }
+          }
+        end
+
+        included do
+          class_attribute :_primary_name, instance_writer: false
+          delegate :has_primary_attribute?, to: 'self.class'
+
+          prepend PrependMethods
+          alias_method :eql?, :==
+        end
+
+        module ClassMethods
+          def primary(*args)
+            options = args.extract_options!
+            self._primary_name = (args.first.presence || Granite::Form.primary_attribute).to_s
+            unless has_attribute?(_primary_name)
+              options[:type] = args.second if args.second
+              attribute _primary_name, options.presence || DEFAULT_PRIMARY_ATTRIBUTE_OPTIONS.call
+            end
+            alias_attribute :primary_attribute, _primary_name
+          end
+
+          alias_method :primary_attribute, :primary
+
+          def has_primary_attribute? # rubocop:disable Naming/PredicateName
+            has_attribute? _primary_name
+          end
+
+          def primary_name
+            _primary_name
+          end
+        end
+
+        module PrependMethods
+          def ==(other)
+            if other.instance_of?(self.class) && has_primary_attribute?
+              if primary_attribute
+                primary_attribute == other.primary_attribute
+              else
+                object_id == other.object_id
+              end
+            else
+              super(other)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/granite/form/model/representation.rb

@@ -0,0 +1,101 @@
+require 'active_model/version'
+require 'granite/form/model/attributes/reflections/represents'
+require 'granite/form/model/attributes/represents'
+
+module Granite
+  module Form
+    module Model
+      module Representation
+        extend ActiveSupport::Concern
+
+        included do
+          prepend PrependMethods
+        end
+
+        module PrependMethods
+          def assign_attributes(attrs)
+            if self.class.represented_attributes.present?
+              attrs = attrs.to_unsafe_hash if attrs.respond_to?(:to_unsafe_hash)
+              attrs = attrs.stringify_keys
+              represented_attrs = self.class.represented_names_and_aliases
+                .each_with_object({}) do |name, result|
+                result[name] = attrs.delete(name) if attrs.key?(name)
+              end
+
+              super(attrs.merge!(represented_attrs))
+            else
+              super(attrs)
+            end
+          end
+
+          alias_method :attributes=, :assign_attributes
+        end
+
+        module ClassMethods
+          def represents(*names, &block)
+            options = names.extract_options!
+            names.each do |name|
+              add_attribute(Granite::Form::Model::Attributes::Reflections::Represents, name, options, &block)
+            end
+          end
+
+          def represented_attributes
+            @represented_attributes ||= _attributes.values.select do |attribute|
+              attribute.is_a? Granite::Form::Model::Attributes::Reflections::Represents
+            end
+          end
+
+          def represented_names_and_aliases
+            @represented_names_and_aliases ||= represented_attributes.flat_map do |attribute|
+              [attribute.name, *inverted_attribute_aliases[attribute.name]]
+            end
+          end
+        end
+
+      private
+
+        def run_validations! #:nodoc:
+          super
+          emerge_represented_attributes_errors!
+          errors.empty?
+        end
+
+        # Move represent attribute errors to the top level:
+        #
+        #   {:'role.email' => ['Some error']}
+        #
+        # to:
+        #
+        #   {email: ['Some error']}
+        #
+        def emerge_represented_attributes_errors!
+          self.class.represented_attributes.each do |attribute|
+            move_errors(:"#{attribute.reference}.#{attribute.column}", attribute.column)
+          end
+        end
+
+        if ActiveModel.version >= Gem::Version.new('6.1.0')
+          def move_errors(from, to)
+            errors.where(from).each do |error|
+              options = error.options
+              # If we generate message for built-in validation, we don't want to later escape it in our monkey-patch
+              options = options.merge(message: error.message.html_safe) unless options.key?(:message)
+
+              errors.add(to, error.type, **options)
+            end
+
+            errors.delete(from)
+          end
+        else
+          # up to 6.0.x
+          def move_errors(from, to)
+            return unless errors.messages.key?(from) && errors.messages[from].present?
+
+            errors[to].concat(errors.messages[from])
+            errors.delete(from)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/granite/form/model/scopes.rb

@@ -0,0 +1,118 @@
+module Granite
+  module Form
+    module Model
+      module Scopes
+        extend ActiveSupport::Concern
+
+        included do
+          class_attribute :_scope_base
+          scopify
+        end
+
+        module ScopeProxy
+          extend ActiveSupport::Concern
+
+          def self.for(model)
+            klass = Class.new(model._scope_base) do
+              include Granite::Form::Model::Scopes::ScopeProxy
+            end
+            klass.define_singleton_method(:_scope_model) { model }
+            model.const_set('ScopeProxy', klass)
+          end
+
+          included do
+            def initialize(source = nil, trust = false)
+              source ||= self.class.superclass.new
+
+              unless trust && source.is_a?(self.class)
+                source.each do |entity|
+                  raise AssociationTypeMismatch.new(self.class._scope_model, entity.class) unless entity.is_a?(self.class._scope_model)
+                end
+              end
+
+              super source
+            end
+          end
+
+          def respond_to_missing?(method, _)
+            super || self.class._scope_model.respond_to?(method)
+          end
+
+          # rubocop:disable Style/MethodMissing
+          # rubocop-0.52.1 doesn't understand that `#respond_to_missing?` is defined above
+          if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('3.0.0')
+            def method_missing(method, *args, **kwargs, &block)
+              with_scope do
+                model = self.class._scope_model
+                if model.respond_to?(method)
+                  result = model.public_send(method, *args, **kwargs, &block)
+                  result.is_a?(Granite::Form::Model::Scopes) ? result : model.scope_class.new(result)
+                else
+                  super
+                end
+              end
+            end
+          elsif Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.7.0')
+            def method_missing(method, *args, **kwargs, &block)
+              with_scope do
+                model = self.class._scope_model
+                if model.respond_to?(method)
+                  model.public_send(method, *args, **kwargs, &block)
+                else
+                  super
+                end
+              end
+            end
+          else
+            # up to 2.6.x
+            def method_missing(method, *args, &block)
+              with_scope do
+                model = self.class._scope_model
+                if model.respond_to?(method)
+                  model.public_send(method, *args, &block)
+                else
+                  super
+                end
+              end
+            end
+          end
+          # rubocop:enable Style/MethodMissing
+
+          def with_scope
+            previous_scope = self.class._scope_model.current_scope
+            self.class._scope_model.current_scope = self
+            result = yield
+            self.class._scope_model.current_scope = previous_scope
+            result
+          end
+        end
+
+        module ClassMethods
+          def scopify(scope_base = Array)
+            self._scope_base = scope_base
+          end
+
+          def scope_class
+            @scope_class ||= Granite::Form::Model::Scopes::ScopeProxy.for(self)
+          end
+
+          def scope(*args)
+            if args.empty?
+              current_scope
+            else
+              scope_class.new(*args)
+            end
+          end
+
+          def current_scope=(value)
+            @current_scope = value
+          end
+
+          def current_scope
+            @current_scope ||= scope_class.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/granite/form/model/validations/associated.rb

@@ -0,0 +1,22 @@
+module Granite
+  module Form
+    module Model
+      module Validations
+        class AssociatedValidator < ActiveModel::EachValidator
+          def validate_each(record, attribute, value)
+            invalid_records = Array.wrap(value).reject do |r|
+              r.respond_to?(:valid?) && r.valid?(record.validation_context)
+            end
+            record.errors.add(attribute, :invalid, **options.merge(value: value)) if invalid_records.present?
+          end
+        end
+
+        module HelperMethods
+          def validates_associated(*attr_names)
+            validates_with AssociatedValidator, _merge_attributes(attr_names)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/granite/form/model/validations/nested.rb

@@ -0,0 +1,56 @@
+require 'active_model/version'
+
+module Granite
+  module Form
+    module Model
+      module Validations
+        class NestedValidator < ActiveModel::EachValidator
+          def self.validate_nested(record, name, value)
+            if value.is_a?(Enumerable)
+              value.each.with_index do |object, i|
+                import_errors(object.errors, record.errors, "#{name}.#{i}") if yield object
+              end
+            elsif value
+              import_errors(value.errors, record.errors, name.to_s) if yield value
+            end
+          end
+
+          if ActiveModel.version >= Gem::Version.new('6.1.0')
+            def self.import_errors(from, to, prefix)
+              from.each do |error|
+                key = "#{prefix}.#{error.attribute}"
+                to.import(error, attribute: key) unless to.added?(key, error.type, error.options)
+              end
+            end
+          else
+            # up to 6.0.x
+            def self.import_errors(from, to, prefix)
+              from.each do |key, message|
+                key = "#{prefix}.#{key}"
+                to[key] << message
+                to[key].uniq!
+              end
+            end
+          end
+
+          def validate_each(record, attribute, value)
+            self.class.validate_nested(record, attribute, value) do |object|
+              object.invalid? && !(object.respond_to?(:marked_for_destruction?) && object.marked_for_destruction?)
+            end
+          end
+        end
+
+        module HelperMethods
+          def validates_nested(*attr_names)
+            validates_with NestedValidator, _merge_attributes(attr_names)
+          end
+
+          def validates_nested?(attr)
+            _validators[attr.to_sym]
+              .grep(Granite::Form::Model::Validations::NestedValidator).present?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/granite/form/model/validations.rb

@@ -0,0 +1,29 @@
+module Granite
+  module Form
+    module Model
+      module Validations
+        extend ActiveSupport::Concern
+        include ActiveModel::Validations
+
+        included do
+          extend HelperMethods
+          include HelperMethods
+
+          alias_method :validate, :valid?
+        end
+
+        def validate!(context = nil)
+          valid?(context) || raise_validation_error
+        end
+
+      protected
+
+        def raise_validation_error
+          raise Granite::Form::ValidationError, self
+        end
+      end
+    end
+  end
+end
+
+Dir[File.dirname(__FILE__) + '/validations/*.rb'].each { |file| require file }

data/lib/granite/form/model.rb

@@ -0,0 +1,33 @@
+require 'granite/form/model/conventions'
+require 'granite/form/model/attributes'
+require 'granite/form/model/validations'
+require 'granite/form/model/scopes'
+require 'granite/form/model/primary'
+require 'granite/form/model/lifecycle'
+require 'granite/form/model/persistence'
+require 'granite/form/model/callbacks'
+require 'granite/form/model/associations'
+require 'granite/form/model/localization'
+require 'granite/form/model/representation'
+require 'granite/form/model/dirty'
+
+module Granite
+  module Form
+    module Model
+      extend ActiveSupport::Concern
+
+      included do
+        extend ActiveModel::Naming
+        extend ActiveModel::Translation
+
+        include ActiveModel::Conversion
+        include ActiveModel::Serialization
+        include ActiveModel::Serializers::JSON
+
+        include Conventions
+        include Attributes
+        include Validations
+      end
+    end
+  end
+end

data/lib/granite/form/railtie.rb

@@ -0,0 +1,9 @@
+module Granite
+  module Form
+    class Railtie < Rails::Railtie
+      initializer 'granite.logger', after: 'active_record.logger' do
+        ActiveSupport.on_load(:active_record) { Granite::Form.logger ||= ActiveRecord::Base.logger }
+      end
+    end
+  end
+end

data/lib/granite/form/undefined_class.rb

@@ -0,0 +1,11 @@
+require 'singleton'
+
+module Granite
+  module Form
+    class UndefinedClass
+      include Singleton
+    end
+
+    UNDEFINED = UndefinedClass.instance.freeze
+  end
+end

data/lib/granite/form/version.rb

@@ -0,0 +1,5 @@
+module Granite
+  module Form
+    VERSION = '0.1.0'.freeze
+  end
+end

data/lib/granite/form.rb

@@ -0,0 +1,163 @@
+require 'tzinfo'
+require 'active_support'
+require 'active_support/deprecation'
+require 'active_support/core_ext'
+require 'active_support/concern'
+require 'singleton'
+
+require 'active_model'
+
+require 'granite/form/version'
+require 'granite/form/errors'
+require 'granite/form/extensions'
+require 'granite/form/undefined_class'
+require 'granite/form/config'
+require 'granite/form/railtie' if defined? Rails
+require 'granite/form/model'
+require 'granite/form/model/associations/persistence_adapters/base'
+require 'granite/form/model/associations/persistence_adapters/active_record'
+
+module Granite
+  module Form
+    BOOLEAN_MAPPING = {
+      1 => true,
+      0 => false,
+      '1' => true,
+      '0' => false,
+      't' => true,
+      'f' => false,
+      'T' => true,
+      'F' => false,
+      true => true,
+      false => false,
+      'true' => true,
+      'false' => false,
+      'TRUE' => true,
+      'FALSE' => false,
+      'y' => true,
+      'n' => false,
+      'yes' => true,
+      'no' => false
+    }.freeze
+
+    def self.config
+      Granite::Form::Config.instance
+    end
+
+    singleton_class.delegate(*Granite::Form::Config.delegated, to: :config)
+
+    typecaster('Object') { |value, attribute| value if value.class < attribute.type }
+    typecaster('String') { |value, _| value.to_s }
+    typecaster('Array') do |value|
+      case value
+      when ::Array then
+        value
+      when ::String then
+        value.split(',').map(&:strip)
+      end
+    end
+    typecaster('Hash') do |value|
+      case value
+      when ::Hash then
+        value
+      end
+    end
+    ActiveSupport.on_load :action_controller do
+      Granite::Form.typecaster('Hash') do |value|
+        case value
+        when ActionController::Parameters
+          value.to_h if value.permitted?
+        when ::Hash then
+          value
+        end
+      end
+    end
+    typecaster('Date') do |value|
+      begin
+        value.to_date
+      rescue ArgumentError, NoMethodError
+        nil
+      end
+    end
+    typecaster('DateTime') do |value|
+      begin
+        value.to_datetime
+      rescue ArgumentError
+        nil
+      end
+    end
+    typecaster('Time') do |value|
+      begin
+        value.is_a?(String) && ::Time.zone ? ::Time.zone.parse(value) : value.to_time
+      rescue ArgumentError
+        nil
+      end
+    end
+    typecaster('ActiveSupport::TimeZone') do |value|
+      case value
+      when ActiveSupport::TimeZone
+        value
+      when ::TZInfo::Timezone
+        ActiveSupport::TimeZone[value.name]
+      when String, Numeric, ActiveSupport::Duration
+        value = begin
+                  Float(value)
+                rescue ArgumentError, TypeError
+                  value
+                end
+        ActiveSupport::TimeZone[value]
+      end
+    end
+    typecaster('BigDecimal') do |value|
+      next unless value
+      begin
+        BigDecimal(Float(value).to_s)
+      rescue ArgumentError, TypeError
+        nil
+      end
+    end
+    typecaster('Float') do |value|
+      begin
+        Float(value)
+      rescue ArgumentError, TypeError
+        nil
+      end
+    end
+    typecaster('Integer') do |value|
+      begin
+        Float(value).to_i
+      rescue ArgumentError, TypeError
+        nil
+      end
+    end
+    typecaster('Boolean') { |value| BOOLEAN_MAPPING[value] }
+    typecaster('Granite::Form::UUID') do |value|
+      case value
+      when UUIDTools::UUID
+        Granite::Form::UUID.parse_raw value.raw
+      when Granite::Form::UUID
+        value
+      when String
+        Granite::Form::UUID.parse_string value
+      when Integer
+        Granite::Form::UUID.parse_int value
+      end
+    end
+  end
+end
+
+require 'granite/form/base'
+
+Granite::Form.base_class = Granite::Form::Base
+
+ActiveSupport.on_load :active_record do
+  require 'granite/form/active_record/associations'
+  require 'granite/form/active_record/nested_attributes'
+
+  include Granite::Form::ActiveRecord::Associations
+  singleton_class.prepend Granite::Form::ActiveRecord::NestedAttributes
+
+  def self.granite_persistence_adapter
+    Granite::Form::Model::Associations::PersistenceAdapters::ActiveRecord
+  end
+end