mini-sharp-mod 0.0.1

data/simple_form-5.4.1/lib/simple_form/helpers/autofocus.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+module SimpleForm
+  module Helpers
+    module Autofocus
+      private
+
+      def has_autofocus?
+        options[:autofocus] == true
+      end
+    end
+  end
+end

data/simple_form-5.4.1/lib/simple_form/helpers/disabled.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module SimpleForm
+  module Helpers
+    module Disabled
+      private
+
+      def has_disabled?
+        options[:disabled] == true
+      end
+
+      def disabled_class
+        :disabled if has_disabled?
+      end
+    end
+  end
+end

data/simple_form-5.4.1/lib/simple_form/helpers/readonly.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module SimpleForm
+  module Helpers
+    module Readonly
+      private
+
+      def readonly_class
+        :readonly if has_readonly?
+      end
+
+      def has_readonly?
+        options[:readonly] == true
+      end
+    end
+  end
+end

data/simple_form-5.4.1/lib/simple_form/helpers/required.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+module SimpleForm
+  module Helpers
+    module Required
+      private
+
+      def required_field?
+        @required
+      end
+
+      def calculate_required
+        if !options[:required].nil?
+          options[:required]
+        elsif has_validators?
+          required_by_validators?
+        else
+          required_by_default?
+        end
+      end
+
+      def required_by_validators?
+        (attribute_validators + reflection_validators).any? { |v| v.kind == :presence && valid_validator?(v) }
+      end
+
+      def required_by_default?
+        SimpleForm.required_by_default
+      end
+
+      # Do not use has_required? because we want to add the class
+      # regardless of the required option.
+      def required_class
+        required_field? ? :required : :optional
+      end
+    end
+  end
+end

data/simple_form-5.4.1/lib/simple_form/helpers/validators.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+module SimpleForm
+  module Helpers
+    module Validators
+      def has_validators?
+        @has_validators ||= attribute_name && object.class.respond_to?(:validators_on)
+      end
+
+      private
+
+      def attribute_validators
+        object.class.validators_on(attribute_name)
+      end
+
+      def reflection_validators
+        reflection ? object.class.validators_on(reflection.name) : []
+      end
+
+      def valid_validator?(validator)
+        !conditional_validators?(validator) && action_validator_match?(validator)
+      end
+
+      def conditional_validators?(validator)
+        validator.options.include?(:if) || validator.options.include?(:unless)
+      end
+
+      def action_validator_match?(validator)
+        return true unless validator.options.include?(:on)
+
+        case validator.options[:on]
+        when :save
+          true
+        when :create
+          !object.persisted?
+        when :update
+          object.persisted?
+        end
+      end
+
+      def find_validator(kind)
+        attribute_validators.find { |v| v.kind == kind } if has_validators?
+      end
+
+      # Implements `ActiveModel::Validations::ResolveValue`, introduced by Rails 7.1.
+      # https://github.com/rails/rails/blob/v7.1.0/activemodel/lib/active_model/validations/resolve_value.rb
+      def resolve_validator_value(value)
+        case value
+        when Proc
+          if value.arity == 0
+            value.call
+          else
+            value.call(object)
+          end
+        when Symbol
+          object.send(value)
+        else
+          if value.respond_to?(:call)
+            value.call(object)
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/simple_form-5.4.1/lib/simple_form/helpers.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module SimpleForm
+  # Helpers are made of several helpers that cannot be turned on automatically.
+  # For instance, disabled cannot be turned on automatically, it requires the
+  # user to explicitly pass the option disabled: true so it may work.
+  module Helpers
+    autoload :Autofocus,  'simple_form/helpers/autofocus'
+    autoload :Disabled,   'simple_form/helpers/disabled'
+    autoload :Readonly,   'simple_form/helpers/readonly'
+    autoload :Required,   'simple_form/helpers/required'
+    autoload :Validators, 'simple_form/helpers/validators'
+  end
+end

data/simple_form-5.4.1/lib/simple_form/inputs/base.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+require 'active_support/core_ext/string/output_safety'
+require 'action_view/helpers'
+
+module SimpleForm
+  module Inputs
+    class Base
+      include ERB::Util
+      include ActionView::Helpers::TranslationHelper
+
+      include SimpleForm::Helpers::Autofocus
+      include SimpleForm::Helpers::Disabled
+      include SimpleForm::Helpers::Readonly
+      include SimpleForm::Helpers::Required
+      include SimpleForm::Helpers::Validators
+
+      include SimpleForm::Components::Errors
+      include SimpleForm::Components::Hints
+      include SimpleForm::Components::HTML5
+      include SimpleForm::Components::LabelInput
+      include SimpleForm::Components::Maxlength
+      include SimpleForm::Components::Minlength
+      include SimpleForm::Components::MinMax
+      include SimpleForm::Components::Pattern
+      include SimpleForm::Components::Placeholders
+      include SimpleForm::Components::Readonly
+
+      attr_reader :attribute_name, :column, :input_type, :reflection,
+                  :options, :input_html_options, :input_html_classes, :html_classes
+
+      delegate :template, :object, :object_name, :lookup_model_names, :lookup_action, to: :@builder
+
+      class_attribute :default_options
+      self.default_options = {}
+
+      def self.enable(*keys)
+        options = self.default_options.dup
+        keys.each { |key| options.delete(key) }
+        self.default_options = options
+      end
+
+      def self.disable(*keys)
+        options = self.default_options.dup
+        keys.each { |key| options[key] = false }
+        self.default_options = options
+      end
+
+      # Always enabled.
+      enable :hint
+
+      # Usually disabled, needs to be enabled explicitly passing true as option.
+      disable :maxlength, :minlength, :placeholder, :pattern, :min_max
+
+      def initialize(builder, attribute_name, column, input_type, options = {})
+        super
+
+        options         = options.dup
+        @builder        = builder
+        @attribute_name = attribute_name
+        @column         = column
+        @input_type     = input_type
+        @reflection     = options.delete(:reflection)
+        @options        = options.reverse_merge!(self.class.default_options)
+        @required       = calculate_required
+
+        # Notice that html_options_for receives a reference to input_html_classes.
+        # This means that classes added dynamically to input_html_classes will
+        # still propagate to input_html_options.
+        @html_classes = SimpleForm.additional_classes_for(:input) { additional_classes }
+
+        @input_html_classes = @html_classes.dup
+
+        input_html_classes = self.input_html_classes
+
+        if SimpleForm.input_class && input_html_classes.any?
+          input_html_classes << SimpleForm.input_class
+        end
+
+        @input_html_options = html_options_for(:input, input_html_classes).tap do |o|
+          o[:readonly]  = true if has_readonly?
+          o[:disabled]  = true if has_disabled?
+          o[:autofocus] = true if has_autofocus?
+        end
+      end
+
+      def input(wrapper_options = nil)
+        raise NotImplementedError
+      end
+
+      def input_options
+        options
+      end
+
+      def additional_classes
+        @additional_classes ||= [input_type, required_class, readonly_class, disabled_class].compact
+      end
+
+      def input_class
+        "#{lookup_model_names.join('_')}_#{reflection_or_attribute_name}"
+      end
+
+      private
+
+      def limit
+        if column
+          decimal_or_float? ? decimal_limit : column_limit
+        end
+      end
+
+      def column_limit
+        column.limit
+      end
+
+      # Add one for decimal point
+      def decimal_limit
+        column_limit && (column_limit + 1)
+      end
+
+      def decimal_or_float?
+        column.type == :float || column.type == :decimal
+      end
+
+      def nested_boolean_style?
+        options.fetch(:boolean_style, SimpleForm.boolean_style) == :nested
+      end
+
+      # Find reflection name when available, otherwise use attribute
+      def reflection_or_attribute_name
+        @reflection_or_attribute_name ||= reflection ? reflection.name : attribute_name
+      end
+
+      # Retrieve options for the given namespace from the options hash
+      def html_options_for(namespace, css_classes)
+        html_options = options[:"#{namespace}_html"]
+        html_options = html_options ? html_options.dup : {}
+        css_classes << html_options[:class] if html_options.key?(:class)
+        html_options[:class] = css_classes unless css_classes.empty?
+        html_options
+      end
+
+      # Lookup translations for the given namespace using I18n, based on object name,
+      # actual action and attribute name. Lookup priority as follows:
+      #
+      #   simple_form.{namespace}.{model}.{action}.{attribute}
+      #   simple_form.{namespace}.{model}.{attribute}
+      #   simple_form.{namespace}.defaults.{attribute}
+      #
+      #  Namespace is used for :labels and :hints.
+      #
+      #  Model is the actual object name, for a @user object you'll have :user.
+      #  Action is the action being rendered, usually :new or :edit.
+      #  And attribute is the attribute itself, :name for example.
+      #
+      #  The lookup for nested attributes is also done in a nested format using
+      #  both model and nested object names, such as follow:
+      #
+      #   simple_form.{namespace}.{model}.{nested}.{action}.{attribute}
+      #   simple_form.{namespace}.{model}.{nested}.{attribute}
+      #   simple_form.{namespace}.{nested}.{action}.{attribute}
+      #   simple_form.{namespace}.{nested}.{attribute}
+      #   simple_form.{namespace}.defaults.{attribute}
+      #
+      #  Example:
+      #
+      #    simple_form:
+      #      labels:
+      #        user:
+      #          new:
+      #            email: 'E-mail para efetuar o sign in.'
+      #          edit:
+      #            email: 'E-mail.'
+      #
+      #  Take a look at our locale example file.
+      def translate_from_namespace(namespace, default = '')
+        model_names = lookup_model_names.dup
+        lookups     = []
+
+        while !model_names.empty?
+          joined_model_names = model_names.join(".")
+          model_names.shift
+
+          lookups << :"#{joined_model_names}.#{lookup_action}.#{reflection_or_attribute_name}"
+          lookups << :"#{joined_model_names}.#{reflection_or_attribute_name}"
+        end
+        lookups << :"defaults.#{lookup_action}.#{reflection_or_attribute_name}"
+        lookups << :"defaults.#{reflection_or_attribute_name}"
+        lookups << default
+
+        I18n.t(lookups.shift, scope: :"#{i18n_scope}.#{namespace}", default: lookups).presence
+      end
+
+      def merge_wrapper_options(options, wrapper_options)
+        if wrapper_options
+          wrapper_options = set_input_classes(wrapper_options)
+
+          wrapper_options.merge(options) do |key, oldval, newval|
+            case key.to_s
+            when "class"
+              Array(oldval) + Array(newval)
+            when "data", "aria"
+              oldval.merge(newval)
+            else
+              newval
+            end
+          end
+        else
+          options
+        end
+      end
+
+      def set_input_classes(wrapper_options)
+        wrapper_options = wrapper_options.dup
+        error_class     = wrapper_options.delete(:error_class)
+        valid_class     = wrapper_options.delete(:valid_class)
+
+        if error_class.present? && has_errors?
+          wrapper_options[:class] = "#{wrapper_options[:class]} #{error_class}"
+        end
+
+        if valid_class.present? && valid?
+          wrapper_options[:class] = "#{wrapper_options[:class]} #{valid_class}"
+        end
+
+        wrapper_options
+      end
+
+      def i18n_scope
+        SimpleForm.i18n_scope
+      end
+    end
+  end
+end

