primer_view_components 0.0.48 → 0.0.52

data/lib/rubocop/cop/primer/no_tag_memoize.rb

@@ -2,6 +2,7 @@
 
 require "rubocop"
 
+# :nocov:
 module RuboCop
   module Cop
     module Primer

data/lib/rubocop/cop/primer/primer_octicon.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require "rubocop"
+require "primer/classify/utilities"
+require "primer/classify/validation"
+
+# :nocov:
+module RuboCop
+  module Cop
+    module Primer
+      # This cop ensures that components use System Arguments instead of CSS classes.
+      #
+      # bad
+      # octicon(:icon)
+      # octicon("icon")
+      # octicon("icon-with-daashes")
+      # octicon(@ivar)
+      # octicon(condition > "icon" : "other-icon")
+      #
+      # good
+      # primer_octicon(:icon)
+      # primer_octicon(:"icon-with-daashes")
+      # primer_octicon(@ivar)
+      # primer_octicon(condition > "icon" : "other-icon")
+      class PrimerOcticon < RuboCop::Cop::Cop
+        INVALID_MESSAGE = <<~STR
+          Replace the octicon helper with primer_octicon. See https://primer.style/view-components/components/octicon for details.
+        STR
+
+        SIZE_ATTRIBUTES = %w[height width size].freeze
+        STRING_ATTRIBUTES = %w[aria- data-].freeze
+        VALID_ATTRIBUTES = [*SIZE_ATTRIBUTES, *STRING_ATTRIBUTES, "class"].freeze
+
+        STRING_ATTRIBUTE_REGEX = Regexp.union(STRING_ATTRIBUTES).freeze
+        ATTRIBUTE_REGEX = Regexp.union(VALID_ATTRIBUTES).freeze
+        INVALID_ATTRIBUTE = -1
+
+        def on_send(node)
+          return unless node.method_name == :octicon
+          return unless node.arguments?
+
+          kwargs = kwargs(node)
+
+          return unless kwargs.type == :hash
+
+          attributes = kwargs.keys.map(&:value)
+
+          # Don't convert unknown attributes
+          return unless attributes.all? { |attribute| attribute.match?(ATTRIBUTE_REGEX) }
+          # Can't convert size
+          return if octicon_size_attributes(kwargs) == INVALID_ATTRIBUTE
+
+          # find class pair
+          classes = classes(kwargs)
+
+          return if classes == INVALID_ATTRIBUTE
+
+          # check if classes are convertible
+          if classes.present?
+            system_arguments = ::Primer::Classify::Utilities.classes_to_hash(classes)
+            invalid_classes = (system_arguments[:classes]&.split(" ") || []).select { |class_name| ::Primer::Classify::Validation.invalid?(class_name) }
+
+            # Uses system argument that can't be converted
+            return if invalid_classes.present?
+          end
+
+          add_offense(node, message: INVALID_MESSAGE)
+        end
+
+        def autocorrect(node)
+          lambda do |corrector|
+            kwargs = kwargs(node)
+
+            # Converting arguments for the component
+            classes = classes(kwargs)
+            size_attributes = transform_sizes(kwargs)
+            args = arguments_as_string(node, size_attributes, classes)
+
+            corrector.replace(node.loc.expression, "primer_octicon(#{args})")
+          end
+        end
+
+        private
+
+        def transform_sizes(kwargs)
+          attributes = octicon_size_attributes(kwargs)
+
+          attributes.transform_values do |size|
+            if size.between?(10, 16)
+              ""
+            elsif size.between?(22, 26)
+              ":medium"
+            else
+              size
+            end
+          end
+        end
+
+        def octicon_size_attributes(kwargs)
+          kwargs.pairs.each_with_object({}) do |pair, h|
+            next unless SIZE_ATTRIBUTES.include?(pair.key.value.to_s)
+
+            # We only support string or int values.
+            case pair.value.type
+            when :int
+              h[pair.key.value] = pair.value.source.to_i
+            when :str
+              h[pair.key.value] = pair.value.value.to_i
+            else
+              return INVALID_ATTRIBUTE
+            end
+          end
+        end
+
+        def classes(kwargs)
+          # find class pair
+          class_arg = kwargs.pairs.find { |kwarg| kwarg.key.value == :class }
+
+          return if class_arg.blank?
+          return INVALID_ATTRIBUTE unless class_arg.value.type == :str
+
+          class_arg.value.value
+        end
+
+        def arguments_as_string(node, size_attributes, classes)
+          args = icon(node.arguments.first)
+          size_args = size_attributes_to_string(size_attributes)
+          string_args = string_args_to_string(node)
+
+          args = "#{args}, #{size_attributes_to_string(size_attributes)}" if size_args.present?
+          args = "#{args}, #{::Primer::Classify::Utilities.classes_to_args(classes)}" if classes.present?
+          args = "#{args}, #{string_args}" if string_args.present?
+
+          args
+        end
+
+        def size_attributes_to_string(size_attributes)
+          # No arguments if they map to the default size
+          return if size_attributes.blank? || size_attributes.values.all?(&:blank?)
+          # Return mapped argument to `size`
+          return "size: :medium" if size_attributes.values.any?(":medium")
+
+          size_attributes.map do |key, value|
+            "#{key}: #{value}"
+          end.join(", ")
+        end
+
+        def string_args_to_string(node)
+          kwargs = kwargs(node)
+
+          args = kwargs.pairs.each_with_object([]) do |pair, acc|
+            next unless pair.key.value.to_s.match?(STRING_ATTRIBUTE_REGEX)
+
+            key =  pair.key.value.to_s == "data-test-selector" ? "test_selector" : "\"#{pair.key.value}\""
+            acc << "#{key}: #{pair.value.source}"
+          end
+
+          args.join(",")
+        end
+
+        def kwargs(node)
+          return node.arguments.last if node.arguments.size > 1
+
+          OpenStruct.new(keys: [], pairs: [], type: :hash)
+        end
+
+        def icon(node)
+          return node.source unless node.type == :str
+          return ":#{node.value}" unless node.value.include?("-")
+
+          # If the icon contains `-` we need to cast the string as a symbole
+          # E.g: `arrow-down` becomes `:"arrow-down"`
+          ":#{node.source}"
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/primer/system_argument_instead_of_class.rb

