openproject-primer_view_components 0.6.3

data/lib/primer/view_components/linters/helpers/rule_helpers.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ERBLint
+  module Linters
+    module Helpers
+      # Helpers for writing rules
+      module RuleHelpers
+        def tags(processed_source)
+          processed_source.parser.nodes_with_type(:tag).map { |tag_node| BetterHtml::Tree::Tag.from_node(tag_node) }
+        end
+
+        def generate_offense(klass, processed_source, tag, message = nil, replacement = nil)
+          message ||= klass::MESSAGE
+          klass_name = klass.name.demodulize
+          offense = ["#{klass_name}:#{message}", tag.node.loc.source].join("\n")
+          add_offense(processed_source.to_source_range(tag.loc), offense, replacement)
+        end
+
+        # Generate offense for ERB node tag
+        def generate_node_offense(klass, processed_source, node, message = nil)
+          message ||= klass::MESSAGE
+          offense = ["#{klass.name}:#{message}", node.loc.source].join("\n")
+          add_offense(processed_source.to_source_range(node.loc), offense)
+        end
+
+        def erb_nodes(processed_source)
+          processed_source.parser.ast.descendants(:erb)
+        end
+
+        def extract_ruby_from_erb_node(erb_node)
+          return unless erb_node.type == :erb
+
+          _, _, code_node = *erb_node
+          code_node.loc.source.strip
+        end
+      end
+    end
+  end
+end

data/lib/primer/view_components/linters/label_component_migration_counter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative "base_linter"
+require_relative "autocorrectable"
+require_relative "argument_mappers/label"
+
+module ERBLint
+  module Linters
+    # Counts the number of times a HTML label is used instead of the component.
+    class LabelComponentMigrationCounter < BaseLinter
+      include Autocorrectable
+
+      TAGS = ::Primer::ViewComponents::Constants.get(
+        component: "Primer::Beta::Label",
+        constant: "TAG_OPTIONS"
+      ).freeze
+
+      CLASSES = %w[Label].freeze
+      MESSAGE = "We are migrating labels to use [Primer::Beta::Label](https://primer.style/view-components/components/label), please try to use that instead of raw HTML."
+      ARGUMENT_MAPPER = ArgumentMappers::Label
+      COMPONENT = "Primer::Beta::Label"
+    end
+  end
+end

data/lib/primer/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 Primer::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 == "Primer::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/primer/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/primer/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 [Primer::Beta::Subhead](https://primer.style/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/primer/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/primer/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/primer/view_components/linters/tooltipped_migration.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "helpers/rule_helpers"
+module ERBLint
+  module Linters
+    module Primer
+      module Accessibility
+        # Flag when `.tooltipped` is being used and offer alternatives.
+        class TooltippedMigration < Linter
+          include LinterRegistry
+          include Helpers::RuleHelpers
+
+          MIGRATE_TO_NEWER_TOOLTIP = ".tooltipped has been deprecated. There are major accessibility concerns with using this tooltip so please take action. See https://github.com/primer/view_components/blob/main/docs/content/guides/accessibility/tooltipped_migration.md."
+          TOOLTIPPED_RUBY_PATTERN = /classes:.*tooltipped|class:.*tooltipped/.freeze
+
+          def run(processed_source)
+            # HTML tags
+            tags(processed_source).each do |tag|
+              next if tag.closing?
+
+              classes = tag.attributes["class"]&.value
+              generate_offense(self.class, processed_source, tag, MIGRATE_TO_NEWER_TOOLTIP) if classes&.include?("tooltipped")
+            end
+
+            # ERB nodes
+            erb_nodes(processed_source).each do |node|
+              code = extract_ruby_from_erb_node(node)
+              generate_node_offense(self.class, processed_source, node, MIGRATE_TO_NEWER_TOOLTIP) if code.match?(TOOLTIPPED_RUBY_PATTERN)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/primer/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 "\
+        "[Primer::Alpha::Layout](https://primer.style/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/primer/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/primer/view_components/statuses.rb

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

data/lib/primer/view_components/version.rb

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

data/lib/primer/view_components.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "primer/classify"
+require "primer/view_components/version"
+require "primer/view_components/engine"
+
+module Primer
+  # :nodoc:
+  module ViewComponents
+    # primer/view_components root directory.
+    def self.root
+      Pathname(File.expand_path(File.join("..", ".."), __dir__))
+    end
+  end
+end

data/lib/primer/yard/backend.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# :nocov:
+module Primer
+  module Yard
+    # Shared functionality for generating documentation from YARD comments.
+    class Backend
+      include DocsHelper
+
+      private
+
+      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(Primer::ViewHelper)
+          vc
+        end
+      end
+    end
+  end
+end
+# :nocov: