script_core 0.0.4 → 0.0.5

data/spec/dummy/app/models/concerns/fields/validations/numericality.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Concerns::Fields
+  module Validations::Numericality
+    extend ActiveSupport::Concern
+
+    included do
+      embeds_one :numericality, class_name: "Concerns::Fields::Validations::Numericality::NumericalityOptions"
+      accepts_nested_attributes_for :numericality
+
+      after_initialize do
+        build_numericality unless numericality
+      end
+    end
+
+    def interpret_to(model, field_name, accessibility, options = {})
+      super
+      numericality&.interpret_to model, field_name, accessibility, options
+    end
+
+    class NumericalityOptions < FieldOptions
+      attribute :lower_bound_check, :string, default: "disabled"
+      attribute :upper_bound_check, :string, default: "disabled"
+
+      attribute :lower_bound_value, :float, default: 0.0
+      attribute :upper_bound_value, :float, default: 0.0
+
+      enum lower_bound_check: {
+        disabled: "disabled",
+        greater_than: "greater_than",
+        greater_than_or_equal_to: "greater_than_or_equal_to"
+      }, _prefix: :lower_bound_check
+      enum upper_bound_check: {
+        disabled: "disabled",
+        less_than: "less_than",
+        less_than_or_equal_to: "less_than_or_equal_to"
+      }, _prefix: :upper_bound_check
+
+      validates :upper_bound_value,
+                numericality: {
+                  greater_than: :lower_bound_value
+                },
+                if: proc { upper_bound_check != "disabled" && lower_bound_check != "disabled" }
+
+      def interpret_to(model, field_name, _accessibility, _options = {})
+        options = {}
+        options[lower_bound_check] = lower_bound_value unless lower_bound_check_disabled?
+        options[upper_bound_check] = upper_bound_value unless upper_bound_check_disabled?
+        return if options.empty?
+
+        options.symbolize_keys!
+        model.validates field_name, numericality: options, allow_blank: true
+      end
+    end
+  end
+end

data/spec/dummy/app/models/concerns/fields/validations/presence.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Concerns::Fields
+  module Validations::Presence
+    extend ActiveSupport::Concern
+
+    included do
+      attribute :presence, :boolean, default: false
+    end
+
+    def interpret_to(model, field_name, _accessibility, _options = {})
+      super
+      return unless presence
+
+      model.validates field_name, presence: true
+    end
+  end
+end

data/spec/dummy/app/models/concerns/form_core/acts_as_default_value.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+# https://github.com/FooBarWidget/default_value_for
+#
+# Copyright (c) 2008-2012 Phusion
+#
+# 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.
+
+module FormCore
+  module ActsAsDefaultValue
+    extend ActiveSupport::Concern
+
+    class NormalValueContainer
+      def initialize(value)
+        @value = value
+      end
+
+      def evaluate(_instance)
+        if @value.duplicable?
+          @value.dup
+        else
+          @value
+        end
+      end
+    end
+
+    class BlockValueContainer
+      def initialize(block)
+        @block = block
+      end
+
+      def evaluate(instance)
+        if @block.arity == 0
+          @block.call
+        else
+          @block.call(instance)
+        end
+      end
+    end
+
+    included do
+      after_initialize :set_default_values
+    end
+
+    def initialize(attributes = nil)
+      @initialization_attributes = attributes.is_a?(Hash) ? attributes.stringify_keys : {}
+      super
+    end
+
+    def set_default_values
+      self.class._all_default_attribute_values.each do |attribute, container|
+        next unless new_record? || self.class._all_default_attribute_values_not_allowing_nil.include?(attribute)
+
+        attribute_blank =
+          if self.class.attribute_types[attribute]&.type == :boolean
+            send(attribute).nil?
+          else
+            send(attribute).blank?
+          end
+        next unless attribute_blank
+
+        # allow explicitly setting nil through allow nil option
+        next if @initialization_attributes.is_a?(Hash) &&
+                (
+                @initialization_attributes.key?(attribute) ||
+                  (
+                  @initialization_attributes.key?("#{attribute}_attributes") &&
+                    nested_attributes_options.stringify_keys[attribute]
+                )
+              ) &&
+                !self.class._all_default_attribute_values_not_allowing_nil.include?(attribute)
+
+        send("#{attribute}=", container.evaluate(self))
+
+        clear_attribute_changes [attribute] if has_attribute?(attribute)
+      end
+    end
+
+    module ClassMethods
+      def _default_attribute_values # :nodoc:
+        @default_attribute_values ||= {}
+      end
+
+      def _default_attribute_values_not_allowing_nil # :nodoc:
+        @default_attribute_values_not_allowing_nil ||= Set.new
+      end
+
+      def _all_default_attribute_values # :nodoc:
+        if superclass.respond_to?(:_default_attribute_values)
+          superclass._all_default_attribute_values.merge(_default_attribute_values)
+        else
+          _default_attribute_values
+        end
+      end
+
+      def _all_default_attribute_values_not_allowing_nil # :nodoc:
+        if superclass.respond_to?(:_default_attribute_values_not_allowing_nil)
+          superclass._all_default_attribute_values_not_allowing_nil + _default_attribute_values_not_allowing_nil
+        else
+          _default_attribute_values_not_allowing_nil
+        end
+      end
+
+      # Declares a default value for the given attribute.
+      #
+      # Sets the default value to the given options parameter
+      #
+      # The <tt>options</tt> can be used to specify the following things:
+      # * <tt>allow_nil (default: true)</tt> - Sets explicitly passed nil values if option is set to true.
+      def default_value_for(attribute, value, **options)
+        allow_nil = options.fetch(:allow_nil, true)
+
+        container =
+          if value.is_a? Proc
+            BlockValueContainer.new(value)
+          else
+            NormalValueContainer.new(value)
+          end
+
+        _default_attribute_values[attribute.to_s] = container
+        _default_attribute_values_not_allowing_nil << attribute.to_s unless allow_nil
+
+        attribute
+      end
+    end
+  end
+end

data/spec/dummy/app/models/field.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+class Field < ApplicationRecord
+  include FormCore::Concerns::Models::Field
+
+  self.table_name = "fields"
+
+  belongs_to :form, class_name: "MetalForm", foreign_key: "form_id", touch: true
+
+  validates :label,
+            presence: true
+  validates :type,
+            inclusion: {
+              in: ->(_) { Field.descendants.map(&:to_s) }
+            },
+            allow_blank: false
+
+  default_value_for :name,
+                    ->(_) { "field_#{SecureRandom.hex(3)}" },
+                    allow_nil: false
+
+  def self.type_key
+    model_name.name.split("::").last.underscore
+  end
+
+  def type_key
+    self.class.type_key
+  end
+
+  def options_configurable?
+    options.is_a?(FieldOptions) && options.attributes.any?
+  end
+
+  def validations_configurable?
+    validations.is_a?(FieldOptions) && validations.attributes.any?
+  end
+
+  protected
+
+  def interpret_validations_to(model, accessibility, overrides = {})
+    return unless accessibility == :read_and_write
+
+    validations_overrides = overrides.fetch(:validations) { {} }
+    validations =
+      if validations_overrides.any?
+        self.validations.dup.update(validations_overrides)
+      else
+        self.validations
+      end
+
+    validations.interpret_to(model, name, accessibility)
+  end
+
+  def interpret_extra_to(model, accessibility, overrides = {})
+    options_overrides = overrides.fetch(:options) { {} }
+    options =
+      if options_overrides.any?
+        self.options.dup.update(options_overrides)
+      else
+        self.options
+      end
+
+    options.interpret_to(model, name, accessibility)
+  end
+end
+
+require_dependency "fields"

data/spec/dummy/app/models/field_options.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+class FieldOptions < DuckRecord::Base
+  include FormCore::ActsAsDefaultValue
+  include EnumAttributeLocalizable
+
+  class_attribute :keeping_old_serialization
+
+  attr_accessor :raw_attributes
+
+  def interpret_to(_model, _field_name, _accessibility, _options = {}); end
+
+  def serializable_hash(options = {})
+    options = (options || {}).reverse_merge include: self.class._embeds_reflections.keys
+    super options
+  end
+
+  private
+
+  def _assign_attribute(k, v)
+    return unless respond_to?("#{k}=")
+
+    public_send("#{k}=", v)
+  end
+
+  class << self
+    def _embeds_reflections
+      _reflections.select { |_, v| v.is_a? DuckRecord::Reflection::EmbedsAssociationReflection }
+    end
+
+    def model_version
+      1
+    end
+
+    def root_key_for_serialization
+      "#{self}.#{model_version}"
+    end
+
+    def dump(obj)
+      return YAML.dump({}) unless obj
+
+      serializable_hash =
+        if obj.respond_to?(:serializable_hash)
+          obj.serializable_hash
+        elsif obj.respond_to?(:to_hash)
+          obj.to_hash
+        else
+          raise ArgumentError, "`obj` required can be cast to `Hash` -- #{obj.class}"
+        end.stringify_keys
+
+      data = {root_key_for_serialization => serializable_hash}
+      data.reverse_merge! obj.raw_attributes if keeping_old_serialization
+
+      YAML.dump(data)
+    end
+
+    def load(yaml_or_hash)
+      case yaml_or_hash
+      when Hash
+        load_from_hash(yaml_or_hash)
+      when String
+        load_from_yaml(yaml_or_hash)
+      else
+        new
+      end
+    end
+
+    WHITELIST_CLASSES = [BigDecimal, Date, Time, Symbol].freeze
+    def load_from_yaml(yaml)
+      return new if yaml.blank?
+
+      return new unless yaml.is_a?(String) && /^---/.match?(yaml)
+
+      decoded = YAML.safe_load(yaml, WHITELIST_CLASSES)
+      return new unless decoded.is_a? Hash
+
+      record = new decoded[root_key_for_serialization]
+      record.raw_attributes = decoded.freeze
+      record
+    end
+
+    def load_from_hash(hash)
+      return new if hash.blank?
+
+      record = new hash[root_key_for_serialization]
+      record.raw_attributes = hash.freeze
+      record
+    end
+  end
+end

data/spec/dummy/app/models/fields.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Fields
+  %w[
+    text boolean decimal integer
+    nested_form multiple_nested_form
+  ].each do |type|
+    require_dependency "fields/#{type}_field"
+  end
+end

data/spec/dummy/app/models/fields/boolean_field.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Fields
+  class BooleanField < Field
+    serialize :validations, Validations::BooleanField
+    serialize :options, Options::BooleanField
+
+    def stored_type
+      :boolean
+    end
+  end
+end

data/spec/dummy/app/models/fields/decimal_field.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Fields
+  class DecimalField < Field
+    serialize :validations, Validations::DecimalField
+    serialize :options, Options::DecimalField
+
+    def stored_type
+      :decimal
+    end
+  end
+end

data/spec/dummy/app/models/fields/integer_field.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Fields
+  class IntegerField < Field
+    serialize :validations, Validations::IntegerField
+    serialize :options, Options::IntegerField
+
+    def stored_type
+      :integer
+    end
+
+    protected
+
+    def interpret_extra_to(model, accessibility, _overrides = {})
+      return if accessibility != :read_and_write
+
+      model.validates name, numericality: {only_integer: true}, allow_blank: true
+    end
+  end
+end

data/spec/dummy/app/models/fields/multiple_nested_form_field.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Fields
+  class MultipleNestedFormField < Field
+    has_one :nested_form, as: :attachable, dependent: :destroy
+
+    after_create do
+      build_nested_form.save!
+    end
+
+    serialize :validations, Validations::MultipleNestedFormField
+    serialize :options, Options::MultipleNestedFormField
+
+    def interpret_to(model, overrides: {})
+      check_model_validity!(model)
+
+      accessibility = overrides.fetch(:accessibility, self.accessibility)
+      return model if accessibility == :hidden
+
+      overrides[:name] = name
+
+      nested_model = nested_form.to_virtual_model(overrides: {_global: {accessibility: accessibility}})
+
+      model.nested_models[name] = nested_model
+
+      model.embeds_many name, anonymous_class: nested_model, validate: true
+      model.accepts_nested_attributes_for name, reject_if: :all_blank
+
+      interpret_validations_to model, accessibility, overrides
+      interpret_extra_to model, accessibility, overrides
+
+      model
+    end
+  end
+end