quicksilver_ui 0.1.0

data/lib/generators/quicksilver_ui/component/all_generator.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module QuicksilverUI
+  module Generators
+    module Component
+      class AllGenerator < Rails::Generators::Base
+        namespace "quicksilver_ui:component:all"
+
+        class_option :force, type: :boolean, default: false
+
+        def generate_all_components
+          say "Generating all components..."
+
+          available_components.each do |component|
+            run "bin/rails generate quicksilver_ui:component #{component}#{" --force" if options["force"]}"
+          end
+        end
+
+        private
+
+        def available_components
+          Dir.glob(File.join(QuicksilverUI.ui_path, "*.rb"))
+            .map { |f| File.basename(f, ".rb") }
+            .reject { |name| name == "base" }
+            .sort
+        end
+      end
+    end
+  end
+end

data/lib/generators/quicksilver_ui/component/component_generator.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module QuicksilverUI
+  module Generators
+    class ComponentGenerator < Rails::Generators::Base
+      namespace "quicksilver_ui:component"
+
+      source_root QuicksilverUI.ui_path.to_s
+
+      def self.banner
+        "rails generate quicksilver_ui:component NAME [options]"
+      end
+
+      desc <<~DESC
+        Generate a QuicksilverUI component into your application.
+
+        Available components:
+      DESC
+
+      def self.desc(description = nil)
+        return super if description
+
+        components = Dir.glob(File.join(QuicksilverUI.ui_path, "*.rb"))
+          .map { |f| File.basename(f, ".rb") }
+          .reject { |n| n == "base" }
+          .sort
+          .map { |c| "  #{c}" }
+          .join("\n")
+
+        "#{super}\n#{components}"
+      end
+
+      argument :component_name, type: :string, required: true
+      class_option :force, type: :boolean, default: false
+
+      def generate_component
+        if component_not_found?
+          say "Component not found: #{component_name}", :red
+          say ""
+          say "Available components:", :green
+          available_components.each { |c| say "  - #{c}" }
+          exit 1
+        end
+
+        say "Generating #{component_name} component..."
+      end
+
+      def add_gems
+        all_gems.each do |gem_name|
+          unless gem_installed?(gem_name)
+            say "Adding #{gem_name} to Gemfile...", :yellow
+            run "bundle add #{gem_name}"
+          end
+        end
+      end
+
+      def copy_component_files
+        all_components.each do |name|
+          paths = file_paths_for(name)
+          paths.each do |file_path|
+            relative = Pathname.new(file_path).relative_path_from(self.class.source_root)
+            copy_file file_path, Rails.root.join("app/views/ui", relative), force: options["force"]
+          end
+        end
+      end
+
+      def copy_stylesheets
+        all_stylesheets.each do |name|
+          source = File.join(QuicksilverUI.stylesheets_path, "#{name}.css")
+          next unless File.exist?(source)
+
+          dest = Rails.root.join("app/assets/tailwind", "#{name}.css")
+          copy_file source, dest, force: options["force"]
+          add_css_import(name)
+        end
+      end
+
+      def copy_controllers
+        all_controllers.each do |name|
+          source = File.join(QuicksilverUI.javascript_controllers_path, "#{name}_controller.js")
+          next unless File.exist?(source)
+
+          copy_file source, Rails.root.join("app/javascript/controllers", "#{name}_controller.js"), force: options["force"]
+        end
+      end
+
+      def copy_mixins
+        all_mixins.each do |name|
+          source = File.join(QuicksilverUI.javascript_mixins_path, "#{name}.js")
+          next unless File.exist?(source)
+
+          copy_file source, Rails.root.join("app/javascript/mixins", "#{name}.js"), force: options["force"]
+        end
+      end
+
+      def done
+        say ""
+        say "#{component_name} component generated!", :green
+
+        deps = all_components - [component_folder_name]
+        if deps.any?
+          say "  Dependencies copied: #{deps.join(", ")}", :cyan
+        end
+      end
+
+      private
+
+      def all_components
+        @all_components ||= QuicksilverUI.resolve_dependencies(component_folder_name)
+      end
+
+      def all_stylesheets
+        all_components.flat_map { |name| QuicksilverUI::DEPENDENCIES.dig(name, :stylesheets) || [] }.uniq
+      end
+
+      def all_controllers
+        all_components.flat_map { |name| QuicksilverUI::DEPENDENCIES.dig(name, :controllers) || [] }.uniq
+      end
+
+      def all_mixins
+        all_components.flat_map { |name| QuicksilverUI::DEPENDENCIES.dig(name, :mixins) || [] }.uniq
+      end
+
+      def all_gems
+        all_components.flat_map { |name| QuicksilverUI::DEPENDENCIES.dig(name, :gems) || [] }.uniq
+      end
+
+      def gem_installed?(name)
+        Gem::Specification.find_all_by_name(name).any?
+      end
+
+      def add_css_import(name)
+        app_css = Rails.root.join("app/assets/tailwind/application.css")
+        import_line = "@import \"./#{name}.css\" layer(affordances);"
+
+        if File.exist?(app_css)
+          content = File.read(app_css)
+          return if content.include?(import_line)
+
+          # Insert after the last existing @import line
+          lines = content.lines
+          last_import_index = lines.rindex { |l| l.start_with?("@import") }
+
+          if last_import_index
+            lines.insert(last_import_index + 1, "#{import_line}\n")
+          else
+            lines.unshift("#{import_line}\n")
+          end
+
+          File.write(app_css, lines.join)
+        else
+          create_file app_css, "#{import_line}\n"
+        end
+
+        say "  Added import for #{name}.css to application.css", :green
+      end
+
+      def component_not_found?
+        !File.exist?(component_file_path) && !Dir.exist?(component_folder_path)
+      end
+
+      def component_folder_name
+        component_name.underscore
+      end
+
+      def component_file_path
+        File.join(self.class.source_root, "#{component_folder_name}.rb")
+      end
+
+      def component_folder_path
+        File.join(self.class.source_root, component_folder_name)
+      end
+
+      def file_paths_for(name)
+        paths = []
+        file = File.join(self.class.source_root, "#{name}.rb")
+        folder = File.join(self.class.source_root, name)
+
+        paths << file if File.exist?(file)
+        paths.concat Dir.glob(File.join(folder, "**/*.rb")) if Dir.exist?(folder)
+        paths
+      end
+
+      def available_components
+        Dir.glob(File.join(self.class.source_root, "*.rb"))
+          .map { |f| File.basename(f, ".rb") }
+          .reject { |name| name == "base" }
+          .sort
+      end
+    end
+  end
+end

