yattho_view_components 0.0.1

data/lib/tasks/test.rake

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "rake/testtask"
+
+namespace :test do
+  desc "Run all tests"
+  task all: [
+    :components,
+    :lib,
+    :system,
+    :accessibility,
+    :performance
+  ]
+
+  Rake::TestTask.new(:single) do |t|
+    t.warning = false
+    t.libs << "test"
+    t.libs << "lib"
+    t.test_files = FileList[ENV["TEST"]]
+  end
+
+  Rake::TestTask.new(:components) do |t|
+    t.warning = false
+    t.libs << "test"
+    t.test_files = FileList[
+      "test/components/**/*_test.rb"
+    ]
+  end
+
+  Rake::TestTask.new(:component_css) do |t|
+    t.warning = false
+    t.libs << "test"
+    t.test_files = FileList[
+      "test/css/**/*_test.rb"
+    ]
+  end
+
+  Rake::TestTask.new(:lib) do |t|
+    t.warning = false
+    t.libs << "test"
+    t.libs << "lib"
+    t.test_files = FileList[
+      "test/lib/**/*_test.rb"
+    ]
+  end
+
+  Rake::TestTask.new(:system) do |t|
+    t.warning = false
+    t.libs << "test"
+    t.test_files = FileList["test/system/**/*_test.rb"]
+  end
+
+  Rake::TestTask.new(:performance) do |t|
+    t.warning = false
+    t.verbose = true
+    t.libs << "test"
+    t.test_files = FileList[
+      "test/performance/**/*_test.rb",
+      "test/performance/**/bench_*.rb"
+    ]
+  end
+
+  Rake::TestTask.new(:accessibility) do |t|
+    t.warning = false
+    t.libs << "test"
+    t.test_files = FileList["test/accessibility_test.rb"]
+  end
+
+  task :coverage do
+    require "simplecov"
+
+    SimpleCov.minimum_coverage 100
+    SimpleCov.collate Dir["coverage/.resultset.json"], "rails"
+  end
+end
+
+task :test do
+  if ENV["TEST"]
+    Rake::Task["test:single"].invoke
+  else
+    Rake::Task["test:all"].invoke
+  end
+end

data/lib/tasks/utilities.rake

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+namespace :utilities do
+  task :build do
+    require "yaml"
+    require "json"
+    ENV["RAILS_ENV"] = "test"
+    require File.expand_path("./../../demo/config/environment.rb", __dir__)
+    require "yattho/classify/utilities"
+
+    # Keys that are looked for to be included in the utilities.yml file
+    # rubocop:disable Lint/ConstantDefinitionInBlock
+    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
+    # rubocop:enable Lint/ConstantDefinitionInBlock
+
+    utility_data = JSON.parse(File.read("app/lib/yattho/css/utilities.css.json"))["selectors"]
+    layout_data = JSON.parse(File.read("app/lib/yattho/css/layout.css.json"))["selectors"]
+    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
+      Yattho::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
+
+    custom_utility_data = YAML.load_file("lib/tasks/custom_utilities.yml")
+    output.merge!(custom_utility_data)
+
+    File.open("lib/yattho/classify/utilities.yml", "w") do |f|
+      f.puts YAML.dump(output)
+    end
+  end
+end

data/lib/tasks/yattho_view_components.rake

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+ERB_GLOB = "**/*.html{+*,}.erb"
+RB_GLOB = "**/*.rb"
+BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/.freeze # copied from Rails: action_view/template/handlers/erb/erubi.rb
+
+namespace :yattho_view_components do
+  desc "Report arguments used in each component"
+  task :report, [:paths] do |_, args|
+    require "rubocop"
+    require "better_html"
+    require "better_html/parser"
+    require "erb_lint/processed_source"
+    require_relative "helpers/ast_processor"
+
+    paths = args[:paths].split
+    stats = {}
+
+    rb_files = paths.reduce([]) { |mem, path| mem + Dir[File.join(path, RB_GLOB)] }
+
+    rb_files.each do |f|
+      ast = RuboCop::AST::ProcessedSource.from_file(f, RUBY_VERSION.to_f).ast
+      AstProcessor.process_ast(ast, stats)
+    end
+
+    erb_files = paths.reduce([]) { |mem, path| mem + Dir[File.join(path, ERB_GLOB)] }
+
+    erb_files.each do |f|
+      erb_ast = ERBLint::ProcessedSource.new(f, File.read(f)).ast
+
+      erb_ast.descendants(:erb).each do |erb_node|
+        indicator, _, code_node, = *erb_node
+
+        next if indicator&.children&.first == "#" # don't analyze comments
+
+        trimmed_source = code_node.loc.source.sub(BLOCK_EXPR, "").strip
+        ast = RuboCop::AST::ProcessedSource.new(trimmed_source, RUBY_VERSION.to_f).ast
+        AstProcessor.process_ast(ast, stats)
+      end
+    end
+
+    File.open(".yattho-view-components-report.json", "w") do |f|
+      f.write(JSON.pretty_generate(stats))
+      f.write($INPUT_RECORD_SEPARATOR)
+    end
+  end
+end

