ccs-frontend_helpers 0.1.2 → 0.3.0

data/lib/ccs/components/govuk/exit_this_page.rb

@@ -0,0 +1,79 @@
+require_relative '../base'
+require_relative 'button'
+
+module CCS
+  module Components
+    module GovUK
+      # = GOV.UK Exit this page
+      #
+      # This is used to generate the exit this page component from the
+      # {https://design-system.service.gov.uk/components/exit-this-page GDS - Components - Exit this page}
+      #
+      # @!attribute [r] text
+      #   @return [String] Text for the exit this page
+      # @!attribute [r] redirect_url
+      #   @return [String] The redirect_url for the exit this page
+
+      class ExitThisPage < Base
+        include ActionView::Context
+        include ActionView::Helpers
+
+        private
+
+        attr_reader :text, :redirect_url
+
+        public
+
+        # @param text [String] the text for the exit this page
+        # @param redirect_url [String] the href for the exit this page
+        # @param options [Hash] options that will be used in customising the HTML
+        #
+        # @option options [String] :classes additional CSS classes for the exit this page HTML
+        # @option options [String] :activated_text Text announced by screen readers when Exit this Page has been activated via the keyboard shortcut. Defaults to "Loading."
+        # @option options [String] :timed_out_text Text announced by screen readers when the keyboard shortcut has timed out without successful activation. Defaults to "Exit this page expired."
+        # @option options [String] :press_two_more_times_text Text announced by screen readers when the user must press Shift two more times to activate the button. Defaults to "Shift, press 2 more times to exit."
+        # @option options [String] :press_one_more_time_text Text announced by screen readers when the user must press Shift one more time to activate the button. Defaults to "Shift, press 1 more time to exit."
+        # @option options [Hash] :attributes ({}) any additional attributes that will added as part of the HTML
+
+        def initialize(text: nil, redirect_url: nil, **options)
+          super(**options)
+
+          @text = text || default_text
+          @redirect_url = redirect_url || 'https://www.bbc.co.uk/weather'
+
+          %i[activated timed_out press_two_more_times press_one_more_time].each do |data_attribute|
+            data_attribute_name = :"#{data_attribute}_text"
+            @options[:attributes][:data][:"i18n.#{data_attribute.to_s.gsub('_', '-')}"] = options[data_attribute_name] if options[data_attribute_name]
+          end
+        end
+
+        # Generates the HTML for the GOV.UK Exit this page component
+        #
+        # @return [ActiveSupport::SafeBuffer]
+
+        def render
+          tag.div(**options[:attributes]) do
+            Button.new(text: text, href: redirect_url, context: context, classes: 'govuk-button--warning govuk-exit-this-page__button govuk-js-exit-this-page-button', attributes: { rel: 'nofollow noreferrer' }).render
+          end
+        end
+
+        # The default attributes for the exit this page
+
+        DEFAULT_ATTRIBUTES = { class: 'govuk-exit-this-page', data: { module: 'govuk-exit-this-page' } }.freeze
+
+        private
+
+        # Generates the default HTML for the GOV.UK exit this page component
+        #
+        # @return [ActiveSupport::SafeBuffer]
+
+        def default_text
+          capture do
+            concat(tag.span('Emergency', class: 'govuk-visually-hidden'))
+            concat(' Exit this page')
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ccs/components/govuk/field/input/character_count/count_message.rb

@@ -0,0 +1,62 @@
+module CCS
+  module Components
+    module GovUK
+      class Field < Base
+        class Input < Field
+          class CharacterCount
+            # = GOV.UK Character count message
+            #
+            # This is used to generate the character count message
+            #
+            # @!attribute [r] count_message
+            #   @return [Hint] Hint with the count message
+            # @!attribute [r] after_input
+            #   @return [String] Text or HTML for after the textarea input
+
+            class CountMessage
+              include ActionView::Context
+              include ActionView::Helpers
+
+              private
+
+              attr_reader :count_message, :after_input
+
+              public
+
+              # @param character_count_attribute [String] the name of the field as it will appear in the textarea
+              # @param context [ActionView::Base] the view context
+              # @param character_count_options (see CCS::Components::GovUK::Field::Input::CharacterCount.get_character_count_from_group_options)
+              # @param after_input [String] Text or HTML that goes after the input
+              #
+              # @option (see CCS::Components::GovUK::Field::Input::CharacterCount.get_character_count_from_group_options)
+
+              def initialize(character_count_attribute:, context:, character_count_options:, after_input: nil)
+                count_message = character_count_options[:textarea_description] || {}
+
+                count_message_length = character_count_options[:maxwords] || character_count_options[:maxlength]
+                count_message_default = "You can enter up to %<count>s #{character_count_options[:maxwords] ? 'words' : 'characters'}"
+
+                text = count_message_length ? format(count_message[:count_message] || count_message_default, count: count_message_length) : ''
+                classes = "govuk-character-count__message #{count_message[:classes]}".rstrip
+
+                @count_message = Hint.new(text: text, classes: classes, attributes: { id: "#{character_count_attribute}-info" }, context: context)
+                @after_input = after_input
+              end
+
+              # Generates the HTML for the GOV.UK Character count message
+              #
+              # @return [ActiveSupport::SafeBuffer]
+
+              def render
+                capture do
+                  concat(count_message.render)
+                  concat(after_input) if after_input
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ccs/components/govuk/field/input/character_count.rb

