terrazzo 0.6.0 → 0.7.0

data/lib/generators/terrazzo/eject/eject_generator.rb

@@ -1,8 +1,11 @@
 require "rails/generators"
+require_relative "../views/generated_defaults_helper"
 
 module Terrazzo
   module Generators
     class EjectGenerator < Rails::Generators::Base
+      include Views::GeneratedDefaultsHelper
+
       source_root File.expand_path("../views/templates", __dir__)
 
       argument :target, type: :string,
@@ -22,9 +25,11 @@ module Terrazzo
         when "pages"
           eject_page
         when "navigation"
+          raise_unknown_target unless target == "navigation"
+
           eject_navigation
         else
-          say_status :error, "Unknown category '#{category}'. Use fields/, components/, ui/, pages/, or navigation", :red
+          raise_unknown_target
         end
       end
 
@@ -42,13 +47,17 @@ module Terrazzo
         options[:namespace]
       end
 
+      def raise_unknown_target
+        raise Thor::Error,
+          "Unknown ejection target '#{target}'. Use fields/, components/, ui/, pages/, or navigation"
+      end
+
       def eject_field
         field_type = component_name
         source_dir = "fields/#{field_type}"
 
         unless File.directory?(File.join(self.class.source_root, source_dir))
-          say_status :error, "Unknown field type '#{field_type}'", :red
-          return
+          raise Thor::Error, "Unknown field type '#{field_type}'"
         end
 
         %w[IndexField.jsx ShowField.jsx FormField.jsx].each do |file|
@@ -57,25 +66,29 @@ module Terrazzo
           copy_file source, "app/views/#{namespace_name}/fields/#{field_type}/#{file}"
         end
 
-        # Copy shared dependencies if needed
-        if field_uses_shared?(field_type)
-          copy_file "fields/shared/TextInputFormField.jsx",
-            "app/views/#{namespace_name}/fields/shared/TextInputFormField.jsx"
+        field_shared_dependencies(field_type).each do |dependency|
+          copy_file_unless_exists "fields/shared/#{dependency}.jsx",
+            "app/views/#{namespace_name}/fields/shared/#{dependency}.jsx"
         end
 
+        ensure_ui_barrel
+        ensure_components_barrel
         update_fields_barrel(field_type)
       end
 
       def eject_component
         name = component_name
-        source = "components/#{name}.jsx"
 
-        unless File.exist?(File.join(self.class.source_root, source))
-          say_status :error, "Unknown component '#{name}'", :red
-          return
+        unless component_template_exists?(name)
+          raise Thor::Error, "Unknown component '#{name}'"
         end
 
-        copy_file source, "app/views/#{namespace_name}/components/#{name}.jsx"
+        copy_component_template(name)
+        component_dependencies(name).each do |component|
+          copy_component_template_unless_exists(component)
+        end
+
+        ensure_ui_barrel
         update_components_barrel(name)
       end
 
@@ -84,12 +97,15 @@ module Terrazzo
         source = "components/ui/#{name}.jsx"
 
         unless File.exist?(File.join(self.class.source_root, source))
-          say_status :error, "Unknown UI component '#{name}'", :red
-          return
+          raise Thor::Error, "Unknown UI component '#{name}'"
         end
 
-        copy_file source, "app/views/#{namespace_name}/components/ui/#{name}.jsx"
+        copy_ui_template(name)
         update_ui_barrel(name)
+
+        ui_dependencies(name).each do |component|
+          update_ui_barrel(component) if copy_ui_template_unless_exists(component)
+        end
       end
 
       def eject_page
@@ -97,142 +113,236 @@ module Terrazzo
         source = "pages/#{name}.jsx"
 
         unless File.exist?(File.join(self.class.source_root, source))
-          say_status :error, "Unknown page template '#{name}'", :red
-          return
+          raise Thor::Error, "Unknown page template '#{name}'"
         end
 
