arara 0.2.0

data/app/components/arara/tags/chipset.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "action_view/helpers/tags/placeholderable"
+
+module Arara
+  module Tags # :nodoc:
+    class Chipset < ActionView::Helpers::Tags::Base # :nodoc:
+      attr_reader :block
+      include ActionView::Helpers::Tags::Placeholderable
+
+      def initialize(object_name, method_name, template_object, options = {}, &block)
+        @block = block
+        super
+      end
+
+      def render
+        options = @options.stringify_keys
+        options["value"] = options.fetch("value") { value_before_type_cast } unless field_type == "file"
+        if options["variant"] == :choice
+          options["include_choice_hidden_field"] = true
+        end
+        add_default_name_and_id(options)
+
+        @template_object.template.render(Arara::ChipsetComponent, options.symbolize_keys, &block)
+      end
+
+      class << self
+        def field_type
+          @field_type ||= name.split("::").last.sub("Field", "").downcase
+        end
+      end
+
+      private
+        def field_type
+          self.class.field_type
+        end
+    end
+  end
+end

data/app/components/arara/tags/country_select.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Arara
+  module Tags # :nodoc:
+    class CountrySelect < ActionView::Helpers::Tags::Base # :nodoc:
+      include ::CountrySelect::TagHelper
+
+      # def initialize(object_name, method_name, template_object, choices, options, html_options)
+      #   @choices = block_given? ? template_object.capture { yield || "" } : choices
+      #   @choices = @choices.to_a if @choices.is_a?(Range)
+
+      #   @html_options = html_options
+
+      #   super(object_name, method_name, template_object, options)
+      # end
+      def initialize(object_name, method_name, template_object, options, html_options)
+        @html_options = html_options
+
+        super(object_name, method_name, template_object, options)
+      end
+
+      # def render
+      #   option_tags_options = {
+      #     selected: @options.fetch(:selected) { value.to_s },
+      #     disabled: @options[:disabled]
+      #   }
+
+      #   option_tags = if grouped_choices?
+      #     grouped_options_for_select(@choices, option_tags_options)
+      #   else
+      #     options_for_select(@choices, option_tags_options)
+      #   end
+
+      #   if option_tags_options[:selected]
+      #      selected_element = @choices.select { |x| x[1].to_s == option_tags_options[:selected] }.first
+      #      if selected_element
+      #       selected_label = selected_element[0].to_s
+      #       selected_value = selected_element[1].to_s
+      #      end
+      #      @options.merge!(
+      #        selected_value: selected_value,
+      #        selected_label: selected_label,
+      #      )
+      #   end
+
+      #   select_content_tag(option_tags, @options, @html_options)
+      # end
+      def render
+        select_content_tag(country_option_tags, @options, @html_options)
+      end
+
+      # my method
+      def options_for_select(container, selected = nil)
+        return container if String === container
+
+        selected, disabled = extract_selected_and_disabled(selected).map do |r|
+          Array(r).map(&:to_s)
+        end
+
+        container.map do |element|
+          html_attributes = option_html_attributes(element)
+          text, value = option_text_and_value(element).map(&:to_s)
+
+          html_attributes[:selected] ||= option_value_selected?(value, selected)
+          html_attributes[:disabled] ||= disabled && option_value_selected?(value, disabled)
+          html_attributes[:value] = value
+
+          # also set the label
+          html_attributes[:label] = text
+
+          # and render our component
+          @template_object.template.render(Arara::SelectItemComponent, html_attributes.symbolize_keys)
+        end.join("\n").html_safe
+      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
+
+        select_options = options.merge(html_options)
+        @template_object.template.render(Arara::SelectComponent, select_options.symbolize_keys) do
+          option_tags
+        end
+      end
+
+      private
+        # Grouped choices look like this:
+        #
+        #   [nil, []]
+        #   { nil => [] }
+        def grouped_choices?
+          !@choices.blank? && @choices.first.respond_to?(:last) && Array === @choices.first.last
+        end
+    end
+  end
+end

data/app/components/arara/tags/label.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Arara
+  module Tags # :nodoc:
+    class Label < ActionView::Helpers::Tags::Base # :nodoc:
+      class LabelBuilder # :nodoc:
+        attr_reader :object
+
+        def initialize(template_object, object_name, method_name, object, tag_value)
+          @template_object = template_object
+          @object_name = object_name
+          @method_name = method_name
+          @object = object
+          @tag_value = tag_value
+        end
+
+        def translation
+          method_and_value = @tag_value.present? ? "#{@method_name}.#{@tag_value}" : @method_name
+
+          content ||= Translator
+            .new(object, @object_name, method_and_value, scope: "helpers.label")
+            .translate
+          content ||= @method_name.humanize
+
+          content
+        end
+      end
+
+      def initialize(object_name, method_name, template_object, content_or_options = nil, options = nil)
+        options ||= {}
+
+        content_is_options = content_or_options.is_a?(Hash)
+        if content_is_options
+          options.merge! content_or_options
+          @content = nil
+        else
+          @content = content_or_options
+        end
+
+        super(object_name, method_name, template_object, options)
+      end
+
+      def render(&block)
+        options = @options.stringify_keys
+        tag_value = options.delete("value")
+        name_and_id = options.dup
+
+        if name_and_id["for"]
+          name_and_id["id"] = name_and_id["for"]
+        else
+          name_and_id.delete("id")
+        end
+
+        add_default_name_and_id_for_value(tag_value, name_and_id)
+        options.delete("index")
+        options.delete("namespace")
+        options["for"] = name_and_id["id"] unless options.key?("for")
+
+        builder = LabelBuilder.new(@template_object, @object_name, @method_name, @object, tag_value)
+
+        content = if block_given?
+          @template_object.capture(builder, &block)
+        elsif @content.present?
+          @content.to_s
+        else
+          render_component(builder)
+        end
+
+        label_tag(name_and_id["id"], content, options)
+      end
+
+      private
+        def render_component(builder)
+          builder.translation
+        end
+    end
+  end
+end

data/app/components/arara/tags/password_field.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "action_view/helpers/tags/placeholderable"
+
+module Arara
+  module Tags # :nodoc:
+    class PasswordField < TextField # :nodoc:
+      include ActionView::Helpers::Tags::Placeholderable
+
+      def render
+        @options = { value: nil }.merge!(@options)
+        super
+      end
+    end
+  end
+end

data/app/components/arara/tags/radio_button.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "action_view/helpers/tags/checkable"
+
+module Arara
+  module Tags # :nodoc:
+    class RadioButton < ActionView::Helpers::Tags::Base # :nodoc:
+      include ActionView::Helpers::Tags::Checkable
+
+      def initialize(object_name, method_name, template_object, tag_value, options)
+        @tag_value = tag_value
+        super(object_name, method_name, template_object, options)
+      end
+
+      def render
+        options = @options.stringify_keys
+        options["type"]     = "radio"
+        options["value"]    = @tag_value
+        options["checked"] = "checked" if input_checked?(options)
+        add_default_name_and_id_for_value(@tag_value, options)
+
+        @template_object.template.render(Arara::RadioButtonComponent, options.symbolize_keys)
+      end
+
+      private
+        def checked?(value)
+          value.to_s == @tag_value.to_s
+        end
+    end
+  end
+end

data/app/components/arara/tags/select.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Arara
+  module Tags # :nodoc:
+    class Select < ActionView::Helpers::Tags::Base # :nodoc:
+      def initialize(object_name, method_name, template_object, choices, options, html_options)
+        @choices = block_given? ? template_object.capture { yield || "" } : choices
+        @choices = @choices.to_a if @choices.is_a?(Range)
+
+        @html_options = html_options
+
+        super(object_name, method_name, template_object, options)
+      end
+
+      def render
+        option_tags_options = {
+          selected: @options.fetch(:selected) { value.to_s },
+          disabled: @options[:disabled]
+        }
+
+        option_tags = if grouped_choices?
+          grouped_options_for_select(@choices, option_tags_options)
+        else
+          options_for_select(@choices, option_tags_options)
+        end
+
+        if option_tags_options[:selected]
+           selected_element = @choices.select { |x| x[1].to_s == option_tags_options[:selected] }.first
+           if selected_element
+            selected_label = selected_element[0].to_s
+            selected_value = selected_element[1].to_s
+           end
+           @options.merge!(
+             selected_value: selected_value,
+             selected_label: selected_label,
+           )
+        end
+
+        select_content_tag(option_tags, @options, @html_options)
+      end
+
+      # def render
+      #   option_tags_options = {
+      #     selected: @options.fetch(:selected) { value.to_s },
+      #     disabled: @options[:disabled]
+      #   }
+
+      #   option_tags = if grouped_choices?
+      #     grouped_options_for_select(@choices, option_tags_options)
+      #   else
+      #     options_for_select(@choices, option_tags_options)
+      #   end
+
+      #   # select_content_tag(option_tags, @options, @html_options)
+
+      #   @options.merge!(@html_options)
+      #   @template_object.template.render(SelectComponent, @options.symbolize_keys) do
+      #     option_tags
+      #   end
+      # end
+
+      # my method
+      def options_for_select(container, selected = nil)
+        return container if String === container
+
+        selected, disabled = extract_selected_and_disabled(selected).map do |r|
+          Array(r).map(&:to_s)
+        end
+
+        container.map do |element|
+          html_attributes = option_html_attributes(element)
+          text, value = option_text_and_value(element).map(&:to_s)
+
+          html_attributes[:selected] ||= option_value_selected?(value, selected)
+          html_attributes[:disabled] ||= disabled && option_value_selected?(value, disabled)
+          html_attributes[:value] = value
+
+          # also set the label
+          html_attributes[:label] = text
+
+          # and render our component
+          @template_object.template.render(Arara::SelectItemComponent, html_attributes.symbolize_keys)
+        end.join("\n").html_safe
+      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
+
+        select_options = options.merge(html_options)
+        @template_object.template.render(Arara::SelectComponent, select_options.symbolize_keys) do
+          option_tags
+        end
+      end
+
+      private
+        # Grouped choices look like this:
+        #
+        #   [nil, []]
+        #   { nil => [] }
+        def grouped_choices?
+          !@choices.blank? && @choices.first.respond_to?(:last) && Array === @choices.first.last
+        end
+    end
+  end
+end

data/app/components/arara/tags/text_area.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "action_view/helpers/tags/placeholderable"
+
+module Arara
+  module Tags # :nodoc:
+    class TextArea < ActionView::Helpers::Tags::Base # :nodoc:
+      include ActionView::Helpers::Tags::Placeholderable
+
+      def render
+        options = @options.stringify_keys
+        add_default_name_and_id(options)
+
+        if size = options.delete("size")
+          options["cols"], options["rows"] = size.split("x") if size.respond_to?(:split)
+        end
+
+        options["textarea"] = true
+        options["value"] = options.delete("value") { value_before_type_cast }
+
+        @template_object.template.render(Arara::TextFieldComponent, options.symbolize_keys)
+      end
+    end
+  end
+end

data/app/components/arara/tags/text_field.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "action_view/helpers/tags/placeholderable"
+
+module Arara
+  module Tags # :nodoc:
+    class TextField < ActionView::Helpers::Tags::Base # :nodoc:
+      include ActionView::Helpers::Tags::Placeholderable
+
+      def render
+        options = @options.stringify_keys
+        options["size"] = options["maxlength"] unless options.key?("size")
+        options["type"] ||= field_type
+        options["value"] = options.fetch("value") { value_before_type_cast } unless field_type == "file"
+        add_default_name_and_id(options)
+        @template_object.template.render(Arara::TextFieldComponent, options.symbolize_keys)
+      end
+
+      class << self
+        def field_type
+          @field_type ||= name.split("::").last.sub("Field", "").downcase
+        end
+      end
+
+      private
+        def field_type
+          self.class.field_type
+        end
+    end
+  end
+end