@@ -1,5 +1,5 @@
 require_relative 'textarea'
-require_relative '../../hint'
+require_relative 'character_count/count_message'
 
 module CCS
   module Components
@@ -15,18 +15,15 @@ module CCS
           #
           # @!attribute [r] textarea
           #   @return [Textarea] The initialised textarea
-          # @!attribute [r] fallback_hint
-          #   @return [Hint] The initialised character count fallback hint
+          # @!attribute [r] textarea_description
+          #   @return [Hint] The initialised character count textarea description
           # @!attribute [r] character_count_html_options
           #   @return [Hash] HTML options for the character count
 
           class CharacterCount
-            include ActionView::Context
-            include ActionView::Helpers
-
             private
 
-            attr_reader :textarea, :fallback_hint, :character_count_html_options
+            attr_reader :textarea, :textarea_description
 
             public
 
@@ -38,24 +35,13 @@ module CCS
             #
             # @option (see initialise_character_count_html_options)
 
-            def initialize(attribute:, character_count_options:, context:, **options)
+            def initialize(attribute:, context:, character_count_options: {}, **options)
               character_count_attribute = options[:form] ? "#{options[:form].object_name}_#{attribute}" : attribute
 
-              initialise_textarea(attribute, character_count_attribute, context, options)
-              initialise_character_count_html_options(character_count_options)
-              initialise_fallback_hint(character_count_attribute, context, character_count_options)
+              initialise_textarea(attribute, character_count_attribute, character_count_options, context, options)
             end
 
-            # Generates the HTML for the GOV.UK Character count component
-            #
-            # @return [ActiveSupport::SafeBuffer]
-
-            def render
-              tag.div(**character_count_html_options) do
-                concat(textarea.render)
-                concat(fallback_hint.render)
-              end
-            end
+            delegate :render, to: :textarea
 
             private
 
@@ -63,19 +49,23 @@ module CCS
             #
             # @param attribute [Symbol] the attribute of the field
             # @param character_count_attribute [String] the name of the field as it will appear in the textarea
+            # @param character_count_options [Hash] options for the character count
             # @param context [ActionView::Base] the view context
             # @param options [Hash] options that will be used for the textarea
             #
             # @option (see CCS::Components::GovUK::Field::Input::Textarea#initialize)
 
-            def initialise_textarea(attribute, character_count_attribute, context, options)
+            def initialise_textarea(attribute, character_count_attribute, character_count_options, context, options)
+              set_character_count_from_group_options(character_count_options, options)
+
               ((options[:attributes] ||= {})[:aria] ||= {})[:describedby] = [options.dig(:attributes, :aria, :describedby), "#{character_count_attribute}-info"].compact.join(' ')
-              options[:classes] = "#{options[:classes]} govuk-js-character-count".lstrip
+              options[:classes] = "govuk-js-character-count #{options[:classes]}".rstrip
 
-              @textarea = Textarea.new(attribute: attribute, context: context, **options)
+              count_message = CountMessage.new(character_count_attribute: character_count_attribute, context: context, character_count_options: character_count_options, after_input: options.delete(:after_input))
+              @textarea = Textarea.new(attribute: attribute, context: context, after_input: count_message.render, **options)
             end
 
-            # Initialises the charcter count options
+            # Sets the charcter count form group options
             #
             # @param character_count_options [Hash] options for the charcter count
             #
