ariadne_view_components 0.0.1

data/app/lib/ariadne/icon_helper.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+# Ariadne::FetchOrFallbackHelper
+# A little helper to enable graceful fallbacks
+#
+# Use this helper to quietly ensure a value is
+# one that you expect:
+#
+# allowed_values    - allowed options for *value*
+# given_value       - input being coerced
+# fallback          - returned if *given_value* is not included in *allowed_values*
+#
+# fetch_or_raise([1,2,3], 5) => 2
+# fetch_or_raise([1,2,3], 1) => 1
+# fetch_or_raise([1,2,3], nil) => 2
+module Ariadne
+  # :nodoc:
+  module IconHelper
+    include FetchOrFallbackHelper
+
+    def check_icon_presence!(icon, variant)
+      return true unless has_partial_icon?(icon, variant)
+
+      icon_presence!(icon, variant)
+      variant_presence!(icon, variant)
+      fetch_or_raise(HeroiconsHelper::Icon::VARIANTS, variant)
+
+      true
+    end
+
+    def has_partial_icon?(icon, variant)
+      icon.present? || variant.present?
+    end
+
+    def icon_presence!(icon, variant)
+      raise(ArgumentError, "You must provide an `icon` when providing a `variant`.") if icon.blank? && variant.present?
+
+      true
+    end
+
+    def variant_presence!(icon, variant)
+      raise(ArgumentError, "You must provide a `variant` when providing an `icon`.") if icon.present? && variant.blank?
+
+      true
+    end
+  end
+end

data/app/lib/ariadne/join_style_arguments_helper.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Ariadne
+  # :nodoc:
+  module JoinStyleArgumentsHelper
+    # Join two `style` arguments
+    #
+    # join_style_arguments("width: 100%", "height: 100%") =>
+    #   "width: 100%;height: 100%"
+    def join_style_arguments(*args)
+      args.compact.join(";")
+    end
+  end
+end

data/app/lib/ariadne/logger_helper.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Ariadne
+  # :nodoc:
+  module LoggerHelper
+    def logger
+      return Rails.logger if defined?(Rails) && Rails.logger
+
+      require "logger"
+      Logger.new($stderr)
+    end
+
+    # TODO: test
+    def silence_deprecations?
+      Rails.application.config.ariadne_view_components.silence_deprecations
+    end
+
+    # TODO: test
+    def silence_warnings?
+      Rails.application.config.ariadne_view_components.silence_warnings
+    end
+  end
+end

data/app/lib/ariadne/status/dsl.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Ariadne
+  # :nodoc:
+  module Status
+    # DSL to allow components to register their status.
+    #
+    # Example:
+    #
+    # class MyComponent < ViewComponent::Base
+    #   include Ariadne::Status::Dsl
+    #   status :experimental
+    # end
+    module Dsl
+      extend ActiveSupport::Concern
+
+      STATUSES = {
+        experimental: :experimental,
+        stable: :stable,
+      }.freeze
+
+      class UnknownStatusError < StandardError; end
+
+      included do
+        class_attribute :component_status, instance_writer: false, default: STATUSES[:stable]
+      end
+
+      class_methods do
+        def status(status = nil)
+          return component_status if status.nil?
+
+          raise UnknownStatusError, "status #{status} does not exist" if STATUSES[status].nil?
+
+          self.component_status = STATUSES[status]
+        end
+      end
+    end
+  end
+end

data/app/lib/ariadne/tab_nav_helper.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Ariadne
+  # Helper to share tab validation logic between components.
+  # The component will raise an error if there are 0 or 2+ selected tabs.
+  module TabNavHelper
+    extend ActiveSupport::Concern
+
+    EXTRA_ALIGN_DEFAULT = :left
+    EXTRA_ALIGN_OPTIONS = [EXTRA_ALIGN_DEFAULT, :right].freeze
+
+    def tab_nav_tab_classes(classes)
+      class_names(
+        "tabnav-tab",
+        classes
+      )
+    end
+
+    def tab_nav_classes(classes)
+      class_names(
+        "tabnav",
+        classes
+      )
+    end
+
+    def tab_nav_body_classes(classes)
+      class_names(
+        "tabnav-tabs",
+        classes
+      )
+    end
+  end
+end

