sun-sword 0.0.11 → 0.0.13

data/lib/generators/sun_sword/scaffold_generator.rb

@@ -1,3 +1,11 @@
+require 'rails/generators'
+require 'active_support/inflector'
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/enumerable'
+require 'hashie'
+require 'yaml'
+require 'fileutils'
+
 module SunSword
   class ScaffoldGenerator < Rails::Generators::Base
     source_root File.expand_path('templates_scaffold', __dir__)
@@ -5,10 +13,25 @@ module SunSword
     argument :arg_structure, type: :string, default: '', banner: ''
     argument :arg_scope, type: :hash, default: '', banner: 'scope:dashboard'
 
+    class_option :engine, type: :string, default: nil, desc: 'Specify target engine name (e.g., admin, api)'
+    class_option :engine_structure, type: :string, default: nil, desc: 'Specify engine where structure file is located'
+    class_option :domain, type: :string, default: nil, desc: 'Specify domain prefix for UseCases (e.g., core)'
+
+    def validate_engine
+      return unless options[:engine]
+
+      unless engine_exists?
+        raise Thor::Error, "Engine '#{options[:engine]}' not found. Available engines: #{available_engines.join(', ')}"
+      end
+
+      say "Generating scaffold for engine: #{options[:engine]}", :cyan
+    end
+
     def running
       setup_variables
       create_root_folder
       create_controller_file
+      create_spec_files
       create_view_file
       create_link_file
     end
@@ -16,7 +39,7 @@ module SunSword
     private
 
     def setup_variables
-      config     = YAML.load_file("db/structures/#{arg_structure}_structure.yaml")
+      config     = YAML.load_file(structure_file_path)
       @structure = Hashie::Mash.new(config)
 
       # Mengambil detail konfigurasi
@@ -26,6 +49,7 @@ module SunSword
 
       @actor                = @structure.actor
       @resource_owner_id    = @structure.resource_owner_id
+      @resource_owner       = @structure.resource_owner
       @uploaders            = @structure.uploaders || []
       @search_able          = @structure.search_able || []
       @services             = @structure.domains || {}
@@ -50,6 +74,19 @@ module SunSword
       @route_scope_path = arg_scope['scope'].to_s.downcase rescue ''
       @route_scope_class = @route_scope_path.camelize rescue ''
 