data/simple_form-5.4.1/lib/simple_form/inputs/block_input.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+module SimpleForm
+  module Inputs
+    class BlockInput < Base
+      def initialize(*args, &block)
+        super
+        @block = block
+      end
+
+      def input(wrapper_options = nil)
+        template.capture(&@block)
+      end
+    end
+  end
+end

data/simple_form-5.4.1/lib/simple_form/inputs/boolean_input.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+module SimpleForm
+  module Inputs
+    class BooleanInput < Base
+      def input(wrapper_options = nil)
+        merged_input_options = merge_wrapper_options(input_html_options, wrapper_options)
+
+        if nested_boolean_style?
+          build_hidden_field_for_checkbox +
+            template.label_tag(nil, class: boolean_label_class) {
+              build_check_box_without_hidden_field(merged_input_options) +
+                inline_label
+            }
+        else
+          if include_hidden?
+            build_check_box(unchecked_value, merged_input_options)
+          else
+            build_check_box_without_hidden_field(merged_input_options)
+          end
+        end
+      end
+
+      def label_input(wrapper_options = nil)
+        if options[:label] == false || inline_label?
+          input(wrapper_options)
+        elsif nested_boolean_style?
+          html_options = label_html_options.dup
+          html_options[:class] ||= []
+          html_options[:class].push(boolean_label_class) if boolean_label_class
+
+          merged_input_options = merge_wrapper_options(input_html_options, wrapper_options)
+
+          build_hidden_field_for_checkbox +
+            @builder.label(label_target, html_options) {
+              build_check_box_without_hidden_field(merged_input_options) + label_text
+            }
+        else
+          input(wrapper_options) + label(wrapper_options)
+        end
+      end
+
+      private
+
+      def boolean_label_class
+        options[:boolean_label_class] || SimpleForm.boolean_label_class
+      end
+
+      # Build a checkbox tag using default unchecked value. This allows us to
+      # reuse the method for nested boolean style, but with no unchecked value,
+      # which won't generate the hidden checkbox. This is the default functionality
+      # in Rails > 3.2.1, and is backported in SimpleForm AV helpers.
+      def build_check_box(unchecked_value, options)
+        @builder.check_box(attribute_name, options, checked_value, unchecked_value)
+      end
+
+      # Build a checkbox without generating the hidden field. See
+      # #build_hidden_field_for_checkbox for more info.
+      def build_check_box_without_hidden_field(options)
+        build_check_box(nil, options)
+      end
+
+      # Create a hidden field for the current checkbox, so we can simulate Rails
+      # functionality with hidden + checkbox, but under a nested context, where
+      # we need the hidden field to be *outside* the label (otherwise it
+      # generates invalid html - html5 only).
+      def build_hidden_field_for_checkbox
+        return "".html_safe if !include_hidden? || !unchecked_value
+        options = { value: unchecked_value, id: nil, disabled: input_html_options[:disabled] }
+        options[:name] = input_html_options[:name] if input_html_options.key?(:name)
+        options[:form] = input_html_options[:form] if input_html_options.key?(:form)
+
+        @builder.hidden_field(attribute_name, options)
+      end
+
+      def inline_label?
+        nested_boolean_style? && options[:inline_label]
+      end
+
+      def inline_label
+        inline_option = options[:inline_label]
+
+        if inline_option
+          label = inline_option == true ? label_text : html_escape(inline_option)
+          " #{label}".html_safe
+        end
+      end
+
+      # Booleans are not required by default because in most of the cases
+      # it makes no sense marking them as required. The only exception is
+      # Terms of Use usually presented at most sites sign up screen.
+      def required_by_default?
+        false
+      end
+
+      def include_hidden?
+        options.fetch(:include_hidden, true)
+      end
+
+      def checked_value
+        options.fetch(:checked_value, '1')
+      end
+
+      def unchecked_value
+        options.fetch(:unchecked_value, '0')
+      end
+    end
+  end
+end

data/simple_form-5.4.1/lib/simple_form/inputs/collection_check_boxes_input.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+module SimpleForm
+  module Inputs
+    class CollectionCheckBoxesInput < CollectionRadioButtonsInput
+      protected
+
+      # Checkbox components do not use the required html tag.
+      # More info: https://github.com/heartcombo/simple_form/issues/340#issuecomment-2871956
+      def has_required?
+        false
+      end
+
+      def build_nested_boolean_style_item_tag(collection_builder)
+        collection_builder.check_box + collection_builder.text.to_s
+      end
+
+      def item_wrapper_class
+        "checkbox"
+      end
+    end
+  end
+end

data/simple_form-5.4.1/lib/simple_form/inputs/collection_input.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+module SimpleForm
+  module Inputs
+    class CollectionInput < Base
+      BASIC_OBJECT_CLASSES = [String, Integer, Float, NilClass, Symbol, TrueClass, FalseClass]
+      BASIC_OBJECT_CLASSES.push(Fixnum, Bignum) unless 1.class == Integer
+
+      # Default boolean collection for use with selects/radios when no
+      # collection is given. Always fallback to this boolean collection.
+      # Texts can be translated using i18n in "simple_form.yes" and
+      # "simple_form.no" keys. See the example locale file.
+      def self.boolean_collection
+        [ [I18n.t(:"simple_form.yes", default: 'Yes'), true],
+          [I18n.t(:"simple_form.no", default: 'No'), false] ]
+      end
+
+      def input(wrapper_options = nil)
+        raise NotImplementedError,
+          "input should be implemented by classes inheriting from CollectionInput"
+      end
+
+      def input_options
+        options = super
+
+        options[:include_blank] = true unless skip_include_blank?
+        translate_option options, :prompt
+        translate_option options, :include_blank
+
+        options
+      end
+
+      private
+
+      def collection
+        @collection ||= begin
+          collection = options.delete(:collection) || self.class.boolean_collection
+          collection.respond_to?(:call) ? collection.call : collection.to_a
+        end
+      end
+
+      def has_required?
+        super && (input_options[:include_blank] || input_options[:prompt].present? || multiple?)
+      end
+
+      # Check if :include_blank must be included by default.
+      def skip_include_blank?
+        (options.keys & %i[prompt include_blank default selected]).any? || multiple?
+      end
+
+      def multiple?
+        !!options[:input_html].try(:[], :multiple)
+      end
+
+      # Detect the right method to find the label and value for a collection.
+      # If no label or value method are defined, will attempt to find them based
+      # on default label and value methods that can be configured through
+      # SimpleForm.collection_label_methods and
+      # SimpleForm.collection_value_methods.
+      def detect_collection_methods
+        label, value = options.delete(:label_method), options.delete(:value_method)
+
+        unless label && value
+          common_method_for = detect_common_display_methods
+          label ||= common_method_for[:label]
+          value ||= common_method_for[:value]
+        end
+
+        [label, value]
+      end
+
+      def detect_common_display_methods(collection_classes = detect_collection_classes)
+        collection_translated = translate_collection if collection_classes == [Symbol]
+
+        if collection_translated || collection_classes.include?(Array)
+          { label: :first, value: :second }
+        elsif collection_includes_basic_objects?(collection_classes)
+          { label: :to_s, value: :to_s }
+        else
+          detect_method_from_class(collection_classes)
+        end
+      end
+
+      def detect_method_from_class(collection_classes)
+        sample = collection.first || collection.last
+
+        { label: SimpleForm.collection_label_methods.find { |m| sample.respond_to?(m) },
+          value: SimpleForm.collection_value_methods.find { |m| sample.respond_to?(m) } }
+      end
+
+      def detect_collection_classes(some_collection = collection)
+        some_collection.map(&:class).uniq
+      end
+
+      def collection_includes_basic_objects?(collection_classes)
+        (collection_classes & BASIC_OBJECT_CLASSES).any?
+      end
+
+      def translate_collection
+        if translated_collection = translate_from_namespace(:options)
+          @collection = collection.map do |key|
+            html_key = "#{key}_html".to_sym
+
+            if translated_collection[html_key]
+              [translated_collection[html_key].html_safe || key, key.to_s]
+            else
+              [translated_collection[key] || key, key.to_s]
+            end
+          end
+          true
+        end
+      end
+
+      def translate_option(options, key)
+        if options[key] == :translate
+          namespace = key.to_s.pluralize
+
+          options[key] = translate_from_namespace(namespace, true)
+        end
+      end
+    end
+  end
+end