data/app/lib/ariadne/tabbed_component_helper.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Ariadne
+  # Helper to share tab validation logic between components.
+  # The component will raise an error if there are 0 or 2+ selected tabs.
+  module TabbedComponentHelper
+    extend ActiveSupport::Concern
+
+    class MultipleSelectedTabsError < StandardError; end
+
+    def before_render
+      validate_single_selected_tab unless Rails.env.production?
+    end
+
+    private
+
+    def aria_label_for_page_nav(label)
+      @attributes[:tag] == :nav ? @attributes[:"aria-label"] = label : @body_arguments[:"aria-label"] = label
+    end
+
+    def tab_container_wrapper(with_panel:, **attributes)
+      return yield unless with_panel
+
+      render(Ariadne::TabContainerComponent.new(**attributes)) do
+        yield if block_given?
+      end
+    end
+
+    def validate_single_selected_tab
+      raise MultipleSelectedTabsError, "only one tab can be selected" if selected_tabs_count > 1
+    end
+
+    def selected_tabs_count
+      @selected_tabs_count ||= tabs.count(&:selected)
+    end
+  end
+end

data/app/lib/ariadne/test_selector_helper.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Ariadne
+  # Module to allow components to deal with the `test_selector` argument.
+  # It will only add the selector if env is not Production.
+  #
+  # test_selector: "foo" => data-test-selector="foo"
+  module TestSelectorHelper
+    TEST_SELECTOR_TAG = :test_selector
+
+    def add_test_selector(args)
+      if args.key?(TEST_SELECTOR_TAG)
+        args[:data] ||= {}
+        args[:data][TEST_SELECTOR_TAG] = args[TEST_SELECTOR_TAG]
+      end
+
+      args.except(TEST_SELECTOR_TAG)
+    end
+  end
+end

data/app/lib/ariadne/underline_nav_helper.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module Ariadne
+  # Helper to share tab validation logic between components.
+  # The component will raise an error if there are 0 or 2+ selected tabs.
+  module UnderlineNavHelper
+    extend ActiveSupport::Concern
+
+    ALIGN_DEFAULT = :left
+    ALIGN_OPTIONS = [ALIGN_DEFAULT, :right].freeze
+
+    ACTIONS_TAG_DEFAULT = :div
+    ACTIONS_TAG_OPTIONS = [ACTIONS_TAG_DEFAULT, :span].freeze
+
+    def underline_nav_classes(classes, align)
+      class_names(
+        classes,
+        "UnderlineNav",
+        "UnderlineNav--right" => align == :right
+      )
+    end
+
+    def underline_nav_body_classes(classes)
+      class_names(
+        "UnderlineNav-body",
+        classes,
+        "list-style-none"
+      )
+    end
+
+    def underline_nav_action_classes(classes)
+      class_names("UnderlineNav-actions", classes)
+    end
+
+    def underline_nav_tab_classes(classes)
+      class_names(
+        "UnderlineNav-item",
+        classes
+      )
+    end
+  end
+end

data/app/lib/ariadne/view_helper.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# :nocov:
+module Ariadne
+  # Module to allow shorthand calls for Ariadne components
+  module ViewHelper
+    class ViewHelperNotFound < StandardError; end
+
+    HELPERS = {
+      heroicon: "Ariadne::HeroiconComponent",
+      heading: "Ariadne::HeadingComponent",
+      time_ago: "Ariadne::TimeAgoComponent",
+      image: "Ariadne::ImageComponent",
+    }.freeze
+
+    HELPERS.each do |name, component|
+      define_method "ariadne_#{name}" do |*args, **kwargs, &block|
+        render component.constantize.new(*args, **kwargs), &block
+      end
+    end
+  end
+end

