active_dry_form 0.1.0 → 1.1.0

data/lib/active_dry_form/base_form.rb

@@ -0,0 +1,285 @@
+# frozen_string_literal: true
+
+module ActiveDryForm
+  class BaseForm
+
+    attr_accessor :data, :parent_form, :errors, :base_errors
+    attr_reader :record, :validator, :attributes
+
+    def initialize(record: nil, params: nil)
+      @attributes = {}
+
+      self.params = params if params
+      self.record = record if record
+
+      @errors = {}
+      @base_errors = []
+    end
+
+    def record=(value)
+      @record =
+        if value.is_a?(Hash)
+          hr = HashRecord.new
+          hr.replace(value)
+          hr.define_methods
+          hr
+        else
+          value
+        end
+    end
+
+    def params=(params)
+      param_key = self.class::NAMESPACE.param_key
+      form_params = params[param_key] || params[param_key.to_sym] || params
+
+      if form_params.is_a?(::ActionController::Parameters)
+        unless ActiveDryForm.config.allow_action_controller_params
+          message = 'in `params` use `request.parameters` instead of `params` or set `allow_action_controller_params` to `true` in config'
+          raise ParamsNotAllowedError, message
+        end
+
+        form_params = form_params.to_unsafe_h
+      end
+
+      self.attributes = form_params
+    end
+
+    def attributes=(attrs)
+      attrs.each do |attr, v|
+        next if !ActiveDryForm.config.strict_param_keys && !respond_to?(:"#{attr}=")
+
+        public_send(:"#{attr}=", v)
+      end
+    end
+
+    def errors_full_messages
+      return if errors.blank?
+
+      errors.flat_map do |field, errors|
+        case errors
+        when Array
+          "#{t(model_name.i18n_key, field)}: #{errors.join(',')}"
+        when Hash
+          errors.map do |k, v|
+            case k
+            when Integer
+              nested_key, nested_errors = v.to_a.first
+              "#{t(field, nested_key)} (#{k + 1}): #{nested_errors.join(',')}"
+            when Symbol
+              "#{t(field, k)}: #{v.join(',')}"
+            end
+          end
+        end
+      end
+    end
+
+    def t(*keys)
+      str_keys = keys.join('.')
+      I18n.t("helpers.label.#{str_keys}", default: :"activerecord.attributes.#{str_keys}")
+    end
+
+    def persisted?
+      record&.persisted?
+    end
+
+    def model_name
+      self.class::NAMESPACE
+    end
+
+    def info(sub_key)
+      {
+        type:     self.class::FIELDS_INFO.dig(:properties, sub_key, :format) || self.class::FIELDS_INFO.dig(:properties, sub_key, :type),
+        required: self.class::FIELDS_INFO[:required].include?(sub_key.to_s),
+      }
+    end
+
+    # ActionView::Helpers::Tags::Translator#human_attribute_name
+    def to_model
+      self
+    end
+
+    def to_key
+      key = id
+      [key] if key
+    end
+
+    # hidden field for nested association
+    def id
+      record&.id
+    end
+
+    # используется при генерации URL, когда record.persisted?
+    def to_param
+      id.to_s
+    end
+
+    def validate
+      @validator   = self.class::CURRENT_CONTRACT.call(attributes, { form: self, record: record })
+      @data        = @validator.values.data
+      @errors      = @validator.errors.to_h
+      @base_errors = @validator.errors.filter(:base?).map(&:to_s)
+
+      @is_valid = @base_errors.empty? && @errors.empty?
+
+      _deep_validate_nested
+    end
+
+    def valid?
+      @is_valid
+    end
+
+    def self.human_attribute_name(field)
+      I18n.t(field, scope: :"activerecord.attributes.#{self::NAMESPACE.i18n_key}")
+    end
+
+    def self.wrap(object)
+      return object if object.is_a?(BaseForm)
+
+      form = new
+      form.attributes = object if object
+      form
+    end
+
+    def [](key)
+      public_send(key)
+    end
+
+    def []=(key, value)
+      public_send(:"#{key}=", value)
+    end
+
+    def self.define_methods
+      const_set :NESTED_FORM_KEYS, []
+
+      self::FIELDS_INFO[:properties].each do |key, value|
+        define_method :"#{key}=" do |v|
+          attributes[key] = _deep_transform_values_in_params!(v)
+        end
+
+        sub_klass =
+          if value[:properties] || value.dig(:items, :properties)
+            Class.new(BaseForm).tap do |klass|
+              klass.const_set :NAMESPACE, ActiveModel::Name.new(nil, nil, key.to_s)
+              klass.const_set :FIELDS_INFO, value[:items] || value
+              klass.define_methods
+            end
+          elsif const_defined?(:CURRENT_CONTRACT)
+            dry_type = self::CURRENT_CONTRACT.schema.schema_dsl.types[key]
+            dry_type = dry_type.member if dry_type.respond_to?(:member)
+            dry_type.primitive if dry_type.respond_to?(:primitive)
+          end
+
+        if sub_klass && sub_klass < BaseForm
+          self::NESTED_FORM_KEYS << {
+            type:      sub_klass.const_defined?(:CURRENT_CONTRACT) ? :instance : :hash,
+            namespace: key,
+            is_array:  value[:type] == 'array',
+          }
+          nested_key = key
+        end
+
+        if nested_key && value[:type] == 'array'
+          define_method nested_key do
+            nested_records = record.try(nested_key) || []
+            if attributes.key?(nested_key)
+              attributes[nested_key].each_with_index do |nested_params, idx|
+                attributes[nested_key][idx] = sub_klass.wrap(nested_params)
+                attributes[nested_key][idx].record = nested_records[idx]
+                attributes[nested_key][idx].parent_form = self
+                attributes[nested_key][idx]
+              end
+            else
+              attributes[nested_key] =
+                nested_records.map do |nested_record|
+                  nested_form = sub_klass.new
+                  nested_form.record = nested_record
+                  nested_form.parent_form = self
+                  nested_form
+                end
+            end
+            attributes[nested_key]
+          end
+        elsif nested_key
+          define_method nested_key do
+            attributes[nested_key] = sub_klass.wrap(attributes[nested_key])
+            attributes[nested_key].record = record.try(nested_key)
+            attributes[nested_key].parent_form = self
+            attributes[nested_key]
+          end
+        else
+          define_method key do
+            (data || attributes).fetch(key) { record.try(key) }
+          end
+        end
+      end
+    end
+
+    private def _deep_transform_values_in_params!(object)
+      return object if object.is_a?(BaseForm)
+
+      case object
+      when String
+        object.strip.presence
+      when Hash
+        object.transform_values! { |value| _deep_transform_values_in_params!(value) }
+      when Array
+        object.map! { |e| _deep_transform_values_in_params!(e) }
+        object.compact!
+        object
+      else
+        object
+      end
+    end
+
+    private def _deep_validate_nested
+      self.class::NESTED_FORM_KEYS.each do |nested_info|
+        namespace, type, is_array = nested_info.values_at(:namespace, :type, :is_array)
+        next unless attributes.key?(namespace)
+
+        nested_data = public_send(namespace)
+
+        if type == :hash && is_array
+          nested_data.each_with_index do |nested_form, idx|
+            nested_form.errors = @errors.dig(namespace, idx) || {}
+            nested_form.data   = @data.dig(namespace, idx)
+          end
+        elsif type == :hash
+          nested_data.errors = @errors[namespace] || {}
+          nested_data.data   = @data[namespace]
+        elsif type == :instance && is_array
+          @data[namespace] = []
+          nested_data.each_with_index do |nested_form, idx|
+            nested_form.validate
+            @data[namespace][idx] = nested_form.data
+            @base_errors += nested_form.base_errors
+            @is_valid &= nested_form.valid?
+          end
+        else
+          nested_data.validate
+          @data[namespace] = nested_data.data
+          @base_errors += nested_data.base_errors
+          @is_valid &= nested_data.valid?
+        end
+      end
+    end
+
+    class HashRecord < Hash
+
+      def persisted?
+        false
+      end
+
+      def id
+        self[:id] || self['id']
+      end
+
+      def define_methods
+        keys.each do |key|
+          define_singleton_method(key) { fetch(key) }
+        end
+      end
+
+    end
+
+  end
+end

