coveragebook_components 0.5.0

data/lib/coco/action_view_helper.rb

@@ -0,0 +1,134 @@
+module Coco
+  module ActionViewHelper
+    include ActionView::Helpers::UrlHelper
+    extend self
+
+    def convert_options_to_data_attributes(options, html_options)
+      if html_options
+        html_options = html_options.stringify_keys
+        html_options["data-remote"] = "true" if link_to_remote_options?(options) || link_to_remote_options?(html_options)
+
+        method = html_options.delete("method")
+
+        add_method_to_attributes!(html_options, method) if method
+
+        html_options
+      else
+        link_to_remote_options?(options) ? {"data-remote" => "true"} : {}
+      end
+    end
+
+    def url_target(name, options)
+      if name.respond_to?(:model_name) && options.is_a?(Hash) && options.empty?
+        url_for(name)
+      else
+        url_for(options)
+      end
+    end
+
+    def link_to_remote_options?(options)
+      if options.is_a?(Hash)
+        options.delete("remote") || options.delete(:remote)
+      end
+    end
+
+    def add_method_to_attributes!(html_options, method)
+      if method_not_get_method?(method) && !html_options["rel"]&.match?(/nofollow/)
+        html_options["rel"] = if html_options["rel"].blank?
+          "nofollow"
+        else
+          "#{html_options["rel"]} nofollow"
+        end
+      end
+      html_options["data-method"] = method
+    end
+
+    def method_for_options(options)
+      if options.is_a?(Array)
+        method_for_options(options.last)
+      elsif options.respond_to?(:persisted?)
+        options.persisted? ? :patch : :post
+      elsif options.respond_to?(:to_model)
+        method_for_options(options.to_model)
+      end
+    end
+
+    STRINGIFIED_COMMON_METHODS = {
+      get: "get",
+      delete: "delete",
+      patch: "patch",
+      post: "post",
+      put: "put"
+    }.freeze
+
+    def method_not_get_method?(method)
+      return false unless method
+      (STRINGIFIED_COMMON_METHODS[method] || method.to_s.downcase) != "get"
+    end
+
+    def token_tag(token = nil, form_options: {})
+      if token != false && defined?(protect_against_forgery?) && protect_against_forgery?
+        token =
+          if token == true || token.nil?
+            form_authenticity_token(form_options: form_options.merge(authenticity_token: token))
+          else
+            token
+          end
+        tag(:input, type: "hidden", name: request_forgery_protection_token.to_s, value: token, autocomplete: "off")
+      else
+        ""
+      end
+    end
+
+    def method_tag(method)
+      tag("input", type: "hidden", name: "_method", value: method.to_s, autocomplete: "off")
+    end
+
+    # Returns an array of hashes each containing :name and :value keys
+    # suitable for use as the names and values of form input fields:
+    #
+    #   to_form_params(name: 'David', nationality: 'Danish')
+    #   # => [{name: 'name', value: 'David'}, {name: 'nationality', value: 'Danish'}]
+    #
+    #   to_form_params(country: { name: 'Denmark' })
+    #   # => [{name: 'country[name]', value: 'Denmark'}]
+    #
+    #   to_form_params(countries: ['Denmark', 'Sweden']})
+    #   # => [{name: 'countries[]', value: 'Denmark'}, {name: 'countries[]', value: 'Sweden'}]
+    #
+    # An optional namespace can be passed to enclose key names:
+    #
+    #   to_form_params({ name: 'Denmark' }, 'country')
+    #   # => [{name: 'country[name]', value: 'Denmark'}]
+    def to_form_params(attribute, namespace = nil)
+      attribute = if attribute.respond_to?(:permitted?)
+        attribute.to_h
+      else
+        attribute
+      end
+
+      params = []
+      case attribute
+      when Hash
+        attribute.each do |key, value|
+          prefix = namespace ? "#{namespace}[#{key}]" : key
+          params.push(*to_form_params(value, prefix))
+        end
+      when Array
+        array_prefix = "#{namespace}[]"
+        attribute.each do |value|
+          params.push(*to_form_params(value, array_prefix))
+        end
+      else
+        params << {name: namespace.to_s, value: attribute.to_param}
+      end
+
+      params.sort_by { |pair| pair[:name] }
+    end
+
+    def remove_trailing_slash!(url_string)
+      trailing_index = (url_string.index("?") || 0) - 1
+      url_string[trailing_index] = "" if url_string[trailing_index] == "/"
+    end
+  end
+end

