formatic 0.1.0

data/app/components/formatic/wrapper.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'formatic/templates/wrapper'
+
+module Formatic
+  # Combines label, input, error and hint.
+  # See also https://github.com/rails/rails/blob/main/actionview/lib/action_view/helpers/tags/base.rb
+  class Wrapper < ApplicationComponent
+    # Passing on the form builder.
+    option :f
+
+    # This is not an actual <input>, but it's the wrapper's container div for the <input>.
+    renders_one :input
+
+    # The attribute of the record to be edited. E.g. `:name`.
+    option :attribute_name, type: proc(&:to_sym)
+
+    # Manually decide whether the form field is optional or not.
+    option :required, as: :manual_required, optional: true
+
+    # Manually decide to hide the label.
+    option :label, as: :manual_label, default: -> { true }
+
+    # Manually decide to hide the hint.
+    option :hint, as: :manual_hint, default: -> { true }
+
+    # Autocompletion + Enter should not submit the form.
+    option :prevent_submit_on_enter, default: -> { false }
+
+    # Multiple inputs can belong to one label (e.g. select day, month, year).
+    # With this you can specify the ID of one first input to couple the label to it.
+    option :label_for_id, optional: true
+
+    # CSS
+    option :class, as: :css_class, optional: true
+
+    erb_template(::Formatic::Templates::Wrapper.call)
+
+    # -----------------
+    # Querying of slots
+    # -----------------
+
+    # Whether to display a label or not.
+    def label?
+      manual_label != false
+    end
+
+    # Whether to display a hint or not.
+    def hint?
+      manual_hint != false
+    end
+
+    def error?
+      error_messages.present?
+    end
+
+    def required?
+      @required ||= ::Formatic::Wrappers::Required.call(manual_required:, object:, attribute_name:)
+    end
+
+    def optional?
+      !required?
+    end
+
+    def hint_before_input?
+      manual_hint == :before_input
+    end
+
+    def error_messages
+      @error_messages ||= ::Formatic::Wrappers::ErrorMessages.call(
+        object:,
+        attribute_name:
+      )
+    end
+
+    # -----------
+    # Static I18n
+    # -----------
+
+    def placeholder
+      @placeholder ||= ::Formatic::Wrappers::Translate.call(
+        prefix: :'helpers.placeholder',
+        object:,
+        attribute_name:,
+        object_name: f&.object_name
+      )
+    end
+
+    def hint
+      @hint ||= ::Formatic::Wrappers::Translate.call(
+        prefix: :'helpers.hint',
+        object:,
+        attribute_name:,
+        object_name: f&.object_name
+      )
+    end
+
+    def toggle_on
+      @toggle_on ||= ::Formatic::Wrappers::Translate.call(
+        prefix: :'helpers.hint',
+        object:,
+        attribute_name: :"#{attribute_name}_active",
+        object_name: f&.object_name
+      )
+    end
+
+    def toggle_off
+      @toggle_off ||= ::Formatic::Wrappers::Translate.call(
+        prefix: :'helpers.hint',
+        object:,
+        attribute_name: :"#{attribute_name}_inactive",
+        object_name: f&.object_name
+      )
+    end
+
+    private
+
+    def object
+      f&.object
+    end
+  end
+end

data/config/locales/formatic.de.yml

@@ -0,0 +1,5 @@
+de:
+  formatic:
+
+    date:
+      blank: Leer

data/config/locales/formatic.en.yml

@@ -0,0 +1,5 @@
+en:
+  formatic:
+
+    date:
+      blank: Blank

data/lib/formatic/choices/countries.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Formatic
+  class Choices
+    # Returns a list of countries suitable for a <select> box.
+    class Countries
+      include Calls
+
+      def call
+        ::ISO3166::Country.pluck(:iso_short_name, :alpha2)
+      end
+    end
+  end
+end

data/lib/formatic/choices/keys.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Formatic
+  class Choices
+    # Looks up options for a <select> in i18n.
+    class Keys
+      include Calls
+
+      option :f
+      option :attribute_name
+      option :keys
+
+      def call
+        keys.map do |slug|
+          caption = ::Formatic::Wrappers::Translate.call(
+            prefix: :'helpers.options',
+            object: f.object,
+            attribute_name: "#{attribute_name}.#{slug}",
+            object_name: f&.object_name
+          )
+
+          [caption, slug.to_s]
+        end
+      end
+    end
+  end
+end