data/lib/generators/quicksilver_ui/form/all_generator.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module QuicksilverUI
+  module Generators
+    module Form
+      class AllGenerator < Rails::Generators::Base
+        namespace "quicksilver_ui:form:all"
+
+        class_option :force, type: :boolean, default: false
+
+        def generate_all_form_components
+          say "Generating all form components..."
+
+          available_form_components.each do |component|
+            run "bin/rails generate quicksilver_ui:form #{component}#{" --force" if options["force"]}"
+          end
+        end
+
+        private
+
+        def available_form_components
+          Dir.glob(File.join(QuicksilverUI.form_path, "*.rb"))
+            .map { |f| File.basename(f, ".rb") }
+            .reject { |name| name == "base_tag" }
+            .sort
+        end
+      end
+    end
+  end
+end

data/lib/generators/quicksilver_ui/form/form_generator.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module QuicksilverUI
+  module Generators
+    class FormGenerator < Rails::Generators::Base
+      namespace "quicksilver_ui:form"
+
+      source_root QuicksilverUI.form_path.to_s
+
+      def self.banner
+        "rails generate quicksilver_ui:form NAME [options]"
+      end
+
+      desc <<~DESC
+        Generate a QuicksilverUI form component into your application.
+
+        Available form components:
+      DESC
+
+      def self.desc(description = nil)
+        return super if description
+
+        components = Dir.glob(File.join(QuicksilverUI.form_path, "*.rb"))
+          .map { |f| File.basename(f, ".rb") }
+          .reject { |n| n == "base_tag" }
+          .sort
+          .map { |c| "  #{c}" }
+          .join("\n")
+
+        "#{super}\n#{components}"
+      end
+
+      argument :form_component_name, type: :string, required: true
+      class_option :force, type: :boolean, default: false
+
+      def generate_form_component
+        if form_component_not_found?
+          say "Form component not found: #{form_component_name}", :red
+          say ""
+          say "Available form components:", :green
+          available_form_components.each { |c| say "  - #{c}" }
+          exit 1
+        end
+
+        say "Generating #{form_component_name} form component..."
+      end
+
+      def add_gems
+        all_gems.each do |gem_name|
+          unless gem_installed?(gem_name)
+            say "Adding #{gem_name} to Gemfile...", :yellow
+            run "bundle add #{gem_name}"
+          end
+        end
+      end
+
+      def copy_form_component_files
+        all_form_components.each do |name|
+          source = File.join(self.class.source_root, "#{name}.rb")
+          next unless File.exist?(source)
+
+          copy_file source, Rails.root.join("app/views/form", "#{name}.rb"), force: options["force"]
+        end
+      end
+
+      def copy_stylesheets
+        all_stylesheets.each do |name|
+          source = File.join(QuicksilverUI.stylesheets_path, "#{name}.css")
+          next unless File.exist?(source)
+
+          dest = Rails.root.join("app/assets/tailwind", "#{name}.css")
+          copy_file source, dest, force: options["force"]
+          add_css_import(name)
+        end
+      end
+
+      def copy_form_builder
+        source = File.join(templates_path, "app_form_builder.rb")
+        dest = Rails.root.join("app/helpers/app_form_builder.rb")
+        copy_file source, dest, force: options["force"]
+      end
+
+      def copy_form_helper
+        source = File.join(templates_path, "app_form_helper.rb")
+        dest = Rails.root.join("app/helpers/app_form_helper.rb")
+        copy_file source, dest, force: options["force"]
+      end
+
+      def done
+        say ""
+        say "#{form_component_name} form component generated!", :green
+
+        deps = all_form_components - [file_name]
+        if deps.any?
+          say "  Dependencies copied: #{deps.join(", ")}", :cyan
+        end
+      end
+
+      private
+
+      def all_form_components
+        @all_form_components ||= QuicksilverUI.resolve_form_dependencies(file_name)
+      end
+
+      def all_stylesheets
+        all_form_components.flat_map { |name| QuicksilverUI::FORM_DEPENDENCIES.dig(name, :stylesheets) || [] }.uniq
+      end
+
+      def all_gems
+        all_form_components.flat_map { |name| QuicksilverUI::FORM_DEPENDENCIES.dig(name, :gems) || [] }.uniq
+      end
+
+      def gem_installed?(name)
+        Gem::Specification.find_all_by_name(name).any?
+      end
+
+      def add_css_import(name)
+        app_css = Rails.root.join("app/assets/tailwind/application.css")
+        import_line = "@import \"./#{name}.css\" layer(affordances);"
+
+        if File.exist?(app_css)
+          content = File.read(app_css)
+          return if content.include?(import_line)
+
+          lines = content.lines
+          last_import_index = lines.rindex { |l| l.start_with?("@import") }
+
+          if last_import_index
+            lines.insert(last_import_index + 1, "#{import_line}\n")
+          else
+            lines.unshift("#{import_line}\n")
+          end
+
+          File.write(app_css, lines.join)
+        else
+          create_file app_css, "#{import_line}\n"
+        end
+
+        say "  Added import for #{name}.css to application.css", :green
+      end
+
+      def form_component_not_found?
+        !File.exist?(File.join(self.class.source_root, "#{file_name}.rb"))
+      end
+
+      def templates_path
+        File.join(File.dirname(__FILE__), "templates")
+      end
+
+      def file_name
+        form_component_name.underscore
+      end
+
+      def available_form_components
+        Dir.glob(File.join(self.class.source_root, "*.rb"))
+          .map { |f| File.basename(f, ".rb") }
+          .reject { |name| name == "base_tag" }
+          .sort
+      end
+    end
+  end
+end