data/lib/active_dry_form/builder.rb

@@ -3,74 +3,109 @@
 module ActiveDryForm
   class Builder < ActionView::Helpers::FormBuilder
 
-    def input(method, options = {})
-      dry_tag = ActiveDryForm::Input.new(self, __method__, method, options)
-
-      input_tag =
-        case dry_tag.input_type
-        when 'date'      then text_field(method, dry_tag.input_opts.merge('data-controller': 'flatpickr'))
-        when 'date_time' then text_field(method, dry_tag.input_opts.merge('data-controller': 'flatpickr', 'data-flatpickr-enable-time': 'true'))
-        when 'integer'   then number_field(method, dry_tag.input_opts)
-        when 'bool'      then check_box(method, dry_tag.input_opts)
-        else
-          case method.to_s
-          when /password/ then password_field(method, dry_tag.input_opts)
-          when /email/    then email_field(method, dry_tag.input_opts)
-          when /phone/    then telephone_field(method, dry_tag.input_opts)
-          when /url/      then url_field(method, dry_tag.input_opts)
-          else text_field(method, dry_tag.input_opts)
-          end
-        end
-
-      dry_tag.wrap_tag input_tag
-    end
+    include Dry::Core::Constants
 
-    def input_select(method, collection, options = {}, html_options = {}) # rubocop:disable Gp/OptArgParameters
-      dry_tag = ActiveDryForm::Input.new(self, __method__, method, options)
-      dry_tag.wrap_tag select(method, collection, dry_tag.input_opts, html_options)
+    def input(field, options = {})
+      case input_type(field)
+      when 'date'              then input_date(field, options)
+      when 'time'              then input_datetime(field, options)
+      when 'date-time'         then raise DateTimeNotAllowedError, 'use :time instead of :date_time (does not apply timezone) in params block'
+      when 'integer'           then input_integer(field, options)
+      when 'number'            then input_number(field, options)
+      when 'boolean'           then input_check_box(field, options)
+      else
+        case field.to_s
+        when /password/ then input_password(field, options)
+        when /email/    then input_email(field, options)
+        when /phone/    then input_telephone(field, options)
+        when /url/      then input_url(field, options)
+        else input_text(field, options)
+        end
+      end
     end
 