data/lib/yattho/classify/utilities.rb

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require "yaml"
+
+# :nodoc:
+module Yattho
+  class Classify
+    # Handler for YatthoCSS utility classes loaded from utilities.rake
+    class Utilities
+      UTILITIES = YAML.safe_load(
+        File.read(
+          File.join(File.dirname(__FILE__), "utilities.yml")
+        ),
+        permitted_classes: [Symbol]
+      ).freeze
+
+      BREAKPOINTS = ["", "-sm", "-md", "-lg", "-xl"].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",
+        "^width" => "w",
+        "^height" => "h",
+        "^color-bg" => "bg",
+        "^color-border" => "border_color",
+        "^color-fg" => "color"
+      }.freeze
+
+      SUPPORTED_KEY_CACHE = Hash.new { |h, k| h[k] = !UTILITIES[k].nil? }
+      BREAKPOINT_INDEX_CACHE = Hash.new { |h, k| h[k] = BREAKPOINTS.index(k) }
+
+      class << self
+        attr_accessor :validate_class_names
+        alias validate_class_names? validate_class_names
+
+        def classname(key, val, breakpoint = "")
+          # For cases when `argument: false` is passed in, treat like we would nil
+          return nil unless val
+
+          if (valid = validate(key, val, breakpoint))
+            valid
+          else
+            # Get selector
+            UTILITIES[key][val][BREAKPOINT_INDEX_CACHE[breakpoint]]
+          end
+        end
+
+        # Does the Utility class support the given key
+        #
+        # returns Boolean
+        def supported_key?(key)
+          SUPPORTED_KEY_CACHE[key]
+        end
+
+        # Does the Utility class support the given key and value
+        #
+        # returns Boolean
+        def supported_value?(key, val)
+          supported_key?(key) && !UTILITIES[key][val].nil?
+        end
+
+        # Does the given selector exist in the utilities file
+        #
+        # returns Boolean
+        def supported_selector?(selector)
+          # This method is too slow to run in production
+          return false unless validate_class_names?
+
+          find_selector(selector).present?
+        end
+
+        # Is the key and value responsive
+        #
+        # returns Boolean
+        def responsive?(key, val)
+          supported_value?(key, val) && UTILITIES[key][val].count > 1
+        end
+
+        # Get the options for the given key
+        #
+        # returns Array or nil if key not supported
+        def mappings(key)
+          return unless supported_key?(key)
+
+          UTILITIES[key].keys
+        end
+
+        # Extract hash from classes ie. "mr-1 mb-2 foo" => { mr: 1, mb: 2, classes: "foo" }
+        def classes_to_hash(classes)
+          # This method is too slow to run in production
+          return { classes: classes } unless validate_class_names?
+
+          obj = {}
+          classes = classes.split
+          # Loop through all classes supplied and reject ones we find a match for
+          # So when we're at the end of the loop we have classes left with any non-system classes.
+          classes.reject! do |classname|
+            key, value, index = find_selector(classname)
+            next false if key.nil?
+
+            # Create array if nil
+            obj[key] = Array.new(5, nil) if obj[key].nil?
+            # Place the arguments in the responsive array based on index mr: [nil, 2]
+            obj[key][index] = value
+            next true
+          end
+
+          # Transform responsive arrays into arrays without trailing nil, so `mr: [1, nil, nil, nil, nil]` becomes `mr: 1`
+          obj.transform_values! do |value|
+            value = value.reverse.drop_while(&:nil?).reverse
+            if value.count == 1
+              value.first
+            else
+              value
+            end
+          end
+
+          # Add back the non-system classes
+          obj[:classes] = classes.join(" ") if classes.any?
+          obj
+        end
+
+        def classes_to_args(classes)
+          hash_to_args(classes_to_hash(classes))
+        end
+
+        def hash_to_args(hash)
+          hash.map do |key, value|
+            val = case value
+                  when Symbol
+                    ":#{value}"
+                  when String
+                    value.to_json
+                  else
+                    value
+                  end
+
+            "#{key}: #{val}"
+          end.join(", ")
+        end
+
+        def validate(key, val, breakpoint)
+          unless supported_key?(key)
+            raise ArgumentError, "#{key} is not a valid Yattho utility key" if validate_class_names?
+
+            return ""
+          end
+
+          unless breakpoint.empty? || responsive?(key, val)
+            raise ArgumentError, "#{key} does not support responsive values" if validate_class_names?
+
+            return ""
+          end
+
+          unless supported_value?(key, val)
+            if validate_class_names?
+              raise ArgumentError,
+                    "#{val} is not a valid value for :#{key}. Use one of #{mappings(key)}"
+            end
+
+            return nil if [true, false].include?(val)
+
+            return "#{key.to_s.dasherize}-#{val.to_s.dasherize}"
+          end
+
+          nil
+        end
+
+        private
+
+        def find_selector(selector)
+          key = infer_selector_key(selector)
+          value_hash = UTILITIES[key]
+
+          return nil if value_hash.blank?
+
+          # Each value hash will also contain an array of classnames for breakpoints
+          # Key argument `0`, classes `[ "mr-0", "mr-sm-0", "mr-md-0", "mr-lg-0", "mr-xl-0" ]`
+          value_hash.each do |key_argument, classnames|
+            # Skip each value hash until we get one with the selector
+            next unless classnames.include?(selector)
+
+            # Return [:mr, 0, 1]
+            # has index of classname, so we can match it up with responsive array `mr: [nil, 0]`
+            return [key, key_argument, classnames.index(selector)]
+          end
+
+          nil
+        end
+
+        def infer_selector_key(selector)
+          REPLACEMENT_KEYS.each do |k, v|
+            return v.to_sym if selector.match?(Regexp.new(k))
+          end
+          selector.split("-").first.to_sym
+        end
+      end
+    end
+  end
+end