@@ -3,7 +3,9 @@
 require "rubocop"
 require "primer/classify/utilities"
 require "primer/view_components/statuses"
+require_relative "../../../../app/lib/primer/view_helper"
 
+# :nocov:
 module RuboCop
   module Cop
     module Primer
@@ -20,8 +22,7 @@ module RuboCop
         STR
 
         def on_send(node)
-          return unless node.method_name == :new
-          return unless ::Primer::ViewComponents::STATUSES.key?(node.receiver.const_name)
+          return unless valid_node?(node)
           return unless node.arguments?
 
           # we are looking for hash arguments and they are always last
@@ -48,26 +49,21 @@ module RuboCop
 
         def autocorrect(node)
           lambda do |corrector|
-            system_arguments = ::Primer::Classify::Utilities.classes_to_hash(node.value.value)
-            corrector.replace(node.loc.expression, arguments_as_string(system_arguments))
+            args = ::Primer::Classify::Utilities.classes_to_args(node.value.value)
+            corrector.replace(node.loc.expression, args)
           end
         end
 
         private
 
-        def arguments_as_string(system_arguments)
-          system_arguments.map do |key, value|
-            val = case value
-                  when Symbol
-                    ":#{value}"
-                  when String
-                    value.to_json
-                  else
-                    value
-                  end
+        # We only verify SystemArguments if it's a `.new` call on a component or
+        # a ViewHleper call.
+        def valid_node?(node)
+          view_helpers.include?(node.method_name) || (node.method_name == :new && ::Primer::ViewComponents::STATUSES.key?(node.receiver.const_name))
+        end
 