-    def input_checkbox_inline(method, options = {})
-      dry_tag = ActiveDryForm::Input.new(self, __method__, method, options)
-      dry_tag.wrap_tag check_box(method, dry_tag.input_opts), label_last: true
-    end
+    def input_date(field, options = {});      wrap_input(__method__, field, options) { |opts| date_field(field, opts) } end
+    def input_datetime(field, options = {});  wrap_input(__method__, field, options) { |opts| datetime_field(field, opts) } end
+    def input_integer(field, options = {});   wrap_input(__method__, field, options) { |opts| number_field(field, opts) } end
+    def input_number(field, options = {});    wrap_input(__method__, field, options) { |opts| number_field(field, opts) } end
+    def input_password(field, options = {});  wrap_input(__method__, field, options) { |opts| password_field(field, opts) } end
+    def input_email(field, options = {});     wrap_input(__method__, field, options) { |opts| email_field(field, opts) } end
+    def input_url(field, options = {});       wrap_input(__method__, field, options) { |opts| url_field(field, opts) } end
+    def input_text(field, options = {});      wrap_input(__method__, field, options) { |opts| text_field(field, opts) } end
+    def input_file(field, options = {});      wrap_input(__method__, field, options) { |opts| file_field(field, opts) } end
+    def input_telephone(field, options = {}); wrap_input(__method__, field, options) { |opts| telephone_field(field, opts) } end
+    def input_text_area(field, options = {}); wrap_input(__method__, field, options) { |opts| text_area(field, opts) } end
+    def input_check_box(field, options = {}); wrap_input(__method__, field, options) { |opts| check_box(field, opts) } end
 
-    def input_text(method, options = {})
-      dry_tag = ActiveDryForm::Input.new(self, __method__, method, options)
-      dry_tag.wrap_tag text_area(method, dry_tag.input_opts)
-    end
+    def input_hidden(field, options = {}); hidden_field(field, options) end
 
-    def input_file(method, options = {})
-      dry_tag = ActiveDryForm::Input.new(self, __method__, method, options)
-      dry_tag.wrap_tag file_field(method, dry_tag.input_opts)
+    def input_check_box_inline(field, options = {})
+      wrap_input(__method__, field, options, label_last: true) do |opts|
+        check_box(field, opts)
+      end
     end
 
-    def input_hidden(method, options = {})
-      hidden_field(method, options)
+    def input_select(field, collection, options = {}, html_options = {})
+      wrap_input(__method__, field, html_options) do |opts|
+        select(field, collection, options, opts)
+      end
     end
 
     def show_base_errors
-      return unless @object.base_errors
+      return if @object.base_errors.empty?
 
