fox_tail 0.1.0

data/lib/fox_tail/engine.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "fox_tail/config"
+
+module FoxTail
+  class Engine < Rails::Engine
+    isolate_namespace FoxTail
+
+    config.fox_tail = Config.current
+    config.eager_load_paths = %W[#{root}/app/components #{root}/app/helpers]
+  end
+end

data/lib/fox_tail/errors.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module FoxTail
+  class Error < StandardError; end
+
+  class AssetNotFound < Error
+    attr_reader :asset
+
+    def initialize(asset, msg = "Could not find the asset \"#{asset}\"")
+      super(msg)
+      @asset = asset
+    end
+  end
+
+  class ControllerNotImplemented < Error; end
+
+  class ComponentError < Error
+    attr_reader :component
+
+    def initialize(component, msg = nil)
+      @component = component
+      super(msg)
+    end
+  end
+
+  class ReservedOption < ComponentError
+    attr_reader :option
+
+    def initialize(component, option, msg = nil)
+      @option = option
+      msg ||= "#{component} declares an option \"#{option}\", which is a reserved word in the" \
+        " FoxTail framework."
+
+      super(component, msg)
+    end
+  end
+end

data/lib/fox_tail/stimulus_controller.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module FoxTail
+  class StimulusController
+    delegate :stimulus_merger, to: :config
+
+    attr_reader :identifier
+
+    def initialize(identifier, config: nil)
+      @identifier = format_identifier identifier
+      @config = config
+    end
+
+    def config
+      @config ||= FoxTail::Config.current
+    end
+
+    def attributes(_options = {})
+      {
+        data: { controller: identifier }
+      }
+    end
+
+    def target_key(raw: false)
+      key :target, raw: raw
+    end
+
+    def outlet_key(name, raw: false)
+      key name, :outlet, raw: raw
+    end
+
+    def value_key(name, raw: false)
+      key name, :value, raw: raw
+    end
+
+    def classes_key(name, raw: false)
+      key name, :class, raw: raw
+    end
+
+    def merge(attributes, options = {})
+      merge! attributes.deep_dup, options
+    end
+
+    def merge!(attributes, options = {})
+      stimulus_merger.merge_attributes! attributes, self.attributes(options)
+    end
+
+    def action(method_name, event: nil)
+      action = "#{identifier}##{method_name}"
+      event && event.to_sym != :click ? "#{event}->#{action}" : action
+    end
+
+    def action_param_key(name, raw: false)
+      key name, :param, raw: raw
+    end
+
+    def event(event_name)
+      "#{identifier}:#{event_name}"
+    end
+
+    def build_actions(actions)
+      return nil if actions.blank?
+
+      formatted_actions = actions.each_with_object([]) do |(method_name, events), results|
+        Array(events).each { |event| results.push( action(method_name, event: event)) }
+      end
+
+      stimulus_merger.merge_actions(*formatted_actions)
+    end
+
+    def to_sym
+      identifier.gsub("-", "_").to_sym
+    end
+
+    def to_s
+      identifier
+    end
+
+    protected
+
+    def format_identifier(name)
+      name.to_s.gsub "_", "-"
+    end
+
+    def key(*parts)
+      options = parts.extract_options!
+      key = parts.map { |p| format_identifier p }
+      key.unshift identifier
+
+      if options[:raw]
+        key.unshift :data
+        key.join("-").gsub("_", "-").to_sym
+      else
+        key.join("_").gsub("-", "_").to_sym
+      end
+    end
+  end
+end

data/lib/fox_tail/stimulus_merger.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module FoxTail
+  class StimulusMerger
+    def merge_attributes!(attributes, *other_attributes)
+      attributes[:data] ||= {}
+      other_attributes.each { |attr| merge_stimulus_attributes attributes, attr }
+      attributes
+    end
+
+    def merge_attributes(attributes, *other_attributes)
+      merge_attributes!(attributes.deep_dup, *other_attributes)
+    end
+
+    def merge_controllers(*controllers)
+      controllers.map(&:to_s).reject(&:blank?).uniq.join(" ").presence
+    end
+
+    def merge_actions(*actions)
+      actions.reject(&:blank?).join(" ").presence
+    end
+
+    private
+
+    def merge_stimulus_attributes(source, attributes)
+      attributes[:data] ||= {}
+      controllers = merge_controllers source[:data].delete(:controller), attributes[:data].delete(:controller)
+      actions = merge_actions source[:data].delete(:action), attributes[:data].delete(:action)
+      source[:data][:controller] = controllers
+      source[:data][:action] = actions
+      source.deep_merge! attributes
+    end
+  end
+end

data/lib/fox_tail/theme.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module FoxTail
+  # FoxTail Component Theme
+  class Theme
+    BASE_KEY = "base"
+
+    def initialize(theme = {}, class_merger: ClassnameMerger.new)
+      @class_merger = class_merger
+      @base_theme = (theme || {}).deep_stringify_keys
+    end
+
+    # Merge another theme into the current theme
+    def merge!(theme)
+      theme = Theme.load_file theme if theme.is_a? String
+      theme = theme.base_theme if theme.is_a? Theme
+      base_theme.deep_merge! theme
+      self
+    end
+
+    def merge(theme)
+      dup.merge! theme
+    end
+
+    def dup
+      Theme.new @base_theme.deep_dup
+    end
+
+    # Return the classnames for the `key` in the theme
+    def classname(key)
+      key = normalize_key key
+      return if key.blank?
+
+      lookup_key base_theme, key
+    end
+
+    alias [] classname
+
+    def theme(key)
+      key = normalize_key key
+      return if key.blank?
+
+      hash = lookup_key base_theme, key
+      return if hash.blank?
+
+      self.class.new hash
+    end
+
+    def apply(key, object, attributes = {})
+      key = normalize_key key
+      return if key.blank? || object.blank?
+
+      object_theme = lookup_key base_theme, key
+      attributes = ActiveSupport::HashWithIndifferentAccess.new attributes
+      object = ActiveSupport::HashWithIndifferentAccess.new object if object.is_a? Hash
+      apply_theme object_theme, object, attributes
+    end
+
+    def to_h
+      @base_theme.deep_dup.to_h
+    end
+
+    delegate :to_json, :as_json, to: :to_h
+
+    protected
+
+    attr_reader :base_theme, :class_merger
+
+    def normalize_key(key)
+      Array(key).map { |k| k.to_s.split "." }.flatten.presence
+    end
+
+    def lookup_key(theme, key)
+      return theme if key.empty?
+      return nil unless theme.is_a? Hash
+
+      lookup_key theme[key.shift], key
+    end
+
+    def apply_theme(theme, object, attributes)
+      return if theme.blank?
+
+      theme.inject(theme[BASE_KEY]) do |classes, (key, value)|
+        class_merger.merge [classes, apply_classes_for(object, attributes, key, value)]
+      end
+    end
+
+    def apply_classes_for(object, attributes, key, value)
+      object_value = object_attribute_value object, attributes, key.to_sym
+
+      if value.is_a? Hash
+        theme = value[object_value&.to_s]
+        theme.is_a?(Hash) ? apply_theme(theme, object, attributes) : theme
+      elsif object_value
+        value
+      end
+    end
+
+    def object_attribute_value(object, attributes, attribute)
+      if attributes.key?(attribute)
+        attributes[attribute]
+      elsif object.is_a?(Hash)
+        object[attribute]
+      elsif object.respond_to? attribute, true
+        object.send attribute
+      end
+    end
+
+    class << self
+      # Load the theme from a YAML file
+      # @param [String] file The path to the theme file.
+      # @return [FoxTail::Theme] The loaded theme object.
+      # @raise [IO::Error] if unable to load the theme file
+      def load_file(file)
+        new YAML.load_file(file, aliases: true)
+      end
+    end
+  end
+end

data/lib/fox_tail/translator.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module FoxTail
+  class Translator
+    attr_reader :model, :object_name, :method, :value, :scope, :default_value
+
+    def initialize(object, object_name, method, options = {})
+      @model = object.respond_to?(:to_model) ? object.to_model : nil
+      @object_name = object_name.gsub(/\[(.*)_attributes\]\[\d+\]/, '.\1')
+      @method = method
+      @value = options[:value]
+      @scope = options[:scope]
+      @default_value = options.fetch(:default, "")
+    end
+
+    def translate
+      return default_value unless method.present?
+
+      defaults = []
+
+      object_scopes.each do |object_scope|
+        method_scopes.each do |method_scope|
+          defaults << [object_scope, method_scope].compact_blank.join(".").to_sym
+        end
+      end
+
+      defaults << method.to_sym
+      defaults << default_value
+
+      I18n.t(defaults.shift, default: defaults, scope: scope).presence
+    end
+
+    def to_s
+      translate
+    end
+
+    private
+
+    def object_scopes
+      objects = []
+      objects << object_name if object_name.present?
+      objects << model.model_name.i18n_key if model
+      objects << nil
+      objects
+    end
+
+    def method_scopes
+      value.present? ? ["#{method}.#{value}", "#{method}/#{value}", method] : [method]
+    end
+  end
+end

data/lib/fox_tail/version.rb

@@ -0,0 +1,3 @@
+module FoxTail
+  VERSION = "0.1.0"
+end

data/lib/fox_tail.rb

@@ -0,0 +1,20 @@
+require "active_support/dependencies/autoload"
+
+require "fox_tail/version"
+require "fox_tail/errors"
+require "fox_tail/engine"
+
+module FoxTail
+  extend ActiveSupport::Autoload
+
+  autoload :ClassnameMerger
+  autoload :Config
+  autoload :Base
+  autoload :Theme
+  autoload :Translator
+  autoload :StimulusController
+
+  def self.root
+    Pathname.new File.expand_path("..", __dir__)
+  end
+end

data/lib/generators/fox_tail/themes_generator.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+module FoxTail
+  class ThemesGenerator < Rails::Generators::Base
+    desc "Copy Fox Tail UI component themes in your view component folder."
+
+    source_root FoxTail.root.join("app/components/fox_tail").to_s
+
+    class_option :components,
+                 aliases: "-c",
+                 type: :array,
+                 desc: "Select specific controllers to generate (i.e., Accordion, Modal, Tooltip, etc.)."
+
+    def copy_themes
+      if options.components.present?
+        copy_selected_components
+      else
+        copy_all
+      end
+    end
+
+    private
+
+    def copy_selected_components
+      options.components.each do |component|
+        copy_theme_file "#{component.underscore}_component.theme.yml"
+      end
+    end
+
+    def copy_all
+      source_paths.each do |source_path|
+        files = Dir[File.join(source_path, "**/*.theme.yml")]
+        next if files.blank?
+
+        files.each do |file|
+          path = Pathname file
+          path = path.relative_path_from source_path if path.absolute?
+          copy_theme_file path.to_s
+        end
+      end
+    end
+
+    def copy_theme_file(file)
+      copy_file file, File.join(ViewComponent::Base.view_component_path, "fox_tail", file)
+    end
+  end
+end

data/lib/tasks/fox_tail.rake

@@ -0,0 +1,6 @@
+namespace :fox_tail do
+  # Get the root directory for the gem
+  task :which do
+    puts FoxTail.root.to_s
+  end
+end