-            "#{key}: #{val}"
-          end.join(", ")
+        def view_helpers
+          ::Primer::ViewHelper::HELPERS.keys.map { |key| "primer_#{key}".to_sym }
         end
       end
     end

data/lib/tasks/constants.rake

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+namespace :constants do
+  task :dump do
+    require File.expand_path("./../../demo/config/environment.rb", __dir__)
+    require "primer/view_components"
+    # Loads all components for `.descendants` to work properly
+    Dir["./app/components/primer/**/*.rb"].sort.each { |file| require file }
+
+    Primer::ViewComponents.dump_constants
+  end
+end

data/lib/tasks/coverage.rake

@@ -9,6 +9,10 @@ namespace :coverage do
 
     SimpleCov.collate Dir["simplecov-resultset-*/.resultset.json"], "rails" do
       formatter SimpleCov::Formatter::Console
+
+      add_group "Ignored Code" do |src_file|
+        File.readlines(src_file.filename).grep(/:nocov:/).any?
+      end
     end
   end
 end

data/lib/tasks/docs.rake

@@ -35,7 +35,7 @@ namespace :docs do
       Primer::Beta::AutoComplete,
       Primer::Beta::AutoComplete::Item,
       Primer::Beta::Avatar,
-      Primer::AvatarStackComponent,
+      Primer::Beta::AvatarStack,
       Primer::BaseButton,
       Primer::BlankslateComponent,
       Primer::BorderBoxComponent,
@@ -74,6 +74,7 @@ namespace :docs do
       Primer::TimelineItemComponent,
       Primer::Tooltip,
       Primer::Truncate,
+      Primer::Beta::Truncate,
       Primer::UnderlineNavComponent
     ]
 
@@ -110,6 +111,7 @@ namespace :docs do
       File.open(path, "w") do |f|
         f.puts("---")
         f.puts("title: #{data[:title]}")
+        f.puts("componentId: #{data[:component_id]}")
         f.puts("status: #{data[:status]}")
         f.puts("source: #{data[:source]}")
         f.puts("storybook: #{data[:storybook]}")
@@ -227,28 +229,17 @@ namespace :docs do
         f.puts("## Examples")
 
         initialize_method.tags(:example).each do |tag|
-          name = tag.name
-          description = nil
-          code = nil
-
-          if tag.text.include?("@description")
-            splitted = tag.text.split(/@description|@code/)
-            description = splitted.second.gsub(/^[ \t]{2}/, "").strip
-            code = splitted.last.gsub(/^[ \t]{2}/, "").strip
-          else
-            code = tag.text
-          end
-
+          name, description, code = parse_example_tag(tag)
           f.puts
           f.puts("### #{name}")
           if description
             f.puts
-            f.puts(description)
+            f.puts(view_context.render(inline: description.squish))
           end
           f.puts
           html = view_context.render(inline: code)
           html.scan(/class="([^"]*)"/) do |classnames|