-        copy_file source, "app/views/#{namespace_name}/application/#{name}.jsx"
+        ensure_page_barrels
+        copy_file_over_generated source, "app/views/#{namespace_name}/application/#{name}.jsx",
+          generated_content: generated_page_stub(name)
+        page_dependencies(name).each do |dependency|
+          copy_file_unless_exists "pages/#{dependency}.jsx",
+            "app/views/#{namespace_name}/application/#{dependency}.jsx"
+        end
+        eject_generated_form_counterpart(name)
       end
 
       def eject_navigation
-        source = File.join(Terrazzo::Engine.root, "app/views/terrazzo/application/_navigation.json.props")
         dest = "app/views/#{namespace_name}/application/_navigation.json.props"
-        copy_file source, dest
+        copy_file_over_generated "pages/_navigation.json.props", dest,
+          generated_content: generated_navigation_partial
         say "\nNavigation partial ejected to #{dest}.", :green
         say "Edit it to customize your admin navigation."
       end
 
-      def field_uses_shared?(field_type)
-        %w[string number email url password date date_time time].include?(field_type)
-      end
-
       def update_fields_barrel(field_type)
-        barrel_path = "app/views/#{namespace_name}/fields/index.js"
-        barrel_file = File.join(destination_root, barrel_path)
-
         type_label = field_type.split("_").map(&:capitalize).join("")
+        register_name = "register#{type_label}FieldType"
         local_exports = <<~JS.strip
           // #{type_label} - ejected
-          export { IndexField as #{type_label}IndexField } from "./#{field_type}/IndexField";
-          export { ShowField as #{type_label}ShowField } from "./#{field_type}/ShowField";
-          export { FormField as #{type_label}FormField } from "./#{field_type}/FormField";
+          import { registerFieldType as #{register_name} } from "terrazzo/fields";
+          import { IndexField as #{type_label}IndexField } from "./#{field_type}/IndexField";
+          import { ShowField as #{type_label}ShowField } from "./#{field_type}/ShowField";
+          import { FormField as #{type_label}FormField } from "./#{field_type}/FormField";
+
+          #{register_name}("#{field_type}", {
+            index: #{type_label}IndexField,
+            show: #{type_label}ShowField,
+            form: #{type_label}FormField,
+          });
+
+          export { #{type_label}IndexField, #{type_label}ShowField, #{type_label}FormField };
         JS
 
-        if File.exist?(barrel_file)
-          content = File.read(barrel_file)
-
-          # If barrel is still the default re-export-all, replace with explicit exports
-          if content.include?('export * from "terrazzo/fields"')
-            new_content = build_fields_barrel_with_ejection(field_type)
-            create_file barrel_path, new_content, force: true
-          else
-            # Barrel already has explicit exports; replace the terrazzo re-export
-            # for this field type with local imports
-            unless content.include?("./#{field_type}/")
-              # Remove the existing terrazzo re-export line for this field type
-              terrazzo_export = "export { #{type_label}IndexField, #{type_label}ShowField, #{type_label}FormField } from \"terrazzo/fields\";"
-              if content.include?(terrazzo_export)
-                new_content = content.sub(terrazzo_export, local_exports)
-                create_file barrel_path, new_content, force: true
-              else
-                append_to_file barrel_path, "\n#{local_exports}\n"
-              end
-            end
-          end
-        end
+        ensure_fields_barrel
+        append_to_barrel(fields_barrel_path, local_exports, "./#{field_type}/IndexField")
       end
 
-      def build_fields_barrel_with_ejection(ejected_field_type)
-        all_field_types = %w[
-          string text number boolean date date_time time email url password
-          select rich_text belongs_to has_many has_one polymorphic hstore
-        ]
+      def update_components_barrel(name)
+        export_name = component_export_name(name)
 
-        lines = ['export { FieldRenderer, registerFieldType } from "terrazzo/fields";', ""]
+        local_exports = if name == "Layout"
+          <<~JS.strip
+            // Layout - ejected
+            import { setLayout } from "terrazzo";
+            import { Layout } from "./Layout";
 
-        all_field_types.each do |ft|
-          label = ft.split("_").map(&:capitalize).join("")
-          if ft == ejected_field_type
-            lines << "// #{label} - ejected"
-            lines << "export { IndexField as #{label}IndexField } from \"./#{ft}/IndexField\";"
-            lines << "export { ShowField as #{label}ShowField } from \"./#{ft}/ShowField\";"
-            lines << "export { FormField as #{label}FormField } from \"./#{ft}/FormField\";"
-          else
-            lines << "export { #{label}IndexField, #{label}ShowField, #{label}FormField } from \"terrazzo/fields\";"
-          end
+            setLayout(Layout);
+
+            export { Layout };
+          JS
+        else
+          <<~JS.strip
+            // #{export_name} - ejected
+            import { registerComponent as register#{export_name}Component } from "terrazzo/components";
+            import { #{export_name} } from "./#{name}";
+
+            register#{export_name}Component("#{export_name}", #{export_name});
+
+            export { #{export_name} } from "./#{name}";
+          JS
         end
 
-        lines.join("\n") + "\n"
+        ensure_components_barrel
+        append_to_barrel(components_barrel_path, local_exports, "./#{name}")
       end
 
-      def update_components_barrel(name)
-        barrel_path = "app/views/#{namespace_name}/components/index.js"
-        barrel_file = File.join(destination_root, barrel_path)
-
-        return unless File.exist?(barrel_file)
+      def update_ui_barrel(name)
+        local_exports = ui_component_exports(name)
+        ensure_ui_barrel
+        append_to_barrel(ui_barrel_path, "// #{name} - ejected\nexport { #{local_exports} } from \"./#{name}\";", "./#{name}")
+      end
 
-        content = File.read(barrel_file)
-        if content.include?('export * from "terrazzo/components"')
-          export_name = component_export_name(name)
-          new_content = build_components_barrel_with_ejection(name, export_name)
-          create_file barrel_path, new_content, force: true
+      def component_export_name(file_name)
+        case file_name
+        when "app-sidebar" then "AppSidebar"
+        when "site-header" then "SiteHeader"
+        else file_name
         end
       end
 
-      def build_components_barrel_with_ejection(ejected_name, export_name)
-        all_components = {
-          "Layout" => "Layout",
-          "app-sidebar" => "AppSidebar",
-          "site-header" => "SiteHeader",
-          "FlashMessages" => "FlashMessages",
-          "SearchBar" => "SearchBar",
-          "Pagination" => "Pagination",
-          "SortableHeader" => "SortableHeader",
-        }
-
-        lines = []
-        all_components.each do |file_name, export|
-          if file_name == ejected_name
-            lines << "export { #{export} } from \"./#{file_name}\"; // ejected"
-          else
-            lines << "export { #{export} } from \"terrazzo/components\";"
+      def component_template_exists?(name)
+        File.exist?(File.join(self.class.source_root, "components/#{name}.jsx"))
+      end
+
+      def copy_component_template(name)
+        copy_file "components/#{name}.jsx", "app/views/#{namespace_name}/components/#{name}.jsx"
+      end
+
+      def copy_component_template_unless_exists(name)
+        copy_file_unless_exists "components/#{name}.jsx", "app/views/#{namespace_name}/components/#{name}.jsx"
+      end
+
+      def copy_ui_template(name)
+        copy_file "components/ui/#{name}.jsx", "app/views/#{namespace_name}/components/ui/#{name}.jsx"
+      end
+
+      def copy_ui_template_unless_exists(name)
+        destination = "app/views/#{namespace_name}/components/ui/#{name}.jsx"
+        existed = File.exist?(File.join(destination_root, destination))
+        copy_file_unless_exists "components/ui/#{name}.jsx", destination
+        !existed
+      end
+
+      def eject_generated_form_counterpart(name)
+        counterpart = { "edit" => "new", "new" => "edit" }[name]
+        return unless counterpart
+
+        destination = "app/views/#{namespace_name}/application/#{counterpart}.jsx"
+        return unless generated_file?(destination, generated_page_stub(counterpart))
+
+        copy_file "pages/#{counterpart}.jsx", destination, force: true
+      end
+
+      def field_shared_dependencies(field_type)
+        field_template_paths(field_type).flat_map do |path|
+          relative_imports(File.read(path)).filter_map do |specifier|
+            next unless specifier.start_with?("../shared/")
+
+            dependency = File.basename(specifier, ".*")
+            next unless template_exists?("fields/shared/#{dependency}.jsx")
+
+            dependency
           end
-        end
+        end.uniq
+      end
 
-        lines.join("\n") + "\n"
+      def component_dependencies(name)
+        template_dependencies("components/#{name}.jsx", "components")
       end
 
-      def update_ui_barrel(name)
-        barrel_path = "app/views/#{namespace_name}/components/ui/index.js"
+      def page_dependencies(name)
+        template_dependencies("pages/#{name}.jsx", "pages")
+      end
+
+      def ui_dependencies(name)
+        template_dependencies("components/ui/#{name}.jsx", "components/ui")
+      end
+
+      def template_dependencies(template, template_root, seen = [])
+        template_path = File.join(self.class.source_root, template)
+        return [] unless File.exist?(template_path)
+
+        relative_imports(File.read(template_path)).flat_map do |specifier|
+          next unless specifier.start_with?("./")
+
+          dependency = File.basename(specifier.delete_prefix("./"), ".*")
+          dependency_template = "#{template_root}/#{dependency}.jsx"
+          next unless template_exists?(dependency_template)
+          next if seen.include?(dependency)
+
+          [dependency, *template_dependencies(dependency_template, template_root, seen + [dependency])]
+        end.compact.uniq
+      end
+
+      def field_template_paths(field_type)
+        Dir[File.join(self.class.source_root, "fields", field_type, "*.jsx")]
+      end
+
+      def relative_imports(source)
+        source.scan(/from\s+["']([^"']+)["']/).flatten
+      end
+
+      def template_exists?(template)
+        File.exist?(File.join(self.class.source_root, template))
+      end
+
+      def ui_component_exports(name)
+        ui_barrel_template = File.read(File.join(self.class.source_root, "components/ui/index.js"))
+        match = ui_barrel_template.match(/^export\s*\{(?<exports>[^}]*)\}\s*from\s*["']\.\/#{Regexp.escape(name)}["'];/m)
+        raise Thor::Error, "Could not find UI exports for '#{name}'" unless match
+
+        match[:exports].split(",").map(&:strip).reject(&:empty?).join(", ")
+      end
+
+      def ensure_barrel(barrel_path, package_export)
         barrel_file = File.join(destination_root, barrel_path)
 
-        return unless File.exist?(barrel_file)
+        unless File.exist?(barrel_file)
+          create_file barrel_path, "#{package_export}\n"
+          return
+        end
 
         content = File.read(barrel_file)
-        if content.include?('export * from "terrazzo/ui"')
-          new_content = "export * from \"terrazzo/ui\";\n"
-          new_content += "// Override ejected UI component:\n"
-          new_content += "export * from \"./#{name}\";\n"
-          create_file barrel_path, new_content, force: true
-        end
+        return if content.include?(package_export)
+
+        prepend_to_file barrel_path, "#{package_export}\n"
       end
 
-      def component_export_name(file_name)
-        case file_name
-        when "app-sidebar" then "AppSidebar"
-        when "site-header" then "SiteHeader"
-        else file_name
-        end
+      def ensure_page_barrels
+        ensure_fields_barrel
+        ensure_components_barrel
+        ensure_ui_barrel
+      end
+
+      def ensure_fields_barrel
+        ensure_barrel(fields_barrel_path, 'export * from "terrazzo/fields";')
+      end
+
+      def ensure_components_barrel
+        ensure_barrel(components_barrel_path, 'export * from "terrazzo/components";')
+      end
+
+      def ensure_ui_barrel
+        ensure_barrel(ui_barrel_path, 'export * from "terrazzo/ui";')
+      end
+
+      def fields_barrel_path
+        "app/views/#{namespace_name}/fields/index.js"
+      end
+
+      def components_barrel_path
+        "app/views/#{namespace_name}/components/index.js"
+      end
+
+      def ui_barrel_path
+        "app/views/#{namespace_name}/components/ui/index.js"
+      end
+
+      def append_to_barrel(barrel_path, content, marker)
+        barrel_file = File.join(destination_root, barrel_path)
+        return if File.exist?(barrel_file) && File.read(barrel_file).include?(marker)
+
+        append_to_file barrel_path, "\n#{content}\n"
       end
     end
   end

data/lib/generators/terrazzo/field/field_generator.rb

@@ -10,7 +10,7 @@ module Terrazzo
 
       def create_field_class
         template "field.rb.erb",
-          "app/fields/#{file_name}_field.rb"
+          "app/fields/terrazzo/field/#{file_name}.rb"
       end
 
       def create_jsx_components
@@ -21,18 +21,32 @@ module Terrazzo
       end
 
       def register_in_barrel
-        barrel_path = File.join(destination_root, "app/views/#{namespace_name}/fields/index.js")
-        return unless File.exist?(barrel_path)
+        ensure_fields_barrel
+        ensure_ui_barrel
 
+        barrel_path = "app/views/#{namespace_name}/fields/index.js"
+        barrel_file = File.join(destination_root, barrel_path)
+        return if File.read(barrel_file).include?("./#{file_name}/IndexField")
+
+        register_name = "register#{class_name}FieldType"
         registration = <<~JS
 
           // #{class_name} - custom field
-          export { IndexField as #{class_name}IndexField } from "./#{file_name}/IndexField";
-          export { ShowField as #{class_name}ShowField } from "./#{file_name}/ShowField";
-          export { FormField as #{class_name}FormField } from "./#{file_name}/FormField";
+          import { registerFieldType as #{register_name} } from "terrazzo/fields";
+          import { IndexField as #{class_name}IndexField } from "./#{file_name}/IndexField";
+          import { ShowField as #{class_name}ShowField } from "./#{file_name}/ShowField";
+          import { FormField as #{class_name}FormField } from "./#{file_name}/FormField";
+
+          #{register_name}("#{file_name}", {
+            index: #{class_name}IndexField,
+            show: #{class_name}ShowField,
+            form: #{class_name}FormField,
+          });
+
+          export { #{class_name}IndexField, #{class_name}ShowField, #{class_name}FormField };
         JS
 
-        append_to_file "app/views/#{namespace_name}/fields/index.js", registration
+        append_to_file barrel_path, registration
 
         say "\nCustom field '#{file_name}' registered in fields/index.js.", :green
         say "Use it in your dashboard:"
@@ -44,6 +58,36 @@ module Terrazzo
       def namespace_name
         options[:namespace]
       end
+
+      def ensure_fields_barrel
+        barrel_path = "app/views/#{namespace_name}/fields/index.js"
+        barrel_file = File.join(destination_root, barrel_path)
+
+        unless File.exist?(barrel_file)
+          create_file barrel_path, %(export * from "terrazzo/fields";\n)
+          return
+        end
+
+        content = File.read(barrel_file)
+        return if content.include?('export * from "terrazzo/fields";')
+
+        prepend_to_file barrel_path, %(export * from "terrazzo/fields";\n)
+      end
+
+      def ensure_ui_barrel
+        barrel_path = "app/views/#{namespace_name}/components/ui/index.js"
+        barrel_file = File.join(destination_root, barrel_path)
+
+        unless File.exist?(barrel_file)
+          create_file barrel_path, %(export * from "terrazzo/ui";\n)
+          return
+        end
+
+        content = File.read(barrel_file)
+        return if content.include?('export * from "terrazzo/ui";')
+
+        prepend_to_file barrel_path, %(export * from "terrazzo/ui";\n)
+      end
     end
   end
 end

data/lib/generators/terrazzo/field/templates/FormField.jsx.erb

@@ -1,5 +1,5 @@
 import React from "react";
-import { Input, Label } from "terrazzo/ui";
+import { Input, Label } from "../../components/ui";
 
 export function FormField({ attribute, label, value, input, required }) {
   return (
@@ -9,9 +9,8 @@ export function FormField({ attribute, label, value, input, required }) {
       </Label>
       <Input
         type="text"
-        id={input.id}
-        name={input.name}
         defaultValue={value ?? ""}
+        {...input}
       />
     </div>
   );