+      # Engine scope support
+      @engine_structure_path = (options[:engine_structure] || options[:engine]).to_s.downcase
+      @engine_structure_class = (options[:engine_structure] || options[:engine]).to_s.camelize
+
+      @engine_scope_path = options[:engine] ? options[:engine].to_s.downcase : @route_scope_path
+      @engine_scope_class = options[:engine] ? options[:engine].to_s.camelize : @route_scope_class
+
+      # Engine mount path for view rendering
+      @engine_mount_path = options[:engine] ? options[:engine].to_s.downcase : ''
+
+      # UseCase domain prefix
+      @usecase_domain = options[:domain] ? options[:domain].to_s.camelize : @engine_structure_class
+
       @mapping_fields = {
         string:    :text_field,
         text:      :text_area,
@@ -173,25 +210,33 @@ module SunSword
     end
 
     def create_root_folder
-      empty_directory File.join('app/views', @route_scope_path.to_s, @scope_path.to_s)
+      empty_directory File.join(path_app, 'views', @engine_scope_path.to_s, @scope_path.to_s)
     end
 
     def create_controller_file
-      template 'controllers/controller.rb.tt', File.join('app/controllers', @route_scope_path.to_s, "#{@scope_path}_controller.rb")
+      template 'controllers/controller.rb.tt', File.join(path_app, 'controllers', @engine_scope_path.to_s, "#{@scope_path}_controller.rb")
+    end
+
+    def create_spec_files
+      # Controller spec - sejajar dengan controller
+      controller_path = File.join(path_app, 'controllers', @engine_scope_path.to_s)
+      template 'controllers/controller_spec.rb.tt', File.join(controller_path, "#{@scope_path}_controller_spec.rb")
+
+      say 'Controller spec created successfully!', :green
     end
 
     def create_view_file
       @form_fields_html = generate_form_fields_html
-      template 'views/_form.html.erb.tt', File.join('app/views', @route_scope_path.to_s, @scope_path.to_s, '_form.html.erb')
-      template 'views/edit.html.erb.tt', File.join('app/views', @route_scope_path.to_s, @scope_path.to_s, 'edit.html.erb')
-      template 'views/index.html.erb.tt', File.join('app/views', @route_scope_path.to_s, @scope_path.to_s, 'index.html.erb')
-      template 'views/new.html.erb.tt', File.join('app/views', @route_scope_path.to_s, @scope_path.to_s, 'new.html.erb')
-      template 'views/show.html.erb.tt', File.join('app/views', @route_scope_path.to_s, @scope_path.to_s, 'show.html.erb')
+      template 'views/_form.html.erb.tt', File.join(path_app, 'views', @engine_scope_path.to_s, @scope_path.to_s, '_form.html.erb')
+      template 'views/edit.html.erb.tt', File.join(path_app, 'views', @engine_scope_path.to_s, @scope_path.to_s, 'edit.html.erb')
+      template 'views/index.html.erb.tt', File.join(path_app, 'views', @engine_scope_path.to_s, @scope_path.to_s, 'index.html.erb')
+      template 'views/new.html.erb.tt', File.join(path_app, 'views', @engine_scope_path.to_s, @scope_path.to_s, 'new.html.erb')
+      template 'views/show.html.erb.tt', File.join(path_app, 'views', @engine_scope_path.to_s, @scope_path.to_s, 'show.html.erb')
     end
 
     def namespace_exists?
-      routes_file   = 'config/routes.rb'
-      scope_pattern = "namespace :#{@route_scope_path} do\n"
+      routes_file   = routes_file_path
+      scope_pattern = "namespace :#{@engine_scope_path} do\n"
       if File.exist?(routes_file)
         file_content = File.read(routes_file)
         file_content.include?(scope_pattern)
@@ -200,32 +245,153 @@ module SunSword
       end
     end
 
+    # Engine support methods
+    def path_app
+      engine_path ? File.join(engine_path, 'app') : 'app'
+    end
+
+    def engine_path
+      return nil unless options[:engine]
+      @engine_path ||= detect_engine_path
+    end
+
+    def detect_engine_path
+      engine_name = options[:engine]
+      possible_paths = [
+        "engines/#{engine_name}",
+        "components/#{engine_name}",
+        "gems/#{engine_name}",
+        engine_name
+      ]
+
+      possible_paths.each do |path|
+        return path if Dir.exist?(path) && File.exist?(File.join(path, "#{engine_name}.gemspec"))
+      end
+
+      nil
+    end
+
+    def engine_exists?
+      !engine_path.nil?
+    end
+
+    def available_engines
+      engines = []
+      ['engines', 'components', 'gems', '.'].each do |dir|
+        next unless Dir.exist?(dir)
+
+        Dir.glob(File.join(dir, '*')).each do |path|
+          next unless Dir.exist?(path)
+
+          engine_name = File.basename(path)
+          gemspec = File.join(path, "#{engine_name}.gemspec")
+          engines << engine_name if File.exist?(gemspec)
+        end
+      end
+      engines.uniq
+    end
+
+    def structure_file_path
+      engine_name = options[:engine_structure] || options[:engine]
+
+      if engine_name
+        structure_engine_path = detect_structure_engine_path(engine_name)
+        if structure_engine_path
+          File.join(structure_engine_path, 'db/structures', "#{arg_structure}_structure.yaml")
+        else
+          raise Thor::Error, "Structure file not found in engine '#{engine_name}'"
+        end
+      else
+        "db/structures/#{arg_structure}_structure.yaml"
+      end
+    end
+
+    def detect_structure_engine_path(engine_name)
+      possible_paths = [
+        "engines/#{engine_name}",
+        "components/#{engine_name}",
+        "gems/#{engine_name}",
+        engine_name
+      ]
+
+      possible_paths.each do |path|
+        structure_dir = File.join(path, 'db/structures')
+        return path if Dir.exist?(structure_dir)
+      end
+
+      nil
+    end
+
+    def routes_file_path
+      engine_path ? File.join(engine_path, 'config/routes.rb') : 'config/routes.rb'
+    end
+
     def create_link_file
-      partial_path = File.join('app/views/components/menu', "_link_to_#{@scope_path}.html.erb")
+      partial_path = File.join(path_app, 'views/components/menu', "_link_to_#{@scope_path}.html.erb")
       template 'views/components/menu/link.html.erb.tt', partial_path unless File.exist?(partial_path)
 
-      sidebar = 'app/views/components/layouts/_sidebar.html.erb'
+      sidebar = File.join(path_app, 'views/components/layouts/_sidebar.html.erb')
       marker  = "                <%# generate_link %>\n"
       link_to = "                <li><%= render 'components/menu/#{"link_to_#{@scope_path}"}' %></li>\n"
-      inject_into_file(sidebar, link_to, before: marker) unless File.read(sidebar).include?(link_to)
+      inject_into_file(sidebar, link_to, before: marker) if File.exist?(sidebar) && !File.read(sidebar).include?(link_to)
 
-      routes_file = 'config/routes.rb'
-      if @route_scope_path.present?
-        unless namespace_exists?
-          scope_code = "  namespace :#{@route_scope_path} do\n  end\n"
-          insert_into_file routes_file, scope_code, after: "Rails.application.routes.draw do\n" unless File.read(routes_file).include?(scope_code)
+      routes_file = routes_file_path
+
+      # Ensure routes file exists (create if needed for engine)
+      unless File.exist?(routes_file)
+        if engine_path
+          # Create routes file for engine if it doesn't exist
+          FileUtils.mkdir_p(File.dirname(routes_file))
+          # Use engine routes format: Web::Engine.routes.draw do
+          engine_class_name = options[:engine].to_s.camelize
+          engine_routes_header = "#{engine_class_name}::Engine.routes.draw do\n"
+          File.write(routes_file, "#{engine_routes_header}end\n")
+          say "Created routes file at #{routes_file}", :green
+        else
+          return # Skip if routes file doesn't exist in main app
         end
-        resource_line = "    resources :#{@scope_path}\n"
-        inject_into_file routes_file, resource_line, after: "namespace :#{@route_scope_path} do\n" unless File.read(routes_file).include?(resource_line)
+      end
+
+      routes_content = File.read(routes_file)
+
+      # Determine routes draw pattern based on engine or main app
+      has_engine = options[:engine].present?
+
+      if has_engine
+        engine_class_name = options[:engine].to_s.camelize
+        routes_draw_pattern = "#{engine_class_name}::Engine.routes.draw do\n"
+        routes_draw_pattern_alt = "#{engine_class_name}::Engine.routes.draw do"
       else
-        resource_line = "  resources :#{@scope_path}\n"
-        inject_into_file routes_file, resource_line, after: "Rails.application.routes.draw do\n" unless File.read(routes_file).include?(resource_line)
+        routes_draw_pattern = "Rails.application.routes.draw do\n"
+        routes_draw_pattern_alt = 'Rails.application.routes.draw do'
+      end
+
+      resource_line = "  resources :#{@scope_path}\n"
+
+      # Skip if resource already exists
+      return if routes_content.include?(resource_line)
+
+      begin
+        # Inject at root level (no namespace/scope)
+        if routes_content.include?(routes_draw_pattern)
+          inject_into_file routes_file, resource_line, after: routes_draw_pattern
+          say "Added routes '#{resource_line.strip}' to root level in #{routes_file}", :green
+        elsif routes_content.include?(routes_draw_pattern_alt)
+          inject_into_file routes_file, resource_line, after: routes_draw_pattern_alt
+          say "Added routes '#{resource_line.strip}' to root level in #{routes_file}", :green
+        else
+          say "Warning: Could not find routes draw pattern (#{routes_draw_pattern.strip}) in routes file: #{routes_file}", :yellow
+          say "Routes file content:\n#{routes_content}", :yellow if ENV['DEBUG']
+        end
+      rescue => e
+        say "Error adding routes to #{routes_file}: #{e.message}", :red
+        say e.backtrace.first(3).join("\n"), :red if ENV['DEBUG']
       end
     end
 
     def contract_fields
       skip_contract_fields = @skipped_fields.map(&:strip).uniq
-      @model_class.columns.reject { |column| skip_contract_fields.include?(column.name.to_s) }.map(&:name).map(&:to_s)
+      @model_class.columns.reject { |column| skip_contract_fields.include?(column.name.to_s) }.map { |column| [column.name.to_s, column.type.to_s] }
     end
 
     def strong_params
@@ -234,7 +400,10 @@ module SunSword
 
       # normalisasi jadi pasangan [name, type]
       pairs = raw_fields.map do |f|
-        if f.respond_to?(:name)
+        if f.is_a?(Array) && f.length == 2
+          # Already a tuple [name, type]
+          [f[0].to_s, f[1].to_s]
+        elsif f.respond_to?(:name)
           [f.name.to_s, f.type.to_s]
         else
           column_type = @model_class.columns_hash[f.to_s]&.type.to_s