-            classes_found_in_examples.concat(classnames[0].split(" ").reject { |c| c.starts_with?("octicon", "js", "my-") }.map { ".#{_1}"})
+            classes_found_in_examples.concat(classnames[0].split.reject { |c| c.starts_with?("octicon", "js", "my-") }.map { ".#{_1}" })
           end
           f.puts("<Example src=\"#{html.tr('"', "\'").delete("\n")}\" />")
           f.puts
@@ -330,13 +321,14 @@ namespace :docs do
         f.puts("    class #{short_name}Preview < ViewComponent::Preview")
 
         yard_example_tags.each_with_index do |tag, index|
-          method_name = tag.name.split("|").first.downcase.parameterize.underscore
+          name, _, code = parse_example_tag(tag)
+          method_name = name.split("|").first.downcase.parameterize.underscore
           f.puts("      def #{method_name}; end")
           f.puts unless index == yard_example_tags.size - 1
           path = Pathname.new("demo/test/components/previews/primer/docs/#{short_name.underscore}_preview/#{method_name}.html.erb")
           path.dirname.mkdir unless path.dirname.exist?
           File.open(path, "w") do |view_file|
-            view_file.puts(tag.text.to_s)
+            view_file.puts(code.to_s)
           end
         end
 
@@ -374,8 +366,24 @@ namespace :docs do
     registry
   end
 
+  def parse_example_tag(tag)
+    name = tag.name
+    description = nil
+    code = nil
+
+    if tag.text.include?("@description")
+      splitted = tag.text.split(/@description|@code/)
+      description = splitted.second.gsub(/^[ \t]{2}/, "").strip
+      code = splitted.last.gsub(/^[ \t]{2}/, "").strip
+    else
+      code = tag.text
+    end
+
+    [name, description, code]
+  end
+
   def pretty_default_value(tag, component)
-    params = tag.object.parameters.find { |param| [tag.name.to_s, tag.name.to_s + ":"].include?(param[0]) }
+    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
@@ -388,13 +396,6 @@ namespace :docs do
     pretty_value(constant_value)
   end
 
-  def status_module_and_short_name(component)
-    name_with_status = component.name.gsub(/Primer::|Component/, "")
-
-    m = name_with_status.match(/(?<status>Beta|Alpha|Deprecated)?(::)?(?<name>.*)/)
-    [m[:status]&.downcase, m[:name].gsub("::", "")]
-  end
-
   def docs_metadata(component)
     (status_module, short_name) = status_module_and_short_name(component)
     status_path = status_module.nil? ? "" : "#{status_module}/"
@@ -402,6 +403,7 @@ namespace :docs do
 
     {
       title: short_name,
+      component_id: short_name.underscore,
       status: status.capitalize,
       source: source_url(component),
       storybook: storybook_url(component),

data/lib/tasks/utilities.rake

@@ -5,30 +5,26 @@ namespace :utilities do
     require "yaml"
     require "json"
     require File.expand_path("./../../demo/config/environment.rb", __dir__)
+    require "primer/classify/utilities"
 
     # Keys that are looked for to be included in the utilities.yml file
+    # rubocop:disable Lint/ConstantDefinitionInBlock
     SUPPORTED_KEYS = %i[
       anim
       d
       float
+      height
       hide
       m mt mr mb ml mx my
       p pt pr pb pl px py
       position
       wb
+      width
       v
     ].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"
-    }.freeze
-
     BREAKPOINTS = [nil, "sm", "md", "lg", "xl"].freeze
+    # rubocop:enable Lint/ConstantDefinitionInBlock
 
     css_data =
       JSON.parse(
@@ -44,7 +40,7 @@ namespace :utilities do
     css_data.each do |selector|
       selector.sub!(/^./, "")
       # Next if selector has ancestors or sibling selectors
-      next if selector.match?(/[:><~\[\.]/)
+      next if selector.match?(/[:><~\[.]/)
       next unless SUPPORTED_KEYS.any? { |key| selector.start_with?("#{key}-") }
 
       # Dupe so we still have the selector at the end of slicing it up
@@ -52,11 +48,11 @@ namespace :utilities do
       key = ""
 
       # Look for a replacement key
-      REPLACEMENT_KEYS.each do |k, v|
+      Primer::Classify::Utilities::REPLACEMENT_KEYS.each do |k, v|
         next unless classname.match?(Regexp.new(k))
 
         key = v
-        classname.sub!(Regexp.new(k + "-"), "")
+        classname.sub!(Regexp.new("#{k}-"), "")
       end
 
       # If we didn't find a replacement, grab the first text before hyphen
@@ -72,7 +68,7 @@ namespace :utilities do
       end
 
       # Change the rest from hypens to underscores
-      classname.sub!(/\-/, "_")
+      classname.sub!(/-/, "_")
 
       # convert padding/margin negative values ie n7 to -7
       classname.sub!(/^n/, "-") if classname.match?(/^n[0-9]/)