data/lib/formatic/choices/options.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Formatic
+  class Choices
+    # Returns raw options suitable for a <select> box.
+    class Options
+      include Calls
+
+      option :f
+      option :options
+      option :attribute_name
+      option :include_current
+
+      def call
+        candidates = options
+        return candidates unless currently_associated_record && include_current
+        return candidates if records&.include?(currently_associated_record)
+
+        candidates.prepend currently_associated_record.presenters.for_select
+        candidates
+      end
+
+      def currently_associated_record
+        return unless association
+        return unless f.object
+
+        f.object.public_send(association.name)
+      end
+
+      def association
+        model_klass = f&.object&.class
+        return false unless model_klass.respond_to?(:reflect_on_all_associations)
+
+        model_klass.reflect_on_all_associations(:belongs_to)
+                   .detect { _1.foreign_key == attribute_name.to_s }
+      end
+    end
+  end
+end

data/lib/formatic/choices/records.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Formatic
+  class Choices
+    # Returns a list of countries suitable for a <select> box.
+    class Records
+      include Calls
+
+      option :f
+      option :records
+      option :attribute_name
+      option :include_current
+
+      def call
+        candidates = records_to_options || []
+        return candidates unless currently_associated_record && include_current?
+        return candidates if records&.include?(currently_associated_record)
+
+        candidates.prepend currently_associated_record.presenters.for_select
+        candidates
+      end
+
+      def include_current?
+        include_current != false
+      end
+
+      def records_to_options
+        records&.map(&:presenters)&.map(&:for_select)
+      end
+
+      def currently_associated_record
+        return unless association
+        return unless f.object
+
+        f.object.public_send(association.name)
+      end
+
+      def association
+        model_klass = f&.object&.class
+        return false unless model_klass.respond_to?(:reflect_on_all_associations)
+
+        model_klass.reflect_on_all_associations(:belongs_to)
+                   .detect { _1.foreign_key == attribute_name.to_s }
+      end
+    end
+  end
+end

data/lib/formatic/choices.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Formatic
+  # Calculates options for e.g. select boxes.
+  class Choices
+    include Calls
+
+    option :f
+    option :attribute_name
+    option :include_blank, optional: true
+
+    # The currently selected choice should be in the list of choosable choices.
+    # Otherwise a simple form submit would modify this value.
+    option :include_current, optional: true
+
+    option :options, optional: true
+    option :records, optional: true
+    option :keys, optional: true
+
+    def call
+      result = choices
+      result.prepend [nil, nil] if include_blank
+      result
+    end
+
+    private
+
+    def choices
+      return options_choices if options.present?
+      return country_choices if country_code?
+      return keys_choices if keys.present?
+
+      record_choices
+    end
+
+    def options_choices
+      return options unless include_current
+
+      # Could be implemented though.
+      raise '`Formatic::Choices.call(options: ...)` cannot also have `include_current: true`'
+    end
+
+    def country_code?
+      attribute_name.to_s.end_with?('country_code')
+    end
+
+    # Assuming that countries don't disappear, `include_current` is implied.
+    def country_choices
+      ::Formatic::Choices::Countries.call
+    end
+
+    def keys_choices
+      return ::Formatic::Choices::Keys.call(f:, attribute_name:, keys:) unless include_current
+
+      raise '`Formatic::Choices.call(keys: ...)` cannot also have `include_current: true`'
+    end
+
+    def record_choices
+      ::Formatic::Choices::Records.call(f:, records:, attribute_name:, include_current:)
+    end
+  end
+end

data/lib/formatic/css.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Formatic
+  # Simple helper to unify Strings and Arrays of CSS class names.
+  class Css
+    def self.call(*input)
+      Array(input).flatten.compact.join(' ')
+    end
+  end
+end

data/lib/formatic/engine.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'rails/engine'
+require 'dry-initializer'
+
+module Formatic
+  # :nodoc:
+  class Engine < ::Rails::Engine
+    isolate_namespace Formatic
+
+    config.to_prepare do
+      require_formatic_components
+    end
+
+    def self.require_formatic_components
+      # Our Formatic components are subclasses of `ViewComponent::Base`.
+      # When `ViewComponent::Base` is subclassed, two things happen:
+      #
+      #   1. Rails routes are included into the component
+      #   2. The ViewComponent configuration is accessed
+      #
+      # So we can only require our components, once Rails has booted
+      # AND the view_component gem has been fully initialized (configured).
+      #
+      # That's right here and now.
+      require_relative '../../app/components/formatic/application_component'
+      require_relative '../../app/components/formatic/wrapper'
+      require_relative '../../app/components/formatic/base'
+
+      # Components
+      require_relative '../../app/components/formatic/toggle'
+      require_relative '../../app/components/formatic/checklist'
+      require_relative '../../app/components/formatic/date'
+      require_relative '../../app/components/formatic/select'
+      require_relative '../../app/components/formatic/string'
+      require_relative '../../app/components/formatic/stepper'
+      require_relative '../../app/components/formatic/textarea'
+    end
+  end
+end

data/lib/formatic/safe_join.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Formatic
+  # Joins multiple html safe strings, retaining html safety.
+  class SafeJoin
+    include ::ActionView::Helpers::OutputSafetyHelper
+
+    def self.call(...)
+      new(...).call
+    end
+
+    def initialize(*input)
+      @input = input
+    end
+
+    def call
+      safe_join(@input)
+    end
+  end
+end

data/lib/formatic/templates/date.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Formatic
+  module Templates
+    # Holds the ERB template for this component.
+    module Date
+      TEMPLATE = <<~ERB
+        <%= render wrapper do |wrap| %>
+
+          <% wrap.with_input do %>
+            <div class="c-formatic-date s-formatic js-formatic-date">
+
+            <% if readonly %>
+              <div class="s-markdown">
+                <p>
+                  <%= value.to_date %>
+                </p>
+              </div>
+            <% else %>
+
+              <div class="c-formatic-date__inputs">
+                <% if discard_day %>
+                  = hidden_field_tag day_attribute_name, (day_value || 1)
+                <% else %>
+                  <%= select_tag day_attribute_name,
+                                 options_for_day,
+                                 id: day_input_id,
+                                 class: 'c-formatic-date__select js-formatic-date__day' %>
+
+                  <%= select_tag month_attribute_name,
+                                 options_for_month,
+                                 id: month_input_id,
+                                 class: 'c-formatic-date__select js-formatic-date__month' %>
+
+                  <%= select_tag year_attribute_name,
+                                 options_for_year,
+                                 id: year_input_id,
+                                 class: 'c-formatic-date__select js-formatic-date__year' %>
+                <% end %>
+              </div>
+              <div class="c-formatic-date__calendar">
+                <a class="c-formatic-date__flick c-formatic-date__clear js-formatic-date__shortcut" href="#"
+                   data-day=""
+                   data-month=""
+                   data-year=""
+                >
+                  X
+                </a>
+                <% calendar.each do |day| %>
+                  <a class="c-formatic-date__flick <%= day.classes %> js-formatic-date__shortcut"
+                    href='#'
+                    data-day="<%= day.date.day %>"
+                    data-month="<%= day.date.month %>"
+                    data-year="<%= day.date.year %>"
+                  >
+                  <span class="c-formatic-date__calendar-day-number"><%= I18n.l(day.date, format: "%e").strip %></span>
+                    <span class="c-formatic-date__calendar-month"><%= I18n.l(day.date, format: "%b") %></span>
+                    <span class="c-formatic-date__calendar-year"><%= I18n.l(day.date, format: "%y") %></span>
+                  </a>
+                <% end %>
+              </div>
+            <% end %>
+
+            </div>
+          <% end %>
+        <% end %>
+      ERB
+
+      private_constant :TEMPLATE
+
+      def self.call
+        TEMPLATE
+      end
+    end
+  end
+end