data/lib/coco/app_form_builder.rb

@@ -0,0 +1,3 @@
+class Coco::AppFormBuilder < ViewComponent::Form::Builder
+  namespace "Coco::App::Fields"
+end

data/lib/coco/component_resolver.rb

@@ -0,0 +1,37 @@
+module Coco
+  class ComponentResolver
+    CLASS_CACHE = {}
+
+    delegate_missing_to :@klass
+
+    def initialize(klass, *args, **kwargs)
+      @klass = klass
+      @args = args
+      @kwargs = kwargs
+    end
+
+    def render_in(view_context, ...)
+      view_context.render(instance, ...)
+    end
+
+    def instance
+      @_instance ||= @klass.new(*@args, **@kwargs)
+    end
+
+    class << self
+      def new(target, *args, **kwargs)
+        klass = target.is_a?(String) ? lookup_class(target) : target
+
+        if args.any? || kwargs.any?
+          klass.new(*args, **kwargs)
+        else
+          super(klass, *args, **kwargs)
+        end
+      end
+
+      def lookup_class(path)
+        CLASS_CACHE[path] ||= path.tr("-", "_").camelize.constantize
+      end
+    end
+  end
+end

data/lib/coco/engine.rb

@@ -0,0 +1,43 @@
+require "rails/engine"
+require "view_component"
+
+module Coco
+  class Engine < ::Rails::Engine
+    isolate_namespace Coco
+
+    COLLAPSE_DIRS = %w[base]
+
+    config.autoload_paths += %W[
+      #{root}/app/components
+      #{root}/app/helpers
+    ]
+
+    initializer "coco.autoloading" do |app|
+      coco_dir = "#{root}/app/components/coco"
+
+      app.autoloaders.each do |autoloader|
+        COLLAPSE_DIRS.each do |path|
+          autoloader.collapse("#{coco_dir}/#{path}")
+        end
+
+        Dir.glob("#{coco_dir}/base/**/*.rb").each do |path|
+          autoloader.collapse(File.dirname(path))
+        end
+
+        Dir.glob("#{coco_dir}/{app,book}/{blocks,elements,layouts}/**/*.rb").each do |path|
+          autoloader.collapse(File.dirname(path))
+        end
+      end
+
+      Rails.application.config.to_prepare do
+        Rails.autoloaders.main.eager_load_dir(coco_dir)
+      end
+    end
+
+    initializer "coco.assets" do |app|
+      if app.config.respond_to?(:assets)
+        app.config.assets.precompile += %w[coco/manifest.js *.svg]
+      end
+    end
+  end
+end

data/lib/coco/options/group.rb