@@ -87,40 +77,63 @@ module CCS
             #                                                    If +maxwords+ is provided, the +maxlength+ option will be ignored.
             # @option character_count_options [String] :threshold the percentage value of the limit at which point the count message is displayed.
             #                                                     If this attribute is set, the count message will be hidden by default.
-            # @option character_count_options [Hash] :fallback_hint ({}) additional parameters that will be used to create the hint containing the character count text:
+            # @option character_count_options [Hash] :textarea_description ({}) additional parameters that will be used to create the hint containing the character count text:
             #                                                            - +:count_message+ replaced the default text for the count message.
             #                                                                               If you want the count number to appear, put %<count>s in the string and it will be replaced with the number
-            #                                                            - +classes+ additional CSS classes for the fallback hint HTML
-
-            def initialise_character_count_html_options(character_count_options)
-              character_count_html_options = { class: 'govuk-character-count', data: { module: 'govuk-character-count' } }
+            #                                                            - +classes+ additional CSS classes for the textarea description HTML
+            # @option character_count_options [String] :characters_under_limit Message displayed when the number of characters is under the configured maximum, maxlength
+            # @option character_count_options [String] :characters_at_limit_text Message displayed when the number of characters reaches the configured maximum, maxlength
+            # @option character_count_options [String] :characters_over_limit Message displayed when the number of characters is over the configured maximum, maxlength
+            # @option character_count_options [String] :words_under_limit Message displayed when the number of words is under the configured maximum, maxwords
+            # @option character_count_options [String] :words_at_limit_text Message displayed when the number of words reaches the configured maximum, maxwords
+            # @option character_count_options [String] :words_over_limit Message displayed when the number of words is over the configured maximum, maxwords
+
+            def set_character_count_from_group_options(character_count_options, options)
+              (options[:form_group] ||= {})[:classes] = "govuk-character-count #{options.dig(:form_group, :classes)}".rstrip
+              ((options[:form_group][:attributes] ||= {})[:data] ||= {})[:module] = 'govuk-character-count'
 
               %i[maxlength threshold maxwords].each do |data_attribute|
-                character_count_html_options[:data][data_attribute] = character_count_options[data_attribute].to_s if character_count_options[data_attribute]
+                options[:form_group][:attributes][:data][data_attribute] = character_count_options[data_attribute].to_s if character_count_options[data_attribute]
               end
 
-              @character_count_html_options = character_count_html_options
+              get_chacrter_count_translations(character_count_options) do |data_attribute, value|
+                options[:form_group][:attributes][:data][data_attribute] = value
+              end
             end
 
-            # Initialises the charcter count fall back hint
+            # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+            # Generator for the translation options for character count
             #
-            # @param character_count_attribute [String] the name of the field as it will appear in the textarea
-            # @param context [ActionView::Base] the view context
             # @param (see initialise_character_count_html_options)
             #
             # @option (see initialise_character_count_html_options)
+            #
+            # @return [Hash]
 
-            def initialise_fallback_hint(character_count_attribute, context, character_count_options)
-              fallback_hint = character_count_options[:fallback_hint] || {}
+            def get_chacrter_count_translations(character_count_options)
+              %i[characters_at_limit words_at_limit].each do |data_attribute|
+                data_attribute_name = :"#{data_attribute}_text"
 
-              fallback_hint_length = character_count_options[:maxwords] || character_count_options[:maxlength]
-              fallback_hint_default = "You can enter up to %<count>s #{character_count_options[:maxwords] ? 'words' : 'characters'}"
+                next unless character_count_options[data_attribute_name]
+
+                yield :"i18n.#{data_attribute.to_s.gsub('_', '-')}", character_count_options[data_attribute_name]
+              end
 
-              text = format(fallback_hint[:count_message] || fallback_hint_default, count: fallback_hint_length)
-              classes = "#{fallback_hint[:classes]} govuk-character-count__message".lstrip
+              %i[characters_under_limit characters_over_limit words_under_limit words_over_limit].each do |data_attribute|
+                next unless character_count_options[data_attribute]
 
-              @fallback_hint = Hint.new(text: text, classes: classes, attributes: { id: "#{character_count_attribute}-info" }, context: context)
+                %i[other one].each do |plural_rule|
+                  next unless character_count_options[data_attribute][plural_rule]
+
+                  yield :"i18n.#{data_attribute.to_s.gsub('_', '-')}.#{plural_rule}", character_count_options[data_attribute][plural_rule]
+                end
+              end
+
+              yield :'i18n.textarea-description.other', character_count_options[:textarea_description][:count_message] if character_count_options.dig(:textarea_description, :count_message) && !(character_count_options[:maxwords] || character_count_options[:maxlength])
             end
