ariadne_view_components 0.0.10-arm64-darwin

data/exe/tailwindcss

@@ -0,0 +1,21 @@
+#! /usr/bin/env ruby
+# frozen_string_literal: true
+
+# because rubygems shims assume a gem's executables are Ruby
+
+require "ariadne/view_components/commands"
+
+begin
+  command = [Ariadne::ViewComponents::Commands.executable, *ARGV]
+  puts command.inspect
+  if Gem.win_platform?
+    # use system rather than exec as exec inexplicably fails to find the executable on Windows
+    # see related https://github.com/rubys/sprockets-esbuild/pull/4
+    system(*command, exception: true)
+  else
+    exec(*command)
+  end
+rescue Ariadne::ViewComponents::Commands::UnsupportedPlatformException, Ariadne::ViewComponents::Commands::ExecutableNotFoundException => e
+  $stderr.puts("ERROR: " + e.message)
+  exit(1)
+end

data/lib/ariadne/view_components/commands.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require_relative "upstream"
+
+module Ariadne
+  module ViewComponents
+    # commands related to the upstream Tailwindcss project
+    module Commands
+      # raised when the host platform is not supported by upstream tailwindcss's binary releases
+      class UnsupportedPlatformException < StandardError
+      end
+
+      # raised when the tailwindcss executable could not be found where we expected it to be
+      class ExecutableNotFoundException < StandardError
+      end
+
+      class << self
+        def platform
+          [:cpu, :os].map { |m| Gem::Platform.local.send(m) }.join("-")
+        end
+
+        def executable(
+          exe_path: File.expand_path(File.join(__dir__, "..", "..", "exe"))
+        )
+          if Ariadne::ViewComponents::Upstream::NATIVE_PLATFORMS.keys.none? { |p| Gem::Platform.match(p) }
+            raise UnsupportedPlatformException, <<~MESSAGE
+              ariadne_view_components does not support the #{platform} platform
+              Please install tailwindcss following instructions at https://tailwindcss.com/docs/installation
+            MESSAGE
+          end
+
+          exe_path = Dir.glob(File.expand_path(File.join(exe_path, "*", "tailwindcss"))).find do |f|
+            Gem::Platform.match(File.basename(File.dirname(f)))
+          end
+
+          if exe_path.nil?
+            raise ExecutableNotFoundException, <<~MESSAGE
+              Cannot find the tailwindcss executable for #{platform} in #{exe_path}
+
+              If you're using bundler, please make sure you're on the latest bundler version:
+
+                  gem install bundler
+                  bundle update --bundler
+
+              Then make sure your lock file includes this platform by running:
+
+                  bundle lock --add-platform #{platform}
+                  bundle install
+
+              See `bundle lock --help` output for details.
+
+              If you're still seeing this message after taking those steps, try running
+              `bundle config` and ensure `force_ruby_platform` isn't set to `true`. See
+              https://github.com/rails/tailwindcss-rails#check-bundle_force_ruby_platform
+              for more details.
+            MESSAGE
+          end
+
+          exe_path
+        end
+
+        def compile_command(debug: false, **kwargs)
+          [
+            executable(**kwargs),
+            "-i", relative_path("app/assets/stylesheets/ariadne_view_components.css"),
+            "-o", relative_path("app/assets/builds/ariadne_view_components.css"),
+            "-c", relative_path("tailwind.config.js"),
+          ].tap do |command|
+            command << "--minify" unless debug
+          end
+        end
+
+        def watch_command(poll: false, **kwargs)
+          compile_command(**kwargs).tap do |command|
+            command << "-w"
+            command << "-p" if poll
+          end
+        end
+
+        def relative_path(path)
+          if defined?(Rails)
+            Rails.root.join(path).to_s
+          else
+            path
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ariadne/view_components/constants.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ariadne
+  module ViewComponents
+    # A module for constants that are used in the view components.
+    class Constants
+      CONSTANTS = JSON.parse(
+        File.read(
+          File.join(File.dirname(__FILE__), "../../../static/constants.json")
+        )
+      ).freeze
+
+      class << self
+        def get(component:, constant:, invert: true, symbolize: false)
+          values = CONSTANTS.dig(component, constant)
+
+          case values
+          when Hash
+            format_hash(values, invert, symbolize)
+          when Array
+            format_array(values, symbolize)
+          else
+            values
+          end
+        end
+
+        private def format_hash(values, invert, symbolize)
+          val = invert ? values.invert : values
+          # remove defaults
+          val = val.except("", nil)
+
+          return val.transform_values { |v| symbolize_value(v) } if symbolize
+
+          val
+        end
+
+        private def format_array(values, symbolize)
+          val = values.select(&:present?)
+
+          return val.map { |v| symbolize_value(v) } if symbolize
+
+          val
+        end
+
+        private def symbolize_value(value)
+          ":#{value}"
+        end
+      end
+    end
+  end
+end

data/lib/ariadne/view_components/engine.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "rails/engine"
+
+require "view_component"
+
+require "tailwind_merge"
+
+module Ariadne
+  # The Ariadne gem is a collection of ViewComponents that can be used to build
+  # accessible, responsive, and consistent UIs for Yetto.
+  module ViewComponents
+    mattr_accessor :tailwind_merger
+
+    # :nodoc:
+    class Engine < ::Rails::Engine
+      isolate_namespace Ariadne::ViewComponents
+
+      config.autoload_paths = ["#{root}/lib"]
+      config.eager_load_paths = ["#{root}/app/components", "#{root}/app/helpers", "#{root}/app/lib"]
+
+      config.ariadne_view_components = ActiveSupport::OrderedOptions.new
+
+      config.ariadne_view_components.raise_on_invalid_options = true
+      config.ariadne_view_components.silence_deprecations = false
+      config.ariadne_view_components.silence_warnings = false
+      config.ariadne_view_components.validate_class_names = true
+      config.ariadne_view_components.raise_on_invalid_aria = true
+
+      initializer "ariadne_view_components.assets" do |app|
+        app.config.assets.precompile += ["ariadne_view_components"] if app.config.respond_to?(:assets)
+      end
+
+      initializer "ariadne_view_components.importmap", before: "importmap" do |app|
+        if Rails.application.respond_to?(:importmap)
+          app.config.importmap.paths << Engine.root.join("config/importmap.rb")
+        end
+      end
+
+      initializer "ariadne_view_components.zeitwerk_ignore" do
+        Rails.autoloaders.each do |autoloader|
+          autoloader.ignore(Engine.root.join("lib", "ariadne", "view_components", "linters.rb"))
+          autoloader.ignore(Engine.root.join("lib", "ariadne", "view_components", "linters", "**", "*.rb"))
+          autoloader.ignore(Engine.root.join("lib", "ariadne", "view_components", "statuses.rb"))
+        end
+      end
+
+      config.after_initialize do |_app|
+        # TODO: is any of this necessary???
+        ActionView::Base.field_error_proc = proc do |html_tag, instance_tag|
+          fragment = Nokogiri::HTML.fragment(html_tag)
+          field = fragment.at("input,select,textarea")
+
+          model = instance_tag.object
+          error_message = model.errors.full_messages.join(", ")
+
+          html = if field
+            field["class"] = "#{field["class"]} invalid"
+            html = <<-HTML
+                      #{fragment}
+                      <p class="error">#{error_message}</p>
+            HTML
+            html
+          else
+            html_tag
+          end
+
+          html.html_safe # rubocop:disable Rails/OutputSafety
+        end
+
+        Ariadne::ViewComponents.tailwind_merger = TailwindMerge::Merger.new
+      end
+    end
+  end
+end

data/lib/ariadne/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/ariadne/view_components/statuses.rb

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

data/lib/ariadne/view_components/upstream.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Ariadne
+  module ViewComponents
+    # constants describing the upstream tailwindcss project
+    module Upstream
+      VERSION = "v3.1.8"
+
+      # rubygems platform name => upstream release filename
+      NATIVE_PLATFORMS = {
+        "arm64-darwin" => "tailwindcss-macos-arm64",
+        "x64-mingw32" => "tailwindcss-windows-x64.exe",
+        "x64-mingw-ucrt" => "tailwindcss-windows-x64.exe",
+        "x86_64-darwin" => "tailwindcss-macos-x64",
+        "x86_64-linux" => "tailwindcss-linux-x64",
+        "aarch64-linux" => "tailwindcss-linux-arm64",
+      }
+    end
+  end
+end

data/lib/ariadne/view_components/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Ariadne
+  module ViewComponents
+    VERSION = "0.0.10"
+  end
+end

data/lib/ariadne/view_components.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "ariadne/view_components/version"
+require "ariadne/view_components/engine"
+require "ariadne/view_components/constants"
+require "ariadne/view_components/commands"
+
+module Ariadne
+  # :nodoc:
+  module ViewComponents
+    DEFAULT_STATIC_PATH = File.expand_path("static")
+    FILE_NAMES = {
+      statuses: "statuses.json",
+      constants: "constants.json",
+      audited_at: "audited_at.json",
+    }.freeze
+
+    class << self
+      # generate_statuses returns a hash mapping component name to
+      # the component's status sorted alphabetically by the component name.
+      def generate_statuses
+        Ariadne::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 generate_audited_at
+        Ariadne::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 generate_constants
+        Ariadne::Component.descendants.sort_by(&:name).each_with_object({}) do |component, mem|
+          mem[component.to_s] = component.constants(false).sort.each_with_object({}) do |constant, h|
+            h[constant] = component.const_get(constant)
+          end
+        end
+      end
+
+      # dump generates the requested stat hash and outputs it to a file.
+      def 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 read(stats)
+        File.read(File.join(DEFAULT_STATIC_PATH, FILE_NAMES[stats]))
+      end
+    end
+  end
+end

data/lib/rubocop/config/default.yml

@@ -0,0 +1,8 @@
+require:
+  - rubocop/cop/ariadne
+
+AllCops:
+  DisabledByDefault: true
+
+Ariadne/NoTagMemoize:
+  Enabled: true

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "rubocop"
+require "ariadne/view_components/statuses"
+require_relative "../../../../app/lib/ariadne/view_helper"
+
+module RuboCop
+  module Cop
+    module Ariadne
+      # :nodoc:
+      class BaseCop < RuboCop::Cop::Cop
+        # We only verify SystemArguments if it's a `.new` call on a component or
+        # a ViewHeleper call.
+        def valid_node?(node)
+          return if node.nil?
+
+          view_helpers.include?(node.method_name) || (node.method_name == :new && !node.receiver.nil? && ::Ariadne::ViewComponents::STATUSES.key?(node.receiver.const_name))
+        end
+
+        private def view_helpers
+          ::Ariadne::ViewHelper::HELPERS.keys.map { |key| "ariadne_#{key}".to_sym }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "rubocop"
+
+# :nocov:
+module RuboCop
+  module Cop
+    module Ariadne
+      # This cop ensures that tags are not set with ||=
+      #
+      # bad
+      # @attributes[:tag] ||= :h1
+      #
+      # good
+      # @attributes[:tag] = fetch_or_raise(TAG_OPTIONS, tag)
+      #
+      # good
+      # @attributes[:tag] = :h2
+      # TODO: TEST THIS
+      class NoTagMemoize < RuboCop::Cop::Cop
+        INVALID_MESSAGE = <<~STR
+          Avoid `[:tag] ||=`. Instead, try one of the following:
+            - Don't allow consumers to update the tag by having a fixed tag (e.g. `attributes[:tag] = :div`)
+            - Use the `fetch_or_raise` helper to only allow a tag from a restricted list.
+        STR
+
+        def_node_search :tag_memoized?, <<~PATTERN
+          (or-asgn
+            (send
+              _
+              _
+              (sym :tag)
+            )
+            _
+          )
+        PATTERN
+
+        def on_or_asgn(node)
+          add_offense(node, message: INVALID_MESSAGE) if tag_memoized?(node)
+        end
+      end
+    end
+  end
+end

data/lib/rubocop/cop/ariadne.rb

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

data/lib/tasks/ariadne_view_components.rake

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+ERB_GLOB = "**/*.html{+*,}.erb"
+RB_GLOB = "**/*.rb"
+# copied from Rails: action_view/template/handlers/erb/erubi.rb
+BLOCK_EXPR = /\s*((\s+|\))do|\{)(\s*\|[^|]*\|)?\s*\Z/
+
+namespace :ariadne_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(".ariadne-view-components-report.json", "w") do |f|
+      f.write(JSON.pretty_generate(stats))
+      f.write($INPUT_RECORD_SEPARATOR)
+    end
+  end
+end

data/lib/tasks/build.rake

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "ariadne/view_components/commands"
+
+namespace :ariadne_view_components do
+  desc "Build Ariadne View Components CSS"
+  task :build do |_, args|
+    debug = args.extras.include?("debug")
+    command = Ariadne::ViewComponents::Commands.compile_command(debug: debug)
+    puts command.inspect
+    system(*command, exception: true)
+  end
+
+  desc "Watch and build Ariadne View Components CSS on file changes"
+  task :watch do |_, args|
+    debug = args.extras.include?("debug")
+    poll = args.extras.include?("poll")
+    command = Ariadne::ViewComponents::Commands.watch_command(debug: debug, poll: poll)
+    puts command.inspect
+    system(*command)
+  end
+end
+
+Rake::Task["assets:precompile"].enhance(["ariadne_view_components:build"]) if Rake::Task.task_defined?("assets:precompile")
+
+if Rake::Task.task_defined?("test:prepare")
+  Rake::Task["test:prepare"].enhance(["ariadne_view_components:build"])
+elsif Rake::Task.task_defined?("db:test:prepare")
+  Rake::Task["db:test:prepare"].enhance(["ariadne_view_components:build"])
+end

data/lib/tasks/coverage.rake

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+namespace :coverage do
+  desc "Run coverage report. This should ideally be done only on CI."
+  task :report do
+    require "simplecov"
+    require "simplecov-console"
+
+    SimpleCov.minimum_coverage(100)
+
+    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