data/lib/generators/quicksilver_ui/form/templates/app_form_builder.rb

@@ -0,0 +1,39 @@
+class AppFormBuilder < ActionView::Helpers::FormBuilder
+  delegate :render, to: :@template
+
+  def self.with_blank_error_proc(&block)
+    old_error_proc = ActionView::Base.field_error_proc
+    begin
+      ActionView::Base.field_error_proc = proc do |tag, instance|
+        tag
+      end
+      block.call
+    ensure
+      ActionView::Base.field_error_proc = old_error_proc
+    end
+  end
+
+  def group(method, options = {})
+    render Form::Group.new(form: self, method:, type: options[:type] || :text, **options.except(:type))
+  end
+
+  def text_field(method, options = {})
+    render Form::TextField.new(form: self, method:, **options)
+  end
+
+  def label(method, text = nil, options = {}, &block)
+    render Form::Label.new(form: self, method:, text:, **options)
+  end
+
+  def hint(method, text = nil, options = {}, &block)
+    render Form::Hint.new(form: self, method:, text:, **options)
+  end
+
+  def error(method, text = nil, options = {}, &block)
+    render Form::Error.new(form: self, method:, text:, **options)
+  end
+
+  def submit(value = nil, options = {})
+    super(value, options.with_defaults(class: "ui-button ui-button-primary"))
+  end
+end

