ariadne_view_components 0.0.6 → 0.0.7

data/lib/ariadne/classify/validation.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "utilities"
-
-module Ariadne
-  class Classify
-    # :nodoc:
-    class Validation
-      INVALID_CLASS_NAME_PREFIXES = /box-shadow-|box_shadow-/
-
-      class << self
-        def invalid?(class_name)
-          class_name.start_with?(INVALID_CLASS_NAME_PREFIXES) || Ariadne::Classify::Utilities.supported_selector?(class_name)
-        end
-      end
-    end
-  end
-end

data/lib/ariadne/classify.rb

@@ -1,124 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "classify/utilities"
-require_relative "classify/validation"
-
-require "tailwind_merge"
-
-module Ariadne
-  # :nodoc:
-  class Classify
-    FLEX_VALUES = [1, :auto].freeze
-
-    FLEX_WRAP_MAPPINGS = {
-      wrap: "flex-wrap",
-      nowrap: "flex-nowrap",
-      reverse: "flex-wrap-reverse",
-    }.freeze
-
-    FLEX_ALIGN_SELF_VALUES = [:auto, :start, :end, :center, :baseline, :stretch].freeze
-
-    FLEX_DIRECTION_VALUES = [:column, :column_reverse, :row, :row_reverse].freeze
-
-    FLEX_JUSTIFY_CONTENT_VALUES = [:flex_start, :flex_end, :center, :space_between, :space_around].freeze
-
-    FLEX_ALIGN_ITEMS_VALUES = [:flex_start, :flex_end, :center, :baseline, :stretch].freeze
-
-    LOOKUP = Ariadne::Classify::Utilities::UTILITIES
-
-    class << self
-      # Utility for mapping component configuration into Tailwind CSS class names.
-      #
-      # args can contain utility keys that mimic the interface used by
-      # Ariadne components, as well as the special entries :classes
-      # and :style.
-      #
-      # Returns a hash containing two entries. The :classes entry is a string of
-      # Tailwind CSS class names, including any classes given in the :classes entry
-      # in args. The :style entry is the value of the given :style entry given in
-      # args.
-      #
-      #
-      # Example usage:
-      # extract_css_attrs({ mt: 4, py: 2 }) => { classes: "mt-4 py-2", style: nil }
-      # extract_css_attrs(classes: "d-flex", mt: 4, py: 2) => { classes: "d-flex mt-4 py-2", style: nil }
-      # extract_css_attrs(classes: "d-flex", style: "float: left", mt: 4, py: 2) => { classes: "d-flex mt-4 py-2", style: "float: left" }
-      #
-      def call(args)
-        style = nil
-        args = [] if args.blank?
-
-        classes = [].tap do |result|
-          args.each do |key, val|
-            case key
-            when :classes
-              # insert :classes first to avoid huge doc diffs
-              if (class_names = validated_class_names(val))
-                result.unshift(class_names)
-              end
-              next
-            when :style
-              style = val
-              next
-            end
-
-            next unless LOOKUP[key]
-
-            if val.is_a?(Array)
-              # A while loop is ~3.5x faster than Array#each.
-              brk = 0
-              while brk < val.size
-                item = val[brk]
-
-                if item.nil?
-                  brk += 1
-                  next
-                end
-
-                # Believe it or not, three calls to Hash#[] and an inline rescue
-                # are about 30% faster than Hash#dig. It also ensures validate is
-                # only called when necessary, i.e. when the class can't be found
-                # in the lookup table.
-                # rubocop:disable Style/RescueModifier
-                found = (LOOKUP[key][item][brk] rescue nil) || validate(key, item, brk)
-                # rubocop:enable Style/RescueModifier
-                result << found if found
-                brk += 1
-              end
-            else
-              next if val.nil?
-
-              # rubocop:disable Style/RescueModifier
-              found = (LOOKUP[key][val][0] rescue nil) || validate(key, val, 0)
-              # rubocop:enable Style/RescueModifier
-              result << found if found
-            end
-          end
-        end.join(" ")
-
-        result = {}
-
-        result[:class] = classes if classes.present?
-        result[:style] = style if style.present?
-
-        result
-      end
-
-      private def validate(key, val, brk)
-        brk_str = Ariadne::Classify::Utilities::BREAKPOINTS[brk]
-        Ariadne::Classify::Utilities.validate(key, val, brk_str)
-      end
-
-      private def validated_class_names(classes)
-        return if classes.blank?
-
-        # TODO: obviously instantiate this
-        TailwindMerge::Merger.new.merge(classes)
-      end
-
-      private def raise_on_invalid_options?
-        Rails.application.config.ariadne_view_components.raise_on_invalid_options
-      end
-    end
-  end
-end