data/lib/ariadne/classify/utilities.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+# :nodoc:
+module Ariadne
+  class Classify
+    # Handler for AriadneCSS utility classes loaded from utilities.rake
+    class Utilities
+      # Load the utilities.yml file.
+      # Disabling because we want to load symbols, strings, and integers from the .yml file
+      UTILITIES = YAML.load(
+        File.read(
+          File.join(File.dirname(__FILE__), "./utilities.yml")
+        )
+      ).freeze
+      BREAKPOINTS = ["", "-sm", "-md", "-lg", "-xl"].freeze
+
+      # Replacements for some classnames that end up being a different argument key
+      REPLACEMENT_KEYS = {
+        "^anim" => "animation",
+        "^v-align" => "vertical_align",
+        "^d" => "display",
+        "^wb" => "word_break",
+        "^v" => "visibility",
+        "^width" => "w",
+        "^height" => "h",
+        "^color-bg" => "bg",
+        "^color-border" => "border_color",
+        "^color-fg" => "color",
+      }.freeze
+
+      SUPPORTED_KEY_CACHE = Hash.new { |h, k| h[k] = !UTILITIES[k].nil? }
+      BREAKPOINT_INDEX_CACHE = Hash.new { |h, k| h[k] = BREAKPOINTS.index(k) }
+
+      class << self
+        attr_accessor :validate_class_names
+        alias_method :validate_class_names?, :validate_class_names
+
+        def classname(key, val, breakpoint = "")
+          # For cases when `argument: false` is passed in, treat like we would nil
+          return nil unless val
+
+          if (valid = validate(key, val, breakpoint))
+            valid
+          else
+            # Get selector
+            UTILITIES[key][val][BREAKPOINT_INDEX_CACHE[breakpoint]]
+          end
+        end
+
+        # Does the Utility class support the given key
+        #
+        # returns Boolean
+        def supported_key?(key)
+          SUPPORTED_KEY_CACHE[key]
+        end
+
+        # Does the Utility class support the given key and value
+        #
+        # returns Boolean
+        def supported_value?(key, val)
+          supported_key?(key) && !UTILITIES[key][val].nil?
+        end
+
+        # Does the given selector exist in the utilities file
+        #
+        # returns Boolean
+        def supported_selector?(selector)
+          # This method is too slow to run in production
+          return false unless validate_class_names?
+
+          find_selector(selector).present?
+        end
+
+        # Is the key and value responsive
+        #
+        # returns Boolean
+        def responsive?(key, val)
+          supported_value?(key, val) && UTILITIES[key][val].count > 1
+        end
+
+        # Get the options for the given key
+        #
+        # returns Array or nil if key not supported
+        def mappings(key)
+          return unless supported_key?(key)
+
+          UTILITIES[key].keys
+        end
+
+        # Extract hash from classes ie. "mr-1 mb-2 foo" => { mr: 1, mb: 2, classes: "foo" }
+        def classes_to_hash(classes)
+          # This method is too slow to run in production
+          return { classes: classes } unless validate_class_names?
+
+          obj = {}
+          classes = classes.split
+          # Loop through all classes supplied and reject ones we find a match for
+          # So when we're at the end of the loop we have classes left with any non-system classes.
+          classes.reject! do |classname|
+            key, value, index = find_selector(classname)
+            next false if key.nil?
+
+            # Create array if nil
+            obj[key] = Array.new(5, nil) if obj[key].nil?
+            # Place the arguments in the responsive array based on index mr: [nil, 2]
+            obj[key][index] = value
+            next true
+          end
+
+          # Transform responsive arrays into arrays without trailing nil, so `mr: [1, nil, nil, nil, nil]` becomes `mr: 1`
+          obj.transform_values! do |value|
+            value = value.reverse.drop_while(&:nil?).reverse
+            if value.count == 1
+              value.first
+            else
+              value
+            end
+          end
+
+          # Add back the non-system classes
+          obj[:classes] = classes.join(" ") if classes.any?
+          obj
+        end
+
+        def classes_to_args(classes)
+          hash_to_args(classes_to_hash(classes))
+        end
+
+        def hash_to_args(hash)
+          hash.map do |key, value|
+            val = case value
+            when Symbol
+              ":#{value}"
+            when String
+              value.to_json
+            else
+              value
+            end
+
+            "#{key}: #{val}"
+          end.join(", ")
+        end
+
+        def validate(key, val, breakpoint)
+          unless supported_key?(key)
+            raise ArgumentError, "#{key} is not a valid Ariadne utility key" if validate_class_names?
+
+            return ""
+          end
+
+          unless breakpoint.empty? || responsive?(key, val)
+            raise ArgumentError, "#{key} does not support responsive values" if validate_class_names?
+
+            return ""
+          end
+
+          unless supported_value?(key, val)
+            raise ArgumentError, "#{val} is not a valid value for :#{key}. Use one of #{mappings(key)}" if validate_class_names?
+
+            return nil if [true, false].include?(val)
+
+            return "#{key.to_s.dasherize}-#{val.to_s.dasherize}"
+          end
+
+          nil
+        end
+
+        private def find_selector(selector)
+          key = infer_selector_key(selector)
+          value_hash = UTILITIES[key]
+
+          return nil if value_hash.blank?
+
+          # Each value hash will also contain an array of classnames for breakpoints
+          # Key argument `0`, classes `[ "mr-0", "mr-sm-0", "mr-md-0", "mr-lg-0", "mr-xl-0" ]`
+          value_hash.each do |key_argument, classnames|
+            # Skip each value hash until we get one with the selector
+            next unless classnames.include?(selector)
+
+            # Return [:mr, 0, 1]
+            # has index of classname, so we can match it up with responsive array `mr: [nil, 0]`
+            return [key, key_argument, classnames.index(selector)]
+          end
+
+          nil
+        end
+
+        private def infer_selector_key(selector)
+          REPLACEMENT_KEYS.each do |k, v|
+            return v.to_sym if selector.match?(Regexp.new(k))
+          end
+          selector.split("-").first.to_sym
+        end
+      end
+    end
+  end
+end