yattho_view_components 0.0.1

data/lib/yattho/view_components/linters/migrate_deprecated_flash_arguments.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require_relative "helpers/rubocop_helpers"
+
+module ERBLint
+  module Linters
+    # Migrates deprecated arguments in Yattho::Beta::Flash components to their equivalents.
+    class MigrateDeprecatedFlashArguments < Linter
+      # Taken from https://github.com/rails/rails/blob/main/actionview/lib/action_view/template/handlers/erb/erubi.rb#L45
+      BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/.freeze
+
+      include ERBLint::LinterRegistry
+      include Helpers::RubocopHelpers
+
+      def run(processed_source)
+        processed_source.ast.descendants(:erb).each do |erb_node|
+          indicator_node, _, code_node = *erb_node
+          code = code_node.children.first
+          ast = erb_ast(maybe_close_block(code))
+          next unless ast
+
+          constructor_arg_hashes = find_new_flash_instances(ast)
+          next if constructor_arg_hashes.empty?
+
+          indicator, = *indicator_node
+          indicator ||= ""
+
+          # +2 to account for the leading "<%" characters
+          code_start_pos = erb_node.location.begin_pos + indicator.size + 2
+
+          constructor_arg_hashes.each do |constructor_arg_hash|
+            spacious_arg = constructor_arg_hash.include?(:spacious)
+            next unless spacious_arg
+
+            orig_loc = code_node.location
+            key_node, value_node = constructor_arg_hash[:spacious]
+
+            new_loc = orig_loc.with(
+              begin_pos: key_node.location.expression.begin_pos + code_start_pos,
+              end_pos: value_node.location.expression.end_pos + code_start_pos
+            )
+
+            if value_node.source == "true"
+              add_offense(
+                new_loc,
+                "The :spacious argument is deprecated. Use `mb: 4` instead.",
+                "mb: 4"
+              )
+            else
+              new_loc = adjust_to_preceding_comma(new_loc)
+
+              add_offense(
+                new_loc,
+                "The :spacious argument is deprecated; `spacious: false` can be removed.",
+                ""
+              )
+            end
+          end
+        end
+      end
+
+      def autocorrect(_, offense)
+        return unless offense.context
+
+        lambda do |corrector|
+          corrector.replace(offense.source_range, offense.context)
+        end
+      end
+
+      private
+
+      def adjust_to_preceding_comma(loc)
+        comma_pos = loc.source_buffer.source.rindex(/\s*,/, loc.begin_pos)
+        return loc unless comma_pos
+
+        loc.with(begin_pos: comma_pos)
+      end
+
+      def find_new_flash_instances(ast)
+        if (instance = find_new_flash_instance(ast))
+          return [instance]
+        end
+
+        ast.each_child_node.flat_map do |child_ast|
+          find_new_flash_instances(child_ast)
+        end
+      end
+
+      def find_new_flash_instance(ast)
+        render_body = unwrap_render(ast)
+        return nil unless render_body
+
+        constructor_args = unwrap_constructor(render_body)
+        return nil unless constructor_args
+
+        arg1, = *render_body
+        return nil unless arg1.type == :const
+        return nil unless arg1.source == "Yattho::Beta::Flash"
+
+        parse_args(constructor_args)
+      end
+
+      def parse_args(arg_node)
+        arg_node.children.each_with_object({}) do |child, memo|
+          key_node, value_node = *child.children
+          memo[key_node.source.to_sym] = [key_node, value_node]
+        end
+      end
+
+      def unwrap_render(ast)
+        unwrap_method_call(ast, :render)
+      end
+
+      def unwrap_constructor(ast)
+        unwrap_method_call(ast, :new)
+      end
+
+      def unwrap_method_call(ast, method_name)
+        return nil unless ast
+        return nil unless ast.type == :send
+
+        _, name, body = *ast
+        return nil if name != method_name
+
+        body
+      end
+
+      def maybe_close_block(code)
+        match = code.match(BLOCK_EXPR)
+        return code unless match
+
+        if match.captures[0].strip == "do"
+          "#{code}; end"
+        else
+          "#{code} }"
+        end
+      end
+    end
+  end
+end

data/lib/yattho/view_components/linters/severity_schema.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "erb_lint/utils/severity_levels"
+
+module ERBLint
+  module Linters
+    class SeveritySchema < LinterConfig
+      # SEVERITY_NAMES :info, :refactor, :convention, :warning, :error, :fatal
+      # see https://github.com/Shopify/erb-lint/blob/main/lib/erb_lint/utils/severity_levels.rb
+
+      property :severity, accepts: ERBLint::Utils::SeverityLevels::SEVERITY_NAMES, default: nil, reader: :severity
+    end
+  end
+end

data/lib/yattho/view_components/linters/subhead_component_migration_counter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "base_linter"
+
+module ERBLint
+  module Linters
+    # Counts the number of times a HTML Subhead is used instead of the component.
+    class SubheadComponentMigrationCounter < BaseLinter
+      MESSAGE = "We are migrating Subhead to use [Yattho::Beta::Subhead](https://yattho.com/view-components/components/subhead), please try to use that instead of raw HTML."
+      CLASSES = %w[Subhead].freeze
+      TAGS = %w[div].freeze
+    end
+  end
+end

data/lib/yattho/view_components/linters/super_in_component_templates.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative "helpers/rubocop_helpers"
+
+module ERBLint
+  module Linters
+    # Replaces calls to `super` with calls to `render_parent`.
+    class SuperInComponentTemplates < Linter
+      include ERBLint::LinterRegistry
+      include Helpers::RubocopHelpers
+
+      def run(processed_source)
+        processed_source.ast.descendants(:erb).each do |erb_node|
+          indicator_node, _, code_node = *erb_node
+          code = code_node.children.first
+          ast = erb_ast(code)
+          next unless ast
+
+          super_call_nodes = find_super_call_nodes(ast)
+          next if super_call_nodes.empty?
+
+          indicator, = *indicator_node
+          indicator ||= ""
+
+          # +2 to account for the leading "<%" characters
+          code_start_pos = erb_node.location.begin_pos + indicator.size + 2
+
+          super_call_nodes.each do |super_call_node|
+            orig_loc = code_node.location
+            super_call_loc = super_call_node.location.expression
+
+            new_loc = orig_loc.with(
+              begin_pos: super_call_loc.begin_pos + code_start_pos,
+              end_pos: super_call_loc.end_pos + code_start_pos
+            )
+
+            add_offense(
+              new_loc,
+              "Avoid calling `super` in component templates. Call `render_parent` instead",
+              "render_parent"
+            )
+          end
+        end
+      end
+
+      def autocorrect(_, offense)
+        return unless offense.context
+
+        lambda do |corrector|
+          corrector.replace(offense.source_range, offense.context)
+        end
+      end
+
+      private
+
+      def find_super_call_nodes(ast)
+        return [ast] if ast.type == :zsuper
+
+        ast.each_child_node.flat_map do |child_ast|
+          find_super_call_nodes(child_ast)
+        end
+      end
+    end
+  end
+end

data/lib/yattho/view_components/linters/tag_tree_helpers.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module ERBLint
+  module Linters
+    # Helpers used by linters to organize HTML tags into abstract syntax trees.
+    module TagTreeHelpers
+      # from https://github.com/Shopify/erb-lint/blob/6179ee2d9d681a6ec4dd02351a1e30eefa748d3d/lib/erb_lint/linters/self_closing_tag.rb
+      SELF_CLOSING_TAGS = %w[
+        area base br col command embed hr input keygen
+        link menuitem meta param source track wbr img
+      ].freeze
+
+      # This assumes that the AST provided represents valid HTML, where each tag has a corresponding closing tag.
+      # From the tags, we build a structured tree which represents the tag hierarchy.
+      # With this, we are able to know where the tags start and end.
+      def build_tag_tree(processed_source)
+        nodes = processed_source.ast.children
+        tag_tree = {}
+        tags = []
+        current_opened_tag = nil
+
+        nodes.each do |node|
+          if node.type == :tag
+            # get the tag from previously calculated list so the references are the same
+            tag = BetterHtml::Tree::Tag.from_node(node)
+            tags << tag
+
+            if tag.closing?
+              if current_opened_tag && tag.name == current_opened_tag.name
+                tag_tree[current_opened_tag][:closing] = tag
+                current_opened_tag = tag_tree[current_opened_tag][:parent]
+              end
+
+              next
+            end
+
+            self_closing = self_closing?(tag)
+
+            tag_tree[tag] = {
+              tag: tag,
+              closing: self_closing ? tag : nil,
+              parent: current_opened_tag,
+              children: []
+            }
+
+            tag_tree[current_opened_tag][:children] << tag_tree[tag] if current_opened_tag
+            current_opened_tag = tag unless self_closing
+          elsif current_opened_tag
+            tag_tree[current_opened_tag][:children] << node
+          end
+        end
+
+        [tags, tag_tree]
+      end
+
+      def self_closing?(tag)
+        tag.self_closing? || SELF_CLOSING_TAGS.include?(tag.name)
+      end
+    end
+  end
+end

