trusty-cms 4.2 → 4.3.1

data/vendor/bundle/ruby/2.6.0/gems/actionview-6.0.3.4/lib/action_view/helpers/tags/base.rb

@@ -1,195 +0,0 @@
-# frozen_string_literal: true
-
-module ActionView
-  module Helpers
-    module Tags # :nodoc:
-      class Base # :nodoc:
-        include Helpers::ActiveModelInstanceTag, Helpers::TagHelper, Helpers::FormTagHelper
-        include FormOptionsHelper
-
-        attr_reader :object
-
-        def initialize(object_name, method_name, template_object, options = {})
-          @object_name, @method_name = object_name.to_s.dup, method_name.to_s.dup
-          @template_object = template_object
-
-          @object_name.sub!(/\[\]$/, "") || @object_name.sub!(/\[\]\]$/, "]")
-          @object = retrieve_object(options.delete(:object))
-          @skip_default_ids = options.delete(:skip_default_ids)
-          @allow_method_names_outside_object = options.delete(:allow_method_names_outside_object)
-          @options = options
-
-          if Regexp.last_match
-            @generate_indexed_names = true
-            @auto_index = retrieve_autoindex(Regexp.last_match.pre_match)
-          else
-            @generate_indexed_names = false
-            @auto_index = nil
-          end
-        end
-
-        # This is what child classes implement.
-        def render
-          raise NotImplementedError, "Subclasses must implement a render method"
-        end
-
-        private
-          def value
-            if @allow_method_names_outside_object
-              object.public_send @method_name if object && object.respond_to?(@method_name)
-            else
-              object.public_send @method_name if object
-            end
-          end
-
-          def value_before_type_cast
-            unless object.nil?
-              method_before_type_cast = @method_name + "_before_type_cast"
-
-              if value_came_from_user? && object.respond_to?(method_before_type_cast)
-                object.public_send(method_before_type_cast)
-              else
-                value
-              end
-            end
-          end
-
-          def value_came_from_user?
-            method_name = "#{@method_name}_came_from_user?"
-            !object.respond_to?(method_name) || object.public_send(method_name)
-          end
-
-          def retrieve_object(object)
-            if object
-              object
-            elsif @template_object.instance_variable_defined?("@#{@object_name}")
-              @template_object.instance_variable_get("@#{@object_name}")
-            end
-          rescue NameError
-            # As @object_name may contain the nested syntax (item[subobject]) we need to fallback to nil.
-            nil
-          end
-
-          def retrieve_autoindex(pre_match)
-            object = self.object || @template_object.instance_variable_get("@#{pre_match}")
-            if object && object.respond_to?(:to_param)
-              object.to_param
-            else
-              raise ArgumentError, "object[] naming but object param and @object var don't exist or don't respond to to_param: #{object.inspect}"
-            end
-          end
-
-          def add_default_name_and_id_for_value(tag_value, options)
-            if tag_value.nil?
-              add_default_name_and_id(options)
-            else
-              specified_id = options["id"]
-              add_default_name_and_id(options)
-
-              if specified_id.blank? && options["id"].present?
-                options["id"] += "_#{sanitized_value(tag_value)}"
-              end
-            end
-          end
-
-          def add_default_name_and_id(options)
-            index = name_and_id_index(options)
-            options["name"] = options.fetch("name") { tag_name(options["multiple"], index) }
-
-            if generate_ids?
-              options["id"] = options.fetch("id") { tag_id(index) }
-              if namespace = options.delete("namespace")
-                options["id"] = options["id"] ? "#{namespace}_#{options['id']}" : namespace
-              end
-            end
-          end
-
-          def tag_name(multiple = false, index = nil)
-            # a little duplication to construct less strings
-            case
-            when @object_name.empty?
-              "#{sanitized_method_name}#{multiple ? "[]" : ""}"
-            when index
-              "#{@object_name}[#{index}][#{sanitized_method_name}]#{multiple ? "[]" : ""}"
-            else
-              "#{@object_name}[#{sanitized_method_name}]#{multiple ? "[]" : ""}"
-            end
-          end
-
-          def tag_id(index = nil)
-            # a little duplication to construct less strings
-            case
-            when @object_name.empty?
-              sanitized_method_name.dup
-            when index
-              "#{sanitized_object_name}_#{index}_#{sanitized_method_name}"
-            else
-              "#{sanitized_object_name}_#{sanitized_method_name}"
-            end
-          end
-
-          def sanitized_object_name
-            @sanitized_object_name ||= @object_name.gsub(/\]\[|[^-a-zA-Z0-9:.]/, "_").sub(/_$/, "")
-          end
-
-          def sanitized_method_name
-            @sanitized_method_name ||= @method_name.sub(/\?$/, "")
-          end
-
-          def sanitized_value(value)
-            value.to_s.gsub(/[\s\.]/, "_").gsub(/[^-[[:word:]]]/, "").downcase
-          end
-
-          def select_content_tag(option_tags, options, html_options)
-            html_options = html_options.stringify_keys
-            add_default_name_and_id(html_options)
-
-            if placeholder_required?(html_options)
-              raise ArgumentError, "include_blank cannot be false for a required field." if options[:include_blank] == false
-              options[:include_blank] ||= true unless options[:prompt]
-            end
-
-            value = options.fetch(:selected) { value() }
-            select = content_tag("select", add_options(option_tags, options, value), html_options)
-
-            if html_options["multiple"] && options.fetch(:include_hidden, true)
-              tag("input", disabled: html_options["disabled"], name: html_options["name"], type: "hidden", value: "") + select
-            else
-              select
-            end
-          end
-
-          def placeholder_required?(html_options)
-            # See https://html.spec.whatwg.org/multipage/forms.html#attr-select-required
-            html_options["required"] && !html_options["multiple"] && html_options.fetch("size", 1).to_i == 1
-          end
-
-          def add_options(option_tags, options, value = nil)
-            if options[:include_blank]
-              option_tags = tag_builder.content_tag_string("option", options[:include_blank].kind_of?(String) ? options[:include_blank] : nil, value: "") + "\n" + option_tags
-            end
-            if value.blank? && options[:prompt]
-              tag_options = { value: "" }.tap do |prompt_opts|
-                prompt_opts[:disabled] = true if options[:disabled] == ""
-                prompt_opts[:selected] = true if options[:selected] == ""
-              end
-              option_tags = tag_builder.content_tag_string("option", prompt_text(options[:prompt]), tag_options) + "\n" + option_tags
-            end
-            option_tags
-          end
-
-          def name_and_id_index(options)
-            if options.key?("index")
-              options.delete("index") || ""
-            elsif @generate_indexed_names
-              @auto_index || ""
-            end
-          end
-
-          def generate_ids?
-            !@skip_default_ids
-          end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/actionview-6.0.3.4/lib/action_view/helpers/tags/check_box.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-require "action_view/helpers/tags/checkable"
-
-module ActionView
-  module Helpers
-    module Tags # :nodoc:
-      class CheckBox < Base #:nodoc:
-        include Checkable
-
-        def initialize(object_name, method_name, template_object, checked_value, unchecked_value, options)
-          @checked_value   = checked_value
-          @unchecked_value = unchecked_value
-          super(object_name, method_name, template_object, options)
-        end
-
-        def render
-          options = @options.stringify_keys
-          options["type"]     = "checkbox"
-          options["value"]    = @checked_value
-          options["checked"] = "checked" if input_checked?(options)
-
-          if options["multiple"]
-            add_default_name_and_id_for_value(@checked_value, options)
-            options.delete("multiple")
-          else
-            add_default_name_and_id(options)
-          end
-
-          include_hidden = options.delete("include_hidden") { true }
-          checkbox = tag("input", options)
-
-          if include_hidden
-            hidden = hidden_field_for_checkbox(options)
-            hidden + checkbox
-          else
-            checkbox
-          end
-        end
-
-        private
-          def checked?(value)
-            case value
-            when TrueClass, FalseClass
-              value == !!@checked_value
-            when NilClass
-              false
-            when String
-              value == @checked_value
-            else
-              if value.respond_to?(:include?)
-                value.include?(@checked_value)
-              else
-                value.to_i == @checked_value.to_i
-              end
-            end
-          end
-
-          def hidden_field_for_checkbox(options)
-            @unchecked_value ? tag("input", options.slice("name", "disabled", "form").merge!("type" => "hidden", "value" => @unchecked_value)) : "".html_safe
-          end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/actionview-6.0.3.4/lib/action_view/helpers/tags/checkable.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module ActionView
-  module Helpers
-    module Tags # :nodoc:
-      module Checkable # :nodoc:
-        def input_checked?(options)
-          if options.has_key?("checked")
-            checked = options.delete "checked"
-            checked == true || checked == "checked"
-          else
-            checked?(value)
-          end
-        end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/actionview-6.0.3.4/lib/action_view/helpers/tags/collection_check_boxes.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require "action_view/helpers/tags/collection_helpers"
-
-module ActionView
-  module Helpers
-    module Tags # :nodoc:
-      class CollectionCheckBoxes < Base # :nodoc:
-        include CollectionHelpers
-
-        class CheckBoxBuilder < Builder # :nodoc:
-          def check_box(extra_html_options = {})
-            html_options = extra_html_options.merge(@input_html_options)
-            html_options[:multiple] = true
-            html_options[:skip_default_ids] = false
-            @template_object.check_box(@object_name, @method_name, html_options, @value, nil)
-          end
-        end
-
-        def render(&block)
-          render_collection_for(CheckBoxBuilder, &block)
-        end
-
-        private
-          def render_component(builder)
-            builder.check_box + builder.label
-          end
-
-          def hidden_field_name
-            "#{super}[]"
-          end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/actionview-6.0.3.4/lib/action_view/helpers/tags/collection_helpers.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-module ActionView
-  module Helpers
-    module Tags # :nodoc:
-      module CollectionHelpers # :nodoc:
-        class Builder # :nodoc:
-          attr_reader :object, :text, :value
-
-          def initialize(template_object, object_name, method_name, object,
-                         sanitized_attribute_name, text, value, input_html_options)
-            @template_object = template_object
-            @object_name = object_name
-            @method_name = method_name
-            @object = object
-            @sanitized_attribute_name = sanitized_attribute_name
-            @text = text
-            @value = value
-            @input_html_options = input_html_options
-          end
-
-          def label(label_html_options = {}, &block)
-            html_options = @input_html_options.slice(:index, :namespace).merge(label_html_options)
-            html_options[:for] ||= @input_html_options[:id] if @input_html_options[:id]
-
-            @template_object.label(@object_name, @sanitized_attribute_name, @text, html_options, &block)
-          end
-        end
-
-        def initialize(object_name, method_name, template_object, collection, value_method, text_method, options, html_options)
-          @collection   = collection
-          @value_method = value_method
-          @text_method  = text_method
-          @html_options = html_options
-
-          super(object_name, method_name, template_object, options)
-        end
-
-        private
-          def instantiate_builder(builder_class, item, value, text, html_options)
-            builder_class.new(@template_object, @object_name, @method_name, item,
-                              sanitize_attribute_name(value), text, value, html_options)
-          end
-
-          # Generate default options for collection helpers, such as :checked and
-          # :disabled.
-          def default_html_options_for_collection(item, value)
-            html_options = @html_options.dup
-
-            [:checked, :selected, :disabled, :readonly].each do |option|
-              current_value = @options[option]
-              next if current_value.nil?
-
-              accept = if current_value.respond_to?(:call)
-                current_value.call(item)
-              else
-                Array(current_value).map(&:to_s).include?(value.to_s)
-              end
-
-              if accept
-                html_options[option] = true
-              elsif option == :checked
-                html_options[option] = false
-              end
-            end
-
-            html_options[:object] = @object
-            html_options
-          end
-
-          def sanitize_attribute_name(value)
-            "#{sanitized_method_name}_#{sanitized_value(value)}"
-          end
-
-          def render_collection
-            @collection.map do |item|
-              value = value_for_collection(item, @value_method)
-              text  = value_for_collection(item, @text_method)
-              default_html_options = default_html_options_for_collection(item, value)
-              additional_html_options = option_html_attributes(item)
-
-              yield item, value, text, default_html_options.merge(additional_html_options)
-            end.join.html_safe
-          end
-
-          def render_collection_for(builder_class, &block)
-            options = @options.stringify_keys
-            rendered_collection = render_collection do |item, value, text, default_html_options|
-              builder = instantiate_builder(builder_class, item, value, text, default_html_options)
-
-              if block_given?
-                @template_object.capture(builder, &block)
-              else
-                render_component(builder)
-              end
-            end
-
-            # Prepend a hidden field to make sure something will be sent back to the
-            # server if all radio buttons are unchecked.
-            if options.fetch("include_hidden", true)
-              hidden_field + rendered_collection
-            else
-              rendered_collection
-            end
-          end
-
-          def hidden_field
-            hidden_name = @html_options[:name] || hidden_field_name
-            @template_object.hidden_field_tag(hidden_name, "", id: nil)
-          end
-
-          def hidden_field_name
-            "#{tag_name(false, @options[:index])}"
-          end
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.6.0/gems/actionview-6.0.3.4/lib/action_view/helpers/tags/collection_radio_buttons.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require "action_view/helpers/tags/collection_helpers"
-
-module ActionView
-  module Helpers
-    module Tags # :nodoc:
-      class CollectionRadioButtons < Base # :nodoc:
-        include CollectionHelpers
-
-        class RadioButtonBuilder < Builder # :nodoc:
-          def radio_button(extra_html_options = {})
-            html_options = extra_html_options.merge(@input_html_options)
-            html_options[:skip_default_ids] = false
-            @template_object.radio_button(@object_name, @method_name, @value, html_options)
-          end
-        end
-
-        def render(&block)
-          render_collection_for(RadioButtonBuilder, &block)
-        end
-
-        private
-          def render_component(builder)
-            builder.radio_button + builder.label
-          end
-      end
-    end
-  end
-end