+
+            # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           end
         end
       end

data/lib/ccs/components/govuk/field/input/password_input/show_hide_button.rb

@@ -0,0 +1,72 @@
+require_relative '../../../button'
+
+module CCS
+  module Components
+    module GovUK
+      class Field < Base
+        class Input < Field
+          class PasswordInput
+            # = GOV.UK Password input show/hide button
+            #
+            # This is used to generate the password input show/hide button
+            #
+            # @!attribute [r] show_hide_button
+            #   @return [Button] Show/Hide button
+            # @!attribute [r] after_input
+            #   @return [String] Text or HTML for after the textarea input
+
+            class ShowHideButton
+              include ActionView::Context
+              include ActionView::Helpers
+              include ActionView::Helpers::FormTagHelper
+
+              private
+
+              attr_reader :show_hide_button, :after_input
+
+              public
+
+              # @param attribute [String] the name of the field as it will appear in the input
+              # @param context [ActionView::Base] the view context
+              # @param button [Hash] options for the button
+              # @param after_input [String] Text or HTML that goes after the input
+              #
+              # @option button [String] :classes classes to add to the button
+              #
+              # @option (see CCS::Components::GovUK::Field::Input::PasswordInput.set_password_input_from_group_options)
+
+              def initialize(attribute:, context:, button: {}, after_input: nil, **options)
+                button[:classes] = "govuk-button--secondary govuk-password-input__toggle govuk-js-password-input-toggle #{button[:classes]}".rstrip
+                button[:attributes] = {
+                  type: :button,
+                  aria: {
+                    controls: options.dig(:attributes, :id) || field_id(options[:form]&.object_name, attribute),
+                    label: options[:show_password_aria_label_text] || 'Show password'
+                  },
+                  hidden: {
+                    value: true,
+                    optional: true
+                  }
+                }
+
+                @show_hide_button = Button.new(text: options[:show_password_text] || 'Show', context: context, classes: button[:classes], attributes: button[:attributes])
+                @after_input = after_input
+              end
+
+              # Generates the HTML for the GOV.UK Password input show/hide button
+              #
+              # @return [ActiveSupport::SafeBuffer]
+
+              def render
+                capture do
+                  concat(show_hide_button.render)
+                  concat(after_input) if after_input
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ccs/components/govuk/field/input/password_input.rb

@@ -0,0 +1,101 @@
+require_relative 'text_input'
+require_relative 'password_input/show_hide_button'
+
+module CCS
+  module Components
+    module GovUK
+      class Field < Base
+        class Input < Field
+          # = GOV.UK Password input
+          #
+          # This is used for generating the password input component from the
+          # {https://design-system.service.gov.uk/components/password-input GDS - Components - Password Input}
+          #
+          # @!attribute [r] text_input
+          #   @return [CCS::Components::GovUK::Field::Input::TextInput] Initialised text input component
+
+          class PasswordInput
+            private
+
+            attr_reader :text_input
+
+            public
+
+            # @param (see CCS::Components::GovUK::Field::Input::TextInput#initialize)
+            #
+            # @option (see CCS::Components::GovUK::Field::Input::TextInput#initialize)
+
+            def initialize(attribute:, context:, **options)
+              set_password_input_from_group_options(options)
+
+              show_hide_button = ShowHideButton.new(attribute: attribute, context: context, after_input: options.delete(:after_input), **options)
+
+              options[:attributes] ||= {}
+              options[:attributes][:spellcheck] = false
+              options[:attributes][:autocapitalize] = 'none'
+              options[:attributes][:autocomplete] ||= 'current-password'
+
+              @text_input = TextInput.new(
+                context: context,
+                attribute: attribute,
+                after_input: show_hide_button.render,
+                input_wrapper: {
+                  classes: 'govuk-password-input__wrapper'
+                },
+                classes: "govuk-password-input__input govuk-js-password-input-input #{options.delete(:classes)}".rstrip,
+                field_type: :password,
+                **options
+              )
+            end
+
+            delegate :render, to: :text_input
+
+            private
+
+            # rubocop:disable Naming/AccessorMethodName
+
+            # Sets the password input form group options
+            #
+            # @param options [Hash] options for the password input
+            #
+            # @option options [String] :show_password_text button text when the password is hidden
+            # @option options [String] :hide_password_text button text when the password is visible
+            # @option options [String] :show_password_aria_label_text button text exposed to assistive technologies, like screen readers, when the password is hidden
+            # @option options [String] :hide_password_aria_label_text button text exposed to assistive technologies, like screen readers, when the password is visible
+            # @option options [String] :password_shown_announcement_text announcement made to screen reader users when their password has become visible in plain text
+            # @option options [String] :password_hidden_announcement_text announcement made to screen reader users when their password has been obscured and is not visible
+
+            def set_password_input_from_group_options(options)
+              (options[:form_group] ||= {})[:classes] = "govuk-password-input #{options.dig(:form_group, :classes)}".rstrip
+              ((options[:form_group][:attributes] ||= {})[:data] ||= {})[:module] = 'govuk-password-input'
+
+              get_password_input_translations(options) do |data_attribute, value|
+                options[:form_group][:attributes][:data][data_attribute] = value
+              end
+            end
+
+            # rubocop:enable Naming/AccessorMethodName
+
+            # Generator for the translation options for password input
+            #
+            # @param (see initialise_password_input_html_options)
+            #
+            # @option (see initialise_password_input_html_options)
+            #
+            # @yield Data attribute key and the value
+
+            def get_password_input_translations(password_input_options)
+              %i[show_password hide_password show_password_aria_label hide_password_aria_label password_shown_announcement password_hidden_announcement].each do |data_attribute|
+                data_attribute_name = :"#{data_attribute}_text"
+
+                next unless password_input_options[data_attribute_name]
+
+                yield :"i18n.#{data_attribute.to_s.gsub('_', '-')}", password_input_options[data_attribute_name]
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ccs/components/govuk/field/input/select.rb