data/lib/yattho/view_components/linters/two_column_layout_migration_counter.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require_relative "base_linter"
+require_relative "tag_tree_helpers"
+
+module ERBLint
+  module Linters
+    # Counts the number of times a two column layout using col-* CSS classes is used instead of the layout component.
+    class TwoColumnLayoutMigrationCounter < BaseLinter
+      include LinterRegistry
+      include TagTreeHelpers
+
+      WIDTH_RANGE = (8..10).freeze
+      SIDEBAR_WIDTH_RANGE = (2..4).freeze
+
+      CONTAINER_CLASSES = %w[container-xl container-lg container-md container-sm].freeze
+      MESSAGE = "We are migrating two-column layouts to use " \
+                "[Yattho::Alpha::Layout](https://yattho.com/view-components/components/layout), " \
+                "please use that instead of raw HTML."
+
+      # :nodoc:
+      class Breakpoints
+        LABELS = %i[all sm md lg xl].freeze
+
+        def initialize
+          @map = {}
+        end
+
+        def set(breakpoint, value)
+          @map[breakpoint] = value
+        end
+
+        def min
+          LABELS.find { |label| @map[label] } || :all
+        end
+
+        def min_value
+          @map[min]
+        end
+      end
+
+      # :nodoc:
+      class Column
+        attr_reader :widths, :tag_tree
+
+        def initialize(widths, tag_tree)
+          @widths = widths
+          @tag_tree = tag_tree
+        end
+      end
+
+      # :nodoc:
+      class Container
+        attr_reader :columns
+
+        def initialize(columns)
+          @columns = columns
+        end
+
+        def sidebar
+          sorted_columns.first
+        end
+
+        def main
+          sorted_columns.last
+        end
+
+        private
+
+        def sorted_columns
+          @sorted_columns ||= columns.sort_by do |col|
+            col.widths.min_value || 0
+          end
+        end
+      end
+
+      def run(processed_source)
+        @total_offenses = 0
+        @offenses_not_corrected = 0
+
+        tags, tag_tree = build_tag_tree(processed_source)
+
+        tags.each do |tag|
+          next if tag.closing?
+          next unless tag.name == "div"
+
+          classes = classes_from(tag)
+          next if (CONTAINER_CLASSES & classes).empty?
+
+          next unless metadata_from(tag_tree[tag])
+
+          @total_offenses += 1
+          @offenses_not_corrected += 1
+
+          generate_offense(self.class, processed_source, tag, MESSAGE)
+        end
+
+        counter_correct?(processed_source)
+      end
+
+      private
+
+      def metadata_from(tag_tree)
+        tags = tag_tree[:children].select { |c| c.is_a?(Hash) }
+
+        if d_flex?(tags)
+          container_from(tags.first)
+        else
+          container_from(tag_tree)
+        end
+      end
+
+      def d_flex?(tags)
+        tags.size == 1 && classes_from(tags.first[:tag]).include?("d-flex")
+      end
+
+      def container_from(columns_tag_tree)
+        columns = columns_from(columns_tag_tree)
+        return unless columns.size == 2
+
+        container = Container.new(columns)
+
+        main_min = container.main.widths.min_value
+        sidebar_min = container.sidebar.widths.min_value
+        return unless sidebar_min && main_min
+        return unless WIDTH_RANGE.include?(main_min)
+        return unless SIDEBAR_WIDTH_RANGE.include?(sidebar_min)
+
+        container
+      end
+
+      def columns_from(tag_tree)
+        tag_tree[:children].each_with_object([]) do |tag_data, tags_memo|
+          next unless tag_data.is_a?(Hash)
+          next unless tag_data[:tag].name == "div"
+
+          classes = classes_from(tag_data[:tag])
+          widths = Breakpoints.new
+
+          classes.each do |cls|
+            match = cls.match(/\Acol(?:-(xl|lg|md|sm))?-(\d{1,2})(?:-max)?\z/)
+            next unless match
+
+            breakpoint, width = match.captures
+            breakpoint ||= :all
+            widths.set(breakpoint.to_sym, width.to_i)
+          end
+
+          tags_memo << Column.new(widths, tag_data)
+        end
+      end
+
+      def classes_from(tag)
+        tag.attributes["class"]&.value&.split(" ") || []
+      end
+    end
+  end
+end