@@ -0,0 +1,185 @@
+module Coco
+  module Options
+    class Group
+      include Options::Item
+
+      attr_accessor :shorthand
+      attr_reader :name, :items
+
+      def initialize(name, shorthand: nil, **kwargs)
+        @name = name.to_sym
+        @shorthand = shorthand&.to_sym
+        @alias = kwargs.fetch(:alias, nil)
+        @private = kwargs.fetch(:private, false)
+        @items = []
+      end
+
+      def accepts_option(...)
+        if block_given?
+          subgroup = Group.new(...)
+          yield subgroup
+          add_group(subgroup)
+        else
+          add_option(...)
+        end
+      end
+
+      def add_option(...)
+        items << Option.new(...)
+      end
+
+      def add_group(...)
+        items << Group.new(...)
+      end
+
+      # Like #dig... but for options.
+      #
+      # get_option(:size)
+      # get_option(:dropdown, :placement)
+      def get_option(*args)
+        option_name = args.pop.to_sym
+        group = get_group(*args)
+        group.items.find { _1.name == option_name && _1.is_a?(Option) }
+      end
+
+      def get_option!(*args)
+        get_option(*args) || raise("Unknown option: `#{args.join(", ")}`")
+      end
+
+      def option?(...)
+        !!get_option(...)
+      end
+
+      def get_option_value(...)
+        get_option!(...).value
+      end
+
+      def set_option_value(*args, value)
+        if option?(*args)
+          get_option(*args).value = value
+        elsif group?(*args)
+          group = get_group(*args)
+          if group.shorthand
+            group.set_option_value(group.shorthand, value)
+          end
+        end
+      end
+
+      def option_value_equals?(*args, check)
+        get_option_value(*args) == check
+      end
+
+      def merge_option_values(*args, values, overwrite: true)
+        get_group!(*args).items.each do |item|
+          if values.key?(item.name)
+            value = values[item.name]
+            if item.is_a?(Option)
+              item.value = value if overwrite || item.undefined?
+            elsif value.is_a?(Hash) || item.shorthand
+              value = value.is_a?(Hash) ? value : [[item.shorthand, value]].to_h
+              item.merge_option_values(value, overwrite: overwrite)
+            end
+          end
+        end
+      end
+
+      # Like #dig... but for groups.
+      def get_group(*args)
+        current = args.any? ? nil : self
+        args.each do |group_name|
+          next_group = (current || self).groups.find { _1.name == group_name.to_sym }
+          current = next_group || break
+        end
+        current
+      end
+
+      def get_group!(*args)
+        get_group(*args) || raise("Unknown group: `#{args.join(", ")}`")
+      end
+
+      def group?(...)
+        !!get_group(...)
+      end
+
+      def validate_required!
+        items.map(&:validate_required!)
+      end
+
+      def option_names
+        items.map(&:name)
+      end
+
+      def values
+        items.map do |item|
+          [item.name, item.is_a?(Option) ? item.value : item.values]
+        end.to_h
+      end
+
+      def public_items
+        items.filter(&:public?)
+      end
+
+      def flattened_attribute_values(key_prefix = nil)
+        public_items.each_with_object([]) do |item, values|
+          key = [key_prefix, item.html_alias].compact.join("-")
+          if item.is_a?(Option)
+            item.value.nil? ? values : values.push([key, item.value])
+          else
+            values.push(*item.flattened_attribute_values(key).to_a)
+          end
+        end.to_h
+      end
+
+      def to_h
+        {
+          name: name,
+          alias: @alias,
+          shorthand: shorthand,
+          options: items.map(&:to_h)
+        }
+      end
+
+      def clone
+        Group.from_h(to_h)
+      end
+
+      protected
+
+      # All options in this group.
+      # Does not include options in subgroups.
+      def options
+        items.filter { _1.is_a?(Option) }
+      end
+
+      # All groups in this group
+      # Does not include groups in subgroups.
+      def groups
+        items.filter { _1.is_a?(Group) }
+      end
+
+      class << self
+        # Recursively create an options tree from a hash.
+        #
+        # {
+        #   name: :root,
+        #   options: [
+        #     { name: :size, default: "md" },
+        #     { name: :dropdown, options: [{name: :placement, from: [:left, :right]}] }
+        #   }
+        # }
+        def from_h(data)
+          group = Group.new(data.fetch(:name), **data.except(:options, :name))
+          data.fetch(:options, []).each do |option|
+            if option.key?(:options)
+              subgroup = Group.from_h(option)
+              group.add_group(subgroup)
+            else
+              group.add_option(option.fetch(:name), **option.except(:name))
+            end
+          end
+          group
+        end
+      end
+    end
+  end
+end

data/lib/coco/options/item.rb

@@ -0,0 +1,29 @@
+module Coco
+  module Options
+    module Item
+      extend ActiveSupport::Concern
+
+      def alias
+        @alias || name
+      end
+
+      def html_alias
+        self.alias.to_s.tr("_", "-")
+      end
+
+      def private?
+        @private == true
+      end
+
+      def public?
+        !private?
+      end
+
+      class_methods do
+        def new(arg, **opts)
+          arg.is_a?(self) ? arg : super(arg, **opts)
+        end
+      end
+    end
+  end
+end

data/lib/coco/options/option.rb

@@ -0,0 +1,58 @@
+module Coco
+  module Options
+    class Option
+      include Options::Item
+
+      attr_accessor :default
+      attr_reader :from, :name
+
+      def initialize(name, required: false, value: :undefined, from: nil, **kwargs)
+        @name = name.to_sym
+        @required = required
+        @value = value
+        @from = Array(from)
+        @private = kwargs.fetch(:private, false)
+        @default = kwargs.fetch(:default, nil)
+        @alias = kwargs.fetch(:alias, nil)
+      end
+
+      def validate_required!
+        if required? && undefined?
+          raise ArgumentError, "The `#{name}` option requires a value"
+        end
+      end
+
+      def required?
+        @required == true
+      end
+
+      def undefined?
+        @value == :undefined
+      end
+
+      def value
+        undefined? ? default : @value
+      end
+
+      def value=(val)
+        if from.any? && !from.include?(val)
+          raise ArgumentError, "`#{val}` is not a valid #{name} value.\n\tAvailable options: #{from}"
+        end
+        @value = val
+      end
+
+      def to_h
+        h = {
+          name: name,
+          alias: @alias,
+          required: required?,
+          private: private?,
+          from: from,
+          default: default
+        }
+        h[:value] = @value unless undefined?
+        h
+      end
+    end
+  end
+end

data/lib/coco/preview.rb

@@ -0,0 +1,12 @@
+module Coco
+  class Preview < ViewComponent::Preview
+    include Coco::Helpers
+
+    protected
+
+    def icon_names
+      @_icons ||= icon_data_file = File.join(File.dirname(__FILE__), "../../config/icons.json")
+      JSON.parse(File.read(icon_data_file)).map { _1.tr("-", "_") }
+    end
+  end
+end

data/lib/coco/test_helpers.rb

@@ -0,0 +1,42 @@
+module Coco
+  module TestHelpers
+    NESTED_TAG_ATTRS = %w[data test_data x]
+
+    def create_class(name, parent)
+      klass = Class.new(parent)
+      Object.const_set(name, klass)
+      klass
+    end
+
+    def assert_component_selector(name, text: nil, visible: nil, **opts)
+      assert_selector(component_selector(name, **opts), text: text, visible: visible)
+    end
+
+    def component_selector(name, **opts)
+      attr_selector = build_attr_selector(opts.except(:append, :tag))
+      "#{opts[:tag]}[data-component='#{name}']#{attr_selector}#{opts[:append]}".strip
+    end
+
+    def build_attr_selector(attrs)
+      tag_attrs = attrs.except(*NESTED_TAG_ATTRS)
+      NESTED_TAG_ATTRS.each do |key|
+        subattrs = attrs.fetch(key, {})
+        tag_attrs.merge!(prefix_keys(subattrs, key))
+      end
+      attrs.reduce("") do |str, (key, value)|
+        if value.is_a?(Hash)
+          value.each do |k, v|
+            str += "[#{key}-#{k}='#{v}']"
+          end
+        else
+          str += "[#{key}='#{value}']"
+        end
+        str
+      end
+    end
+
+    def prefix_keys(attrs, prefix)
+      attrs.transform_keys! { [prefix, _1].map(&:to_s).join("-").tr("_", "-") }
+    end
+  end
+end

data/lib/coco.rb

@@ -0,0 +1,3 @@
+module Coco
+  VERSION = "0.5.0"
+end

data/lib/coveragebook_components.rb

@@ -0,0 +1,18 @@
+require "zeitwerk"
+require "coco"
+require "coco/engine"
+
+loader = Zeitwerk::Loader.for_gem
+loader.ignore("#{__dir__}/coco.rb")
+loader.ignore("#{__dir__}/coveragebook_components.rb")
+loader.push_dir("#{__dir__}/coco", namespace: Coco)
+loader.ignore("#{__dir__}/generators")
+loader.setup
+
+module CoveragebookComponents
+  class << self
+    def version
+      Coco::VERSION
+    end
+  end
+end

data/lib/generators/coco/USAGE

@@ -0,0 +1,11 @@
+Description:
+Generates a new Coco component with test and preview
+
+Example:
+rails generate coco App::Elements::Button
+
+    Creates the component class and associated files
+        app/components/coco/app/elements/button/component.rb
+        app/components/coco/app/elements/button/component.html.erb
+        lookbook/app/previews/app/elements/button_component_preview.rb
+        test/components/coco/app/elements/button_component_test.rb

data/lib/generators/coco/coco_generator.rb

@@ -0,0 +1,93 @@
+class CocoGenerator < Rails::Generators::NamedBase
+  source_root File.expand_path("templates", __dir__)
+
+  argument :attributes, type: :array, default: [], banner: "attribute"
+
+  def create_component_file
+    template "component.rb", component_file_path
+  end
+
+  def create_template_file
+    template "component.html.erb", template_file_path
+  end
+
+  def create_css_file
+    template "component.css", css_file_path
+  end
+
+  def create_js_file
+    template "component.js", js_file_path
+  end
+
+  def create_preview_file
+    template "preview.rb", preview_file_path
+  end
+
+  def create_test_file
+    template "test.rb", test_file_path
+  end
+
+  private
+
+  def component_dir
+    File.join("app/components", class_path, file_name)
+  end
+
+  def component_file_path
+    File.join(component_dir, "component.rb")
+  end
+
+  def template_file_path
+    File.join(component_dir, "component.html.erb")
+  end
+
+  def js_file_path
+    File.join(component_dir, "component.js")
+  end
+
+  def css_file_path
+    File.join(component_dir, "component.css")
+  end
+
+  def preview_file_path
+    File.join("lookbook/app/previews", class_path_no_coco, "#{file_name}_component_preview.rb")
+  end
+
+  def test_file_path
+    File.join("test/components", class_path_no_coco, "#{file_name}_component_test.rb")
+  end
+
+  def modules_count
+    class_namespace_modules.size
+  end
+
+  def indent(level)
+    level.times.collect { "\t" }.join
+  end
+
+  def zeitwerk_class_name
+    class_name.split("::").filter { !%w[Elements Blocks Layouts Base].include?(_1) }.join("::")
+  end
+
+  def class_path_no_coco
+    class_path.drop(1)
+  end
+
+  def component_class
+    class_name.split("::").last.to_s
+  end
+
+  def class_namespace_modules
+    parts = class_name.split("::")
+    parts.first parts.size - 1
+  end
+
+  def component_ref
+    parts = class_name.delete_prefix("Base::").underscore.dasherize.downcase.split("/")
+    parts.many? ? [parts.first, parts.last].join("-") : parts.first
+  end
+
+  def component_js_name
+    component_ref.tr("-", "_").camelize(:lower)
+  end
+end

data/lib/generators/coco/templates/component.css.tt

@@ -0,0 +1,5 @@
+@layer components {
+  [data-coco][data-component="<%= component_ref %>"] {
+    /* CSS here */
+  }
+}

data/lib/generators/coco/templates/component.html.erb.tt

@@ -0,0 +1,3 @@
+<%%= render component_tag(x: { data: "<%= component_js_name %>" }) do %>
+  <%%= content %>
+<%% end %>

data/lib/generators/coco/templates/component.js.tt

@@ -0,0 +1,7 @@
+import { CocoComponent } from "@js/coco";
+
+export default CocoComponent("<%= component_js_name %>", () => {
+  return {
+    // Alpine data properties
+  };
+});