data/lib/generators/quicksilver_ui/form/templates/app_form_helper.rb

@@ -0,0 +1,7 @@
+module AppFormHelper
+  def app_form_with(*, **, &)
+    AppFormBuilder.with_blank_error_proc do
+      form_with(*, builder: AppFormBuilder, **, &)
+    end
+  end
+end

data/lib/generators/quicksilver_ui/install/install_generator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+
+module QuicksilverUI
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      namespace "quicksilver_ui:install"
+
+      source_root File.expand_path("templates", __dir__)
+
+      def add_gems
+        %w[phlex-rails literal tailwind_merge].each do |gem_name|
+          unless gem_installed?(gem_name)
+            say "Adding #{gem_name} to Gemfile...", :yellow
+            run "bundle add #{gem_name}"
+          end
+        end
+      end
+
+      def create_initializer
+        template "initializer.rb", Rails.root.join("config/initializers/quicksilver_ui.rb")
+      end
+
+      def create_base_component
+        template "base.rb", Rails.root.join("app/views/ui/base.rb")
+      end
+
+      def done
+        say ""
+        say "Quicksilver UI installed successfully!", :green
+        say "Run `bin/rails g quicksilver_ui:component Alert` to generate a component.", :green
+      end
+
+      private
+
+      def gem_installed?(name)
+        Gem::Specification.find_all_by_name(name).any?
+      end
+    end
+  end
+end

data/lib/generators/quicksilver_ui/install/templates/base.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class UI::Base < Phlex::HTML
+  TAILWIND_MERGER = ::TailwindMerge::Merger.new.freeze unless defined?(TAILWIND_MERGER)
+
+  extend Literal::Properties
+  include Phlex::Rails::Helpers::Routes
+  include Phlex::Rails::Helpers::ClassNames
+  include Phlex::Rails::Helpers::LinkTo
+
+  if Rails.env.development?
+    def before_template
+      comment { "Before #{self.class.name}" }
+      super
+    end
+  end
+
+  prop :class, _Nilable(String)
+  prop :data, Hash, default: {}.freeze, reader: :private
+
+  private
+
+  def classes
+    TAILWIND_MERGER.merge [default_classes, @class].join(" ")
+  end
+
+  def default_classes
+  end
+end

data/lib/generators/quicksilver_ui/install/templates/initializer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module UI
+  extend Phlex::Kit
+end
+
+# Look for Phlex components in the views folder
+Rails.autoloaders.main.push_dir(
+  Rails.root.join("app/views")
+)
+
+# Add a folder specifically for UI components, that are generalized and
+# reusable, like modals and accordions.
+Rails.autoloaders.main.push_dir(
+  Rails.root.join("app/views/ui"), namespace: UI
+)