data/lib/rubocop/cop/ariadne/ariadne_heroicon.rb

@@ -1,252 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-require "ariadne/classify/utilities"
-require "ariadne/classify/validation"
-
-# :nocov:
-module RuboCop
-  module Cop
-    module Ariadne
-      # This cop ensures that components use System Arguments instead of CSS classes.
-      #
-      # bad
-      # heroicon(icon: :icon, variant: HeroiconsHelper::Icon::VARIANT_OUTLINE)
-      # heroicon(icon: "icon", variant: HeroiconsHelper::Icon::VARIANT_OUTLINE)
-      # heroicon(icon: "icon-with-dashes")
-      # heroicon(icon: @ivar)
-      # heroicon(icon: condition > "icon" : "other-icon")
-      #
-      # good
-      # ariadne_heroicon(icon: :icon, variant: HeroiconsHelper::Icon::VARIANT_OUTLINE)
-      # ariadne_heroicon(icon: :"icon-with-dashes", variant: HeroiconsHelper::Icon::VARIANT_OUTLINE)
-      # ariadne_heroicon(icon: @ivar, variant: HeroiconsHelper::Icon::VARIANT_OUTLINE)
-      # ariadne_heroicon(icon: condition > "icon" : "other-icon", variant: HeroiconsHelper::Icon::VARIANT_OUTLINE)
-      class AriadneHeroicon < RuboCop::Cop::Cop
-        INVALID_MESSAGE = <<~STR
-          Replace the `heroicon` helper with `ariadne_heroicon`. See https://ariadne.style/view-components/components/heroicon for details.
-        STR
-
-        ICON_ATTRIBUTES = ["icon", "variant"].freeze
-        SIZE_ATTRIBUTES = ["height", "width", "size"].freeze
-        STRING_ATTRIBUTES = ["aria-", "data-"].freeze
-        REST_ATTRIBUTES = ["title"].freeze
-        VALID_ATTRIBUTES = [*ICON_ATTRIBUTES, *SIZE_ATTRIBUTES, *STRING_ATTRIBUTES, *REST_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 == :heroicon
-          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 heroicon_size_attributes(kwargs) == INVALID_ATTRIBUTE
-
-          # find class pair
-          classes = classes(kwargs)
-
-          return if classes == INVALID_ATTRIBUTE
-
-          # check if classes are convertible
-          if classes.present?
-            attributes = ::Ariadne::Classify::Utilities.classes_to_hash(classes)
-            invalid_classes = (attributes[:classes]&.split(" ") || []).select { |class_name| ::Ariadne::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)
-            icon_and_variant = transform_icon_and_variant(kwargs)
-            size_attributes = transform_sizes(kwargs)
-            rest_attributes = rest_args(kwargs)
-
-            args = arguments_as_string(node, icon_and_variant, size_attributes, rest_attributes, classes)
-
-            if node.dot?
-              corrector.replace(node.loc.expression, "#{node.receiver.source}.ariadne_heroicon(#{args})")
-            else
-              corrector.replace(node.loc.expression, "ariadne_heroicon(#{args})")
-            end
-          end
-        end
-
-        private def transform_icon_and_variant(kwargs)
-          kwargs.pairs.each_with_object({}) do |pair, h|
-            next unless ICON_ATTRIBUTES.include?(pair.key.value.to_s)
-
-            # We only support symbol or string values...
-            h[pair.key.value] = case pair.value.type
-            when :str
-              { value: pair.value.value.to_s, type: :str }
-            when :sym
-              { value: pair.value.source.to_sym, type: :sym }
-            else # ... but calling source will also get when you want, for :const, :if, etc.
-              { value: pair.value.source, type: :other }
-            end
-          end
-        end
-
-        private def transform_sizes(kwargs)
-          attributes = heroicon_size_attributes(kwargs)
-
-          attributes.transform_values do |size|
-            if size.between?(10, 16)
-              ""
-            elsif size.between?(22, 26)
-              :md
-            else
-              size
-            end
-          end
-        end
-
-        private def rest_args(kwargs)
-          kwargs.pairs.each_with_object({}) do |pair, h|
-            next unless REST_ATTRIBUTES.include?(pair.key.value.to_s)
-
-            h[pair.key.value] = pair.value.source
-          end
-        end
-
-        private def heroicon_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
-
-        private 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
-
-        private def arguments_as_string(node, icon_and_variant, size_attributes, rest_attributes, classes)
-          icon = case icon_and_variant[:icon][:type]
-          when :str
-            "icon: \"#{icon_and_variant[:icon][:value]}\""
-          when :sym, :other
-            "icon: #{icon_and_variant[:icon][:value]}"
-          end
-          variant = case icon_and_variant[:variant][:type]
-          when :str
-            "variant: \"#{icon_and_variant[:variant][:value]}\""
-          when :sym, :other
-            "variant: #{icon_and_variant[:variant][:value]}"
-          end
-
-          args = "#{icon}, #{variant}"
-
-          size_args = size_attributes_to_string(size_attributes)
-          string_args = string_args_to_string(node)
-          rest_args = rest_args_to_string(rest_attributes)
-
-          args = "#{args}, #{size_args}" if size_args.present?
-          args = "#{args}, #{rest_args}" if rest_args.present?
-          args = "#{args}, #{utilities_args(classes)}" if classes.present?
-          args = "#{args}, #{string_args}" if string_args.present?
-
-          args
-        end
-
-        private def rest_args_to_string(attrs)
-          return if attrs.blank?
-
-          attrs.map do |key, value|
-            "#{key}: #{value}"
-          end.join(", ")
-        end
-
-        private def utilities_args(classes)
-          args = ::Ariadne::Classify::Utilities.classes_to_hash(classes)
-
-          color = case args[:color]
-          when :text_white
-            :on_emphasis
-          when Symbol
-            args[:color].to_s.gsub("text_", "icon_").to_sym
-          end
-
-          args[:color] = color if color
-
-          ::Ariadne::Classify::Utilities.hash_to_args(args)
-        end
-
-        private 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: :md" if size_attributes.values.any?(:md)
-
-          size_attributes.map do |key, value|
-            "#{key}: #{value}"
-          end.join(", ")
-        end
-
-        private 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
-
-        Kwargs = Struct.new(:keys, :pairs, :type)
-        def kwargs(node)
-          return node.arguments.last if node.arguments.size > 1
-
-          keys = node.arguments.first.keys
-          pairs = node.arguments.first.pairs
-          Kwargs.new(keys, pairs, :hash)
-        end
-
-        private 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 symbol
-          # E.g: `arrow-down` becomes `:"arrow-down"`
-          ":#{node.source}"
-        end
-      end
-    end
-  end
-end

data/lib/rubocop/cop/ariadne/component_name_migration.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-
-# :nocov:
-module RuboCop
-  module Cop
-    module Ariadne
-      # This cop ensures that components don't use deprecated component names
-      #
-      # bad
-      # Ariadne::ComponentNameComponent.new()
-      #
-      # good
-      # Ariadne::Beta::ComponentName.new()
-      class ComponentNameMigration < BaseCop
-        DEPRECATIONS = {
-          "Ariadne::TestComponent" => "Ariadne::Beta::Test",
-        }.freeze
-
-        def on_send(node)
-          return unless node.method_name == :new && !node.receiver.nil? && DEPRECATIONS.key?(node.receiver.const_name)
-
-          add_offense(node.receiver, message: "Don't use deprecated names")
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            corrector.replace(node, DEPRECATIONS[node.const_name])
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require "rubocop"
-require "ariadne/classify/utilities"
-
-# :nocov:
-module RuboCop
-  module Cop
-    module Ariadne
-      # This cop ensures that components use System Arguments instead of CSS classes.
-      #
-      # bad
-      # Component.new(classes: "mr-1")
-      #
-      # good
-      # Component.new(mr: 1)
-      class SystemArgumentInsteadOfClass < BaseCop
-        INVALID_MESSAGE = <<~STR
-          Avoid using CSS classes when you can use System Arguments: https://ariadne.style/view-components/system-arguments.
-        STR
-
-        def on_send(node)
-          return unless valid_node?(node)
-          return unless node.arguments?
-
-          # we are looking for hash arguments and they are always last
-          kwargs = node.arguments.last
-
-          return unless kwargs.type == :hash
-
-          # find classes pair
-          classes_arg = kwargs.pairs.find { |kwarg| kwarg.key.value == :classes }
-
-          return if classes_arg.nil?
-          return unless classes_arg.value.type == :str
-
-          # get actual classes
-          classes = classes_arg.value.value
-
-          attributes = ::Ariadne::Classify::Utilities.classes_to_hash(classes)
-
-          # no classes are fixable
-          return if attributes[:classes] == classes
-
-          add_offense(classes_arg, message: INVALID_MESSAGE)
-        end
-
-        def autocorrect(node)
-          lambda do |corrector|
-            args = ::Ariadne::Classify::Utilities.classes_to_args(node.value.value)
-            corrector.replace(node.loc.expression, args)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/tasks/utilities.rake

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-namespace :utilities do
-  desc "Generate CSS utility classes"
-  task :build do
-    require "yaml"
-    require "json"
-    require File.expand_path("./../../lookbook/config/environment.rb", __dir__)
-    require "ariadne/classify/utilities"
-
-    # Keys that are looked for to be included in the utilities.yml file
-    SUPPORTED_KEYS = [
-      /^anim\b/,
-      /^color-bg\b/,
-      /^color-border\b/,
-      /^color-fg\b/,
-      /^col\b/,
-      /^container\b/,
-      /^clearfix\b/,
-      /^d\b/,
-      /^float\b/,
-      /^height\b/,
-      /^hide\b/,
-      /^m[trblxy]?\b/,
-      /^p[trblxy]?\b/,
-      /^position\b/,
-      /^wb\b/,
-      /^width\b/,
-      /^v\b/,
-    ].freeze
-
-    BREAKPOINTS = [nil, "sm", "md", "lg", "xl"].freeze
-    utility_data =
-      JSON.parse(
-        File.read(
-          File.expand_path(File.join("..", "..", "node_modules", "@primer", "css", "dist", "stats", "utilities.json"), __dir__)
-        )
-      )["selectors"]["values"]
-
-    custom_utility_data = YAML.load_file(
-      File.join(__dir__, "custom_utilities.yml")
-    )
-
-    layout_data =
-      JSON.parse(
-        File.read(
-          File.expand_path(File.join("..", "..", "node_modules", "@primer", "css", "dist", "stats", "layout.json"), __dir__)
-        )
-      )["selectors"]["values"]
-
-    css_data = utility_data + layout_data
-
-    output = {}
-
-    css_data.each do |selector|
-      selector.sub!(/^./, "")
-      selector.sub!(/:[^\s]*$/, "")
-
-      # Next if selector has ancestors or sibling selectors
-      next if selector.match?(/[:><~\[.]/)
-      next unless SUPPORTED_KEYS.any? { |key| selector =~ key }
-
-      # Dupe so we still have the selector at the end of slicing it up
-      classname = selector.dup
-      key = ""
-
-      # Look for a replacement key
-      Ariadne::Classify::Utilities::REPLACEMENT_KEYS.each do |k, v|
-        next unless classname.match?(Regexp.new(k))
-
-        key = v
-        classname.sub!(Regexp.new("#{k}-"), "")
-      end
-
-      # If we didn't find a replacement, grab the first text before hyphen
-      if classname == selector
-        key = classname.split("-").first
-        classname.sub!(/^[^-]+-/, "")
-      end
-
-      # Check if the next bit of the classname is a breakpoint
-      if classname.match?(/^(sm-|md-|lg-|xl-)/)
-        breakpoint = classname.split("-").first
-        classname.sub!(/^[^-]+-/, "")
-      end
-
-      # Change the rest from hyphens to underscores
-      classname.sub!(/-/, "_")
-
-      # convert padding/margin negative values ie n7 to -7
-      classname.sub!(/^n/, "-") if classname.match?(/^n[0-9]/)
-
-      # If key and classname are equal, then classname is boolean
-      classname = true if key == classname
-
-      key = key.to_sym
-
-      if classname.is_a?(String)
-        classname = classname.match?(/\A[-+]?[0-9]+\z/) ? classname.to_i : classname.to_sym
-      end
-
-      if output[key].nil?
-        output[key] = { classname => Array.new(5, nil) }
-      elsif output[key][classname].nil?
-        output[key][classname] = Array.new(5, nil)
-      end
-
-      output[key][classname][BREAKPOINTS.index(breakpoint)] = selector
-    end
-
-    output.transform_values! do |x|
-      x.transform_values { |y| y.reverse.drop_while(&:nil?).reverse }
-    end
-
-    output.merge!(custom_utility_data)
-
-    File.open("lib/ariadne/classify/utilities.yml", "w") do |f|
-      f.puts YAML.dump(output)
-    end
-  end
-end