data/lib/yattho/view_components/linters.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+Dir[File.join(__dir__, "linters", "*.rb")].sort.each { |file| require file }

data/lib/yattho/view_components/statuses.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Yattho
+  # :nodoc:
+  module ViewComponents
+    STATUSES = JSON.parse(
+      File.read(
+        File.join(File.dirname(__FILE__), "../../../static/statuses.json")
+      )
+    ).freeze
+  end
+end

data/lib/yattho/view_components/version.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# :nocov:
+module Yattho
+  module ViewComponents
+    module VERSION
+      MAJOR = 0
+      MINOR = 0
+      PATCH = 1
+
+      STRING = [MAJOR, MINOR, PATCH].join(".")
+    end
+  end
+end
+
+# rubocop:disable Rails/Output
+puts Yattho::ViewComponents::VERSION::STRING if __FILE__ == $PROGRAM_NAME
+# rubocop:enable Rails/Output

data/lib/yattho/view_components.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "yattho/classify"
+require "yattho/view_components/version"
+require "yattho/view_components/engine"
+
+module Yattho
+  # :nodoc:
+  module ViewComponents
+    DEFAULT_STATIC_PATH = File.expand_path("static")
+    FILE_NAMES = {
+      statuses: "statuses.json",
+      constants: "constants.json",
+      audited_at: "audited_at.json"
+    }.freeze
+
+    # generate_statuses returns a hash mapping component name to
+    # the component's status sorted alphabetically by the component name.
+    def self.generate_statuses
+      Yattho::Component.descendants.sort_by(&:name).each_with_object({}) do |component, mem|
+        mem[component.to_s] = component.status.to_s
+      end
+    end
+
+    # generate_audited_at returns a hash mapping component name to
+    # the day the component has passed an accessibility audit.
+    def self.generate_audited_at
+      Yattho::Component.descendants.sort_by(&:name).each_with_object({}) do |component, mem|
+        mem[component.to_s] = component.audited_at.to_s
+      end
+    end
+
+    # generate_constants returns a hash mapping component name to
+    # all of its constants.
+    def self.generate_constants
+      Yattho::Component.descendants.sort_by(&:name).each_with_object({}) do |component, mem|
+        mem[component.to_s] = component.constants(false).sort.index_with do |constant|
+          component.const_get(constant)
+        end
+      end
+    end
+
+    # dump generates the requested stat hash and outputs it to a file.
+    def self.dump(stats)
+      require "json"
+
+      File.open(File.join(DEFAULT_STATIC_PATH, FILE_NAMES[stats]), "w") do |f|
+        f.write(JSON.pretty_generate(send("generate_#{stats}")))
+        f.write($INPUT_RECORD_SEPARATOR)
+      end
+    end
+
+    # read returns a JSON string matching the output of the corresponding stat.
+    def self.read(stats)
+      File.read(File.join(DEFAULT_STATIC_PATH, FILE_NAMES[stats]))
+    end
+
+    # yattho/view_components root directory.
+    def self.root
+      Pathname(File.expand_path(File.join("..", ".."), __dir__))
+    end
+  end
+end

data/lib/yattho/yard/backend.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# :nocov:
+module Yattho
+  module YARD
+    # Shared functionality for generating documentation from YARD comments.
+    class Backend
+      include DocsHelper
+
+      private
+
+      def pretty_default_value(tag, component)
+        params = tag.object.parameters.find { |param| [tag.name.to_s, "#{tag.name}:"].include?(param[0]) }
+        default = tag.defaults&.first || params&.second
+
+        return "N/A" unless default
+
+        constant_name = "#{component.name}::#{default}"
+        constant_value = default.safe_constantize || constant_name.safe_constantize
+
+        return pretty_value(default) if constant_value.nil?
+
+        pretty_value(constant_value)
+      end
+
+      def view_context
+        @view_context ||= begin
+          # Rails controller for rendering arbitrary ERB
+          vc = ApplicationController.new.tap { |c| c.request = ActionDispatch::TestRequest.create }.view_context
+          vc.singleton_class.include(DocsHelper)
+          vc.singleton_class.include(Yattho::ViewHelper)
+          vc
+        end
+      end
+    end
+  end
+end
+# :nocov: