script_core 0.0.4 → 0.0.5

data/spec/dummy/app/helpers/forms_helper.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module FormsHelper
+  def smart_form_fields_path(form)
+    case form
+    when Form
+      form_fields_path(form)
+    when NestedForm
+      nested_form_fields_path(form)
+    else
+      raise "Unknown form: #{form.class}"
+    end
+  end
+end

data/spec/dummy/app/jobs/application_job.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+class ApplicationJob < ActiveJob::Base
+end

data/spec/dummy/app/lib/script_engine.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ScriptEngine
+  class << self
+    def engine
+      @engine ||= ScriptCore::Engine.new Rails.root.join("mruby/bin")
+    end
+
+    def eval(string, input: nil, instruction_quota_start: nil, environment_variables: {})
+      environment_variables.reverse_merge!("TZ" => Time.zone.name)
+      sources = [
+        %w[prepare_input prepare_input],
+        ["user", string],
+        %w[prepare_output prepare_output]
+      ]
+
+      engine.eval sources, input: input,
+                           instruction_quota_start: instruction_quota_start,
+                           environment_variables: environment_variables
+    end
+  end
+end

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

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+
+  include ActsAsDefaultValue
+  include EnumAttributeLocalizable
+end

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

@@ -0,0 +1,152 @@
+# 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 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)
+
+      connection_default_value_defined = new_record? && respond_to?("#{attribute}_changed?") && !send("#{attribute}_changed?")
+
+      column = self.class.columns.detect { |c| c.name == attribute }
+      attribute_blank =
+        if column && column.type == :boolean
+          send(attribute).nil?
+        else
+          send(attribute).blank?
+        end
+      next unless connection_default_value_defined || 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
+
+  def attributes_for_create(attribute_names)
+    attribute_names += self.class._all_default_attribute_values.keys.map(&:to_s).find_all do |name|
+      self.class.columns_hash.key?(name)
+    end
+
+    super
+  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

data/spec/dummy/app/models/concerns/enum_attribute_localizable.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module EnumAttributeLocalizable
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def human_enum_value(attribute, value, options = {})
+      parts     = attribute.to_s.split(".")
+      attribute = parts.pop.pluralize
+      attributes_scope = "#{i18n_scope}.attributes"
+
+      if parts.any?
+        namespace = parts.join("/")
+        defaults = lookup_ancestors.map do |klass|
+          :"#{attributes_scope}.#{klass.model_name.i18n_key}/#{namespace}.#{attribute}.#{value}"
+        end
+        defaults << :"#{attributes_scope}.#{namespace}.#{attribute}.#{value}"
+      else
+        defaults = lookup_ancestors.map do |klass|
+          :"#{attributes_scope}.#{klass.model_name.i18n_key}.#{attribute}.#{value}"
+        end
+      end
+
+      defaults << :"attributes.#{attribute}.#{value}"
+      defaults << options.delete(:default) if options[:default]
+      defaults << value.to_s.humanize
+
+      options[:default] = defaults
+      I18n.translate(defaults.shift, options)
+    end
+  end
+end

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

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

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

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

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Concerns::Fields
+  module Validations::Exclusion
+    extend ActiveSupport::Concern
+
+    included do
+      embeds_one :exclusion, class_name: "Concerns::Fields::Validations::Exclusion::ExclusionOptions"
+      accepts_nested_attributes_for :exclusion
+
+      after_initialize do
+        build_exclusion unless exclusion
+      end
+    end
+
+    def interpret_to(model, field_name, accessibility, options = {})
+      super
+      exclusion&.interpret_to model, field_name, accessibility, options
+    end
+
+    class ExclusionOptions < FieldOptions
+      attribute :message, :string, default: ""
+      attribute :in, :string, default: [], array: true
+
+      def interpret_to(model, field_name, _accessibility, _options = {})
+        return if self.in.empty?
+
+        options = {in: self.in}
+        options[:message] = message if message.present?
+
+        model.validates field_name, exclusion: options, allow_blank: true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Concerns::Fields
+  module Validations::Format
+    extend ActiveSupport::Concern
+
+    included do
+      embeds_one :format, class_name: "Concerns::Fields::Validations::Format::FormatOptions"
+      accepts_nested_attributes_for :format
+
+      after_initialize do
+        build_format unless format
+      end
+    end
+
+    def interpret_to(model, field_name, accessibility, options = {})
+      super
+      format&.interpret_to model, field_name, accessibility, options
+    end
+
+    class FormatOptions < FieldOptions
+      attribute :with, :string, default: ""
+      attribute :message, :string, default: ""
+
+      validate do
+        begin
+          Regexp.new(with) if with.present?
+        rescue RegexpError
+          errors.add :with, :invalid
+        end
+      end
+
+      def interpret_to(model, field_name, _accessibility, _options = {})
+        return if with.blank?
+
+        with = Regexp.new(self.with)
+
+        options = {with: with}
+        options[:message] = message if message.present?
+
+        model.validates field_name, format: options, allow_blank: true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Concerns::Fields
+  module Validations::Inclusion
+    extend ActiveSupport::Concern
+
+    included do
+      embeds_one :inclusion, class_name: "Concerns::Fields::Validations::Inclusion::InclusionOptions"
+      accepts_nested_attributes_for :inclusion
+
+      after_initialize do
+        build_inclusion unless inclusion
+      end
+    end
+
+    def interpret_to(model, field_name, accessibility, options = {})
+      super
+      inclusion&.interpret_to model, field_name, accessibility, options
+    end
+
+    class InclusionOptions < FieldOptions
+      attribute :message, :string, default: ""
+      attribute :in, :string, default: [], array: true
+
+      def interpret_to(model, field_name, _accessibility, _options = {})
+        return if self.in.empty?
+
+        options = {in: self.in}
+        options[:message] = message if message.present?
+
+        model.validates field_name, inclusion: options, allow_blank: true
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Concerns::Fields
+  module Validations::Length
+    extend ActiveSupport::Concern
+
+    included do
+      embeds_one :length, class_name: "Concerns::Fields::Validations::Length::LengthOptions"
+      accepts_nested_attributes_for :length
+
+      after_initialize do
+        build_length unless length
+      end
+    end
+
+    def interpret_to(model, field_name, accessibility, options = {})
+      super
+      length&.interpret_to model, field_name, accessibility, options
+    end
+
+    class LengthOptions < FieldOptions
+      attribute :minimum, :integer, default: 0
+      attribute :maximum, :integer, default: 0
+      attribute :is, :integer, default: 0
+
+      validates :minimum, :maximum, :is,
+                numericality: {
+                  greater_than_or_equal_to: 0
+                }
+      validates :maximum,
+                numericality: {
+                  greater_than: :minimum
+                },
+                if: proc { |record| record.maximum <= record.minimum && record.maximum.positive? }
+
+      validates :is,
+                numericality: {
+                  equal_to: 0
+                },
+                if: proc { |record| !record.maximum.zero? || !record.minimum.zero? }
+
+      def interpret_to(model, field_name, _accessibility, _options = {})
+        return if minimum.zero? && maximum.zero? && is.zero?
+
+        if is.positive?
+          model.validates field_name, length: {is: is}, allow_blank: true
+          return
+        end
+
+        options = {}
+        options[:minimum] = minimum if minimum.positive?
+        options[:maximum] = maximum if maximum.positive?
+        return if options.empty?
+
+        model.validates field_name, length: options, allow_blank: true
+      end
+    end
+  end
+end