@@ -38,8 +38,8 @@ module CCS
               @items = items.map do |item|
                 [
                   item[:text] || item[:value],
-                  item[:value],
-                  (item[:attributes] || {})
+                  item[:value].nil? ? item[:text] : item[:value],
+                  item[:attributes] || {}
                 ]
               end
               @selected = @options[:model] ? @options[:model].send(attribute) : selected

data/lib/ccs/components/govuk/field/input/text_input.rb

@@ -19,11 +19,13 @@ module CCS
           #   @return [Fix] The initialised prefix
           # @!attribute [r] suffix
           #   @return [Fix] The initialised suffix
+          # @!attribute [r] input_wrapper_html_options
+          #   @return [Fix] HTML options for the input wrapper
 
           class TextInput < Input
             private
 
-            attr_reader :field_type, :value, :prefix, :suffix
+            attr_reader :field_type, :value, :prefix, :suffix, :input_wrapper_html_options
 
             public
 
@@ -36,33 +38,41 @@ module CCS
             #                      see {CCS::Components::GovUK::Field::Input::TextInput::Fix#initialize Fix#initialize} for more details.
             # @param suffix [Hash] optional suffix for the input field,
             #                      see {CCS::Components::GovUK::Field::Input::TextInput::Fix#initialize Fix#initialize} for more details.
+            # @param input_wrapper [Hash] HTML options for the input wrapper
             #
             # @option (see CCS::Components::GovUK::Field::Input#initialize)
 
-            def initialize(attribute:, field_type: :text, value: nil, prefix: nil, suffix: nil, **options)
+            def initialize(attribute:, field_type: :text, value: nil, prefix: nil, suffix: nil, input_wrapper: {}, **options)
               super(attribute: attribute, **options)
 
               @field_type = :"#{field_type}_field"
               @value = @options[:model] ? @options[:model].send(attribute) : value
               @prefix = Fix.new(fix: 'pre', context: @context, **prefix) if prefix
               @suffix = Fix.new(fix: 'suf', context: @context, **suffix) if suffix
+              @input_wrapper_html_options = {
+                class: "govuk-input__wrapper #{input_wrapper[:classes]}".rstrip
+              }.merge(input_wrapper[:attributes] || {})
             end
 
             # rubocop:enable Metrics/ParameterLists
+            # rubocop:disable Metrics/AbcSize
 
             # Generates the HTML for the GOV.UK Text Input component
             #
             # @return [ActiveSupport::SafeBuffer]
 
             def render
-              super() do
-                text_input_wrapper do
+              form_group.render do |display_error_message|
+                concat(label.render)
+                concat(hint.render) if hint
+                concat(display_error_message)
+                concat(text_input_wrapper do
                   if options[:form]
                     options[:form].send(field_type, attribute, **options[:attributes])
                   else
                     context.send("#{field_type}_tag", attribute, value, **options[:attributes])
                   end
-                end
+                end)
               end
             end
 