data/lib/formatic/templates/select.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Formatic
+  module Templates
+    # Holds the ERB template for this component.
+    module Select
+      TEMPLATE = <<~ERB
+        <%= render wrapper do |wrap| %>
+          <% wrap.with_input do %>
+            <div class="c-formatic-select s-formatic">
+
+              <% if readonly %>
+                <div class="s-markdown">
+                  <p>
+                    <%= current_choice_name %>
+                  </p>
+                </div>
+              <% else %>
+
+                <%= f.select attribute_name, choices, {}, { class: ['c-formatic-select', 'js-formatic-select', ('is-autosubmit' if async_submit)] } %>
+
+              <% end %>
+            </div>
+          <% end %>
+        <% end %>
+      ERB
+
+      private_constant :TEMPLATE
+
+      def self.call
+        TEMPLATE
+      end
+    end
+  end
+end

data/lib/formatic/templates/wrapper.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Formatic
+  module Templates
+    # Holds the ERB template for this component.
+    module Wrapper
+      TEMPLATE = <<~ERB
+        <div class="u-formatic-container <%= css_class %>">
+          <div class="c-formatic-wrapper <%= [('is-required' if required?), ('c-formatic-wrapper--hint-before-input' if hint_before_input?)].join(' ') %>">
+
+          <% if label? %>
+            <div class="c-formatic-wrapper__label">
+              <% if label_for_id.present? %>
+                <%= f.label attribute_name, nil, for: label_for_id %>
+              <% else %>
+                <%= f.label attribute_name %>
+              <% end %>
+            </div>
+          <% end %>
+
+          <div class="c-formatic-wrapper__input">
+            <%= input %>
+          </div>
+
+          <% if error? %>
+            <div class="c-formatic-wrapper__error">
+              <i></i>
+              <%= error_messages.to_sentence %><% unless error_messages.to_sentence.end_with?('.') %>.<% end %>
+            </div>
+          <% end %>
+
+          <% if hint? %>
+            <div class="c-formatic-wrapper__hint">
+              <%= hint %>
+            </div>
+          <% end %>
+
+          <% if prevent_submit_on_enter %>
+            <%= f.submit 'Dummy to prevent submit on Enter', disabled: true, class: 'c-formatic-wrapper__prevent-submit-on-enter' %>
+          <% end %>
+          </div>
+        </div>
+      ERB
+
+      private_constant :TEMPLATE
+
+      def self.call
+        TEMPLATE
+      end
+    end
+  end
+end

data/lib/formatic/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Formatic
+  VERSION = '0.1.0'
+end

data/lib/formatic/wrappers/alternative_attribute_name.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Formatic
+  module Wrappers
+    # Checks if an attribute name is from an associated model.
+    class AlternativeAttributeName
+      include Calls
+
+      param :attribute_name
+
+      def call
+        return unless attribute_name.to_s.end_with?('_id')
+
+        attribute_name[...-3].to_sym
+      end
+    end
+  end
+end

data/lib/formatic/wrappers/error_messages.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Formatic
+  module Wrappers
+    # Extracts the message of an erroneous attribute
+    class ErrorMessages
+      include Calls
+
+      option :object
+      option :attribute_name
+
+      def call
+        return unless object
+
+        (errors_on_attribute + error_on_association).uniq
+      end
+
+      private
+
+      attr_reader :object
+
+      def errors_on_attribute
+        return [] unless object.respond_to?(attribute_name)
+
+        object.errors.full_messages_for(attribute_name)
+      end
+
+      def error_on_association
+        association_attribute_name = ::Formatic::Wrappers::AlternativeAttributeName.call(
+          attribute_name
+        )
+        return [] unless association_attribute_name
+        return [] unless object.respond_to?(association_attribute_name)
+
+        object.errors.full_messages_for(association_attribute_name)
+      end
+    end
+  end
+end

data/lib/formatic/wrappers/required.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Formatic
+  module Wrappers
+    # Determines whether an attributes is optional or not.
+    class Required
+      include Calls
+
+      option :manual_required
+      option :object
+      option :attribute_name
+
+      # Could also be made smarter, e.g. global configuration.
+      # See https://github.com/heartcombo/simple_form/blob/main/lib/simple_form/helpers/required.rb
+      def call
+        return true if manual_required == true
+        return false if manual_required == false
+        return false if validators.empty?
+
+        validators.any? { _1.kind == :presence }
+      end
+
+      # All applicable validatiors of this attribute.
+      def validators
+        @validators ||= ::Formatic::Wrappers::Validators.call(object:, attribute_name:)
+      end
+    end
+  end
+end