-      tag.div class: 'callout alert' do
-        tag.ul do
+      @template.content_tag(:div, class: ActiveDryForm.config.css_classes.base_error) do
+        @template.content_tag(:ul) do
           # внутри ошибки может быть html
-          @object.base_errors.map { tag.li _1.html_safe }.join.html_safe
+          @object.base_errors.map { @template.content_tag(:li, _1.html_safe) }.join.html_safe
         end
       end
     end
 
-    def show_error(method)
-      ActiveDryForm::Input.new(self, __method__, method, {}).error_text
+    def show_error(field)
+      ActiveDryForm::Input.new(self, nil, field, {}).error_text
     end
 
-    def button(value = nil, options = {}, &block) # rubocop:disable Gp/OptArgParameters
+    def button(value = nil, options = {}, &block)
       options[:class] = [options[:class], 'button'].compact
-      super(value, options, &block)
+      super
+    end
+
+    def fields_for(association_name, fields_options = {}, &block)
+      fields_options[:builder] ||= options[:builder]
+      fields_options[:namespace] = options[:namespace]
+      fields_options[:parent_builder] = self
+
+      association = @object.public_send(association_name)
+
+      if association.is_a?(BaseForm)
+        fields_for_nested_model("#{@object_name}[#{association_name}]", association, fields_options, block)
+      elsif association.respond_to?(:to_ary)
+        field_name_regexp = Regexp.new(Regexp.escape("#{@object_name}[#{association_name}][") << '\d+\]') # хак для замены хеша на массив
+        output = ActiveSupport::SafeBuffer.new
+        Array.wrap(association).each do |child|
+          output << fields_for_nested_model("#{@object_name}[#{association_name}][]", child, fields_options, block)
+            .gsub(field_name_regexp, "#{@object_name}[#{association_name}][]").html_safe
+        end
+        output
+      end
     end
-    
-    def fields_for(record_name, &block)
-      super(@object.send(record_name), &block)
+
+    ARRAY_NULL = %w[null].freeze
+    private def input_type(field)
+      (Array.wrap(object.info(field)[:type]) - ARRAY_NULL).first
+    end
+
+    private def wrap_input(method_type, field, options, wrapper_options = {})
+      config = ActiveDryForm.config.html_options._settings[method_type] ? ActiveDryForm.config.html_options[method_type] : EMPTY_HASH
+      options = config.merge(options)
+
+      options[:class] = Array.wrap(config[:class]) + Array.wrap(options[:class]) if config[:class]
+      options[:required] = object.info(field)[:required] unless options.key?(:required)
+
+      Input
+        .new(self, method_type, field, options)
+        .wrap_tag(yield(options), **wrapper_options)
     end
 
   end

data/lib/active_dry_form/configuration.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ActiveDryForm
+
+  extend Dry::Configurable
+  include Dry::Core::Constants
+
+  setting :strict_param_keys, default: defined?(::Rails) ? (::Rails.env.development? || ::Rails.env.test?) : true
+  setting :allow_action_controller_params, default: true
+
+  setting :css_classes do
+    setting :error,          default: 'form-error'
+    setting :base_error,     default: 'form-base-error'
+    setting :hint,           default: 'form-hint'
+    setting :input,          default: 'form-input'
+    setting :input_required, default: 'form-input-required'
+    setting :input_error,    default: 'form-input-error'
+    setting :form,           default: ['active-dry-form']
+  end
+
+  setting :html_options do
+    setting :input_check_box,        default: EMPTY_HASH
+    setting :input_check_box_inline, default: EMPTY_HASH
+    setting :input_date,             default: EMPTY_HASH
+    setting :input_datetime,         default: EMPTY_HASH
+    setting :input_email,            default: EMPTY_HASH
+    setting :input_file,             default: EMPTY_HASH
+    setting :input_integer,          default: EMPTY_HASH
+
+    # If without 'any', the fractional part of the number is lost when step is an integer (1 by default)
+    setting :input_number,           default: { step: 'any' }
+    setting :input_password,         default: EMPTY_HASH
+    setting :input_select,           default: EMPTY_HASH
+    setting :input_telephone,        default: EMPTY_HASH
+    setting :input_text_area,        default: EMPTY_HASH
+    setting :input_text,             default: EMPTY_HASH
+    setting :input_url,              default: EMPTY_HASH
+
+    setting :form,                   default: EMPTY_HASH
+  end
+
+end
+
+ActiveSupport::Reloader.to_prepare do
+  ActiveDryForm.config.finalize!(freeze_values: true)
+end