@@ -72,6 +82,8 @@ module CCS
 
             private
 
+            # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
             # Wrapper method used by {render} to wrap the text input with a prefix or suffix if they exist
             #
             # @yield the text input HTML
@@ -79,16 +91,20 @@ module CCS
             # @return [ActiveSupport::SafeBuffer]
 
             def text_input_wrapper
-              if prefix || suffix
-                tag.div(class: 'govuk-input__wrapper') do
+              if prefix || suffix || before_input || after_input
+                tag.div(**input_wrapper_html_options) do
+                  concat(before_input) if before_input
                   concat(prefix.render) if prefix
                   concat(yield)
                   concat(suffix.render) if suffix
+                  concat(after_input) if after_input
                 end
               else
                 yield
               end
             end
+
+            # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
           end
         end
       end

data/lib/ccs/components/govuk/field/input.rb

@@ -25,6 +25,8 @@ module CCS
 
           # @param (see CCS::Components::GovUK::Field#initialize)
           # @param label [Hash] attributes for the label, see {CCS::Components::GovUK::Label#initialize Label#initialize} for more details.
+          # @param before_input [String] text or HTML to go before the input
+          # @param after_input [String] text or HTML to go after the input
           #
           # @option (see CCS::Components::GovUK::Field#initialize)
 
@@ -52,7 +54,9 @@ module CCS
               concat(label.render)
               concat(hint.render) if hint
               concat(display_error_message)
+              concat(before_input) if before_input
               concat(yield)
+              concat(after_input) if after_input
             end
           end
         end

data/lib/ccs/components/govuk/field/inputs/checkboxes.rb

@@ -12,18 +12,9 @@ module CCS
           #
           # This is used for generating the checkboxes component from the
           # {https://design-system.service.gov.uk/components/checkboxes GDS - Components - Checkboxes}
-          #
-          # @!attribute [r] checkbox_items
-          #   @return [Array<Item::Divider|Item::Checkbox|Item::Checkbox>] An array of the initialised checkbox items
 
           class Checkboxes < Inputs
-            private
-
-            attr_reader :checkbox_items
-
-            public
-
-            # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+            # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize
 
             # @param (see CCS::Components::GovUK::Field::Inputs#initialize)
             # @param checkbox_items [Array<Hash>] an array of options for the checkboxes.
@@ -34,29 +25,18 @@ module CCS
             def initialize(attribute:, checkbox_items:, **options)
               super(attribute: attribute, **options)
 
-              if @options[:model] || @options[:form]
-                values = (@options[:model] || @options[:form].object).send(attribute) || []
-                checkbox_items.each { |checkbox_item| checkbox_item[:checked] = values.include?(checkbox_item[:value]) }
-              end
+              @options[:values] ||= []
+              @options[:values] = (@options[:model] || @options[:form].object).send(attribute) || [] if @options[:model] || @options[:form]
+
+              checkbox_items.each { |checkbox_item| checkbox_item[:checked] = @options[:values].include?(checkbox_item[:value]) } if @options[:values].any?
+              checkbox_items.each { |checkbox_item| set_described_by(checkbox_item, @attribute, @error_message, @hint&.send(:options)) } unless @fieldset
 
               checkbox_item_class = @options[:form] ? Item::Checkbox::Form : Inputs::Item::Checkbox::Tag
 
-              @checkbox_items = checkbox_items.map { |checkbox_item| checkbox_item[:divider] ? Item::Divider.new(divider: checkbox_item[:divider], type: 'checkboxes') : checkbox_item_class.new(attribute: attribute, form: @options[:form], context: @context, **checkbox_item) }
+              @input_items = checkbox_items.map { |checkbox_item| checkbox_item[:divider] ? Item::Divider.new(divider: checkbox_item[:divider], type: 'checkboxes') : checkbox_item_class.new(attribute: attribute, form: @options[:form], context: @context, **checkbox_item) }
             end
 
-            # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-
-            # Generates the HTML for the GOV.UK Checkboxes component
-            #
-            # @return [ActiveSupport::SafeBuffer]
-
-            def render
-              super() do
-                tag.div(**options[:attributes]) do
-                  checkbox_items.each { |checkbox_item| concat(checkbox_item.render) }
-                end
-              end
-            end
+            # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity, Metrics/AbcSize
 
             # The default attributes for the checkboxes