svelte-on-rails 0.0.20 → 0.0.21

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 06d39c6909bc770f4cef89091d1ac17566715996aa7425afe29e847072691ee0
-  data.tar.gz: ca26182656cd9e27bd3a4f9f6d6e58e5e283b625d06a6133b9fd196c369c4306
+  metadata.gz: 4760a8d0ae7d7de9e8bfb08b82e6cc7ff830979ef1297001606ab9a6eb282bff
+  data.tar.gz: 49ba7cbb917e62092d1997a4d39b1815d43a71546d78c5c5e52845e95a4c2d7e
 SHA512:
-  metadata.gz: 3ac18b72caf1f4b64c960423690d4d62dbb9a456edca7337ceb49044b5efa920d5ea728886721dd10818fc2d0be7019af3bc9005ff8e9609017655f21a9e004c
-  data.tar.gz: 7e355580850438267e99bc8eef9077968860813e55f3de90f2b1d451c59ddb68fd1ca99381dec3e44b84232ac8d488f5628a01ab6248ac158e02a33b3936de1b
+  metadata.gz: 4a3774a457cb886ff0854393857aea33b0c067cb814f72a94bad40c7beb4265018544370b1df2e5c6968daf35df9318897dcc666e16e595e8108f1e04c63547a
+  data.tar.gz: b35eabfabd993155ced5ad68f90f9c8795e9520234312f142bd42c25c98b5fe16ebddec50c230879df72a144c13c31e3ace74a9cbaee7681264f4707e658c613

data/README.md

@@ -2,7 +2,7 @@
 
 Seamless and robust Svelte in Rails integration.
 
-By default, and when installed together with hotwired/turbo, it renders
+By default, and when installed together with `@hotwired/turbo-rails`, it renders
 svelte components on first request server side («SSR») and for subsequent
 requests it provides a empty tag that will be mounted on the frontend by the associated npm package [@csedl/svelte-on-rails](https://www.npmjs.com/package/@csedl/svelte-on-rails) on the frontend.
 
@@ -34,17 +34,33 @@ If you have issues, please open one and contributors are welcome!
 - svelte v5 (see: [how to install svelte on rails/vite](https://dev.to/chmich/setup-inertia-and-svelte-on-rails-7-3glk))
 - turbo (recommended / [how to install turbo on rails](https://github.com/hotwired/turbo-rails?tab=readme-ov-file#installation))
 
-## Setup from cero
+## Installation from cero
+
+together with haml, vite, svelte and turbo
 
 If you want to start from a new rails app, follow theese tutorials
 
-- [Create a new rails app with vite_rails](https://dev.to/chmich/setup-vite-on-rails-7-f1i)
-  - create a controller and a view and you should see `Vite ⚡️ Rails` on the browser console.
-  - make sure vite is on its latest version, sometimes you have to `npm i vite@latest`
-- [Setup Svelte](https://dev.to/chmich/setup-inertia-and-svelte-on-rails-7-3glk)
-  - and restart the app
+```bash
+rails new my-test-app --skip-javascript
+```
+
+within the app path do
+
+```bash
+bundle add svelte-on-rails
+```
+
+and run the fat installer
 
-## Installation
+```bash
+rails svelte_on_rails:install_haml_vite
+```
+
+this installer guides you through and if you answer all with yes, 
+at the end, you just have to (re-) start your server
+and you will see a Svelte component!
+
+## Minimal Installation
 
 within the app folder
 
@@ -52,14 +68,11 @@ within the app folder
 bundle add svelte-on-rails
 ```
 ```bash
-rails svelte_on_rails:install_for_vite_and_turbo
+rails svelte_on_rails:install
 ```
 
-
 This will create a little config file, installs the npm package,
 creates a initializer file and adds the import statement on `appplication.js` entrypoint file
-and it adds a HelloWorld.svelte component.
-If not installed, it installs `@hotwired/turbo-rails` too.
 
 #### Minimal installer
 
@@ -69,7 +82,13 @@ There is also a minimal installer:
 rails svelte_on_rails:install
 ```
 
-that does nothing else than creating a config file.
+that does:
+
+- creating a config file.
+- installs the npm package
+
+please follow the instructions on [@csedl/svelte-on-rails](https://www.npmjs.com/package/@csedl/svelte-on-rails)
+for setup the workflow
 
 Within the config file, there are mainly two important tags:
 
@@ -161,6 +180,26 @@ or you want to see the state before hydration, for development purposes, you can
 the `hydrate: false` option to the view helper, 
 and no hydration will happen for this component.
 
+## More rake tasks
+
+This tasks are more for testing/playground purposes
+
+```bash
+rails svelte_on_rails:add_hello_world
+```
+
+```bash
+rails svelte_on_rails:remove_hello_world
+```
+
+```bash
+rails svelte_on_rails:reset_and_compile_all
+```
+
+This does the same step that ist triggered together with the
+`rails assets:precompile` step together with the deployment pipeline:
+it removes all contents of the svelte-on-rails compiled 
+assets and compiles them all new.
 
 ## Performance
 

data/lib/svelte-on-rails.rb

@@ -2,7 +2,16 @@ require "svelte_on_rails/configuration"
 require "svelte_on_rails/view_helpers"
 require "svelte_on_rails/render_server_side"
 require "svelte_on_rails/railtie" if defined?(Rails)
-require 'svelte_on_rails/installer_utils'
+
+# installer
+require 'svelte_on_rails/installer/utils'
+require 'svelte_on_rails/installer/haml'
+require 'svelte_on_rails/installer/gem_utils'
+require 'svelte_on_rails/installer/vite'
+require 'svelte_on_rails/installer/svelte'
+require 'svelte_on_rails/installer/npm'
+require 'svelte_on_rails/installer/javascript'
+require 'svelte_on_rails/installer/hello_world'
 
 module SvelteOnRails
   class << self

data/lib/svelte_on_rails/installer/gem_utils.rb

@@ -0,0 +1,36 @@
+module SvelteOnRails
+
+  module GemUtils
+
+    def self.check_gem_version(gem_name)
+      gl = File.read(Rails.root.join('Gemfile.lock'))
+      regex = /(?<=#{Regexp.escape(gem_name)})[<>=\(~0-9\. \),]+/
+      match = gl.match(regex)
+
+      if match
+        match.to_s.gsub('(','').gsub(')','').strip
+      end
+
+    end
+
+    def self.install_gem(gem_name, group: nil)
+      v = check_gem_version(gem_name)
+      if v
+        puts "Gem #{gem_name} already installed, version: #{v} "
+      else
+        cmd = [
+          "bundle add #{gem_name}",
+          (group ? "--group=#{group}" : nil)
+        ].compact.join(' ')
+        stdout, stderr, status = Open3.capture3(cmd)
+        if stderr.present?
+          raise stderr
+        else
+          puts "Installed #{gem_name} version #{check_gem_version(gem_name)}"
+        end
+      end
+    end
+
+
+  end
+end

data/lib/svelte_on_rails/installer/haml.rb

@@ -0,0 +1,109 @@
+module SvelteOnRails
+  module Installer
+    module Haml
+      def self.install_haml_and_convert
+
+        # install haml-rails
+
+        puts '-' * 80
+
+        gu = SvelteOnRails::GemUtils
+        gu.install_gem('haml-rails')
+
+        # check existing files
+
+        existing_haml_files = Dir.glob('app/views/**/*.haml').select { |f| File.file? f }
+
+        overwrite_files = []
+        files = Dir.glob('app/views/**/*.html.erb').each_with_object([]) do |f, ary|
+          new_file = f.gsub(/\.erb\z/, '.haml')
+          if File.file? new_file
+            overwrite_files += [new_file]
+            existing_haml_files.delete(new_file)
+          end
+          if File.file? f
+            ary << [
+              f,
+              new_file
+            ]
+          end
+        end
+
+        if files.empty?
+          puts "No .erb files found, no conversion necessary."
+          return
+        end
+
+        # ask if haml already exist
+
+        if existing_haml_files.any?
+          puts '-' * 80
+          begin
+            puts "Theare are already .haml files:"
+            puts existing_haml_files
+            puts "Would you like to continue? (y/n)"
+            continue = STDIN.gets.chomp.downcase[0]
+          end until ['y', 'n'].include?(continue)
+          if continue == 'n'
+            puts 'skipping convert to haml'
+            return
+          end
+        end
+
+        # ask if overwrite
+
+        if overwrite_files.any?
+          puts '-' * 80
+          begin
+            puts "The following files already exist and would be overwritten:"
+            puts overwrite_files
+            puts "Would you like to overwrite these .haml files? (y/n)"
+            should_overwrite = STDIN.gets.chomp.downcase[0]
+          end until ['y', 'n'].include?(should_overwrite)
+        end
+
+        puts '-' * 80
+
+        # check for html2haml
+
+        installed_html2haml = false
+        if gu.check_gem_version('html2haml')
+          puts "html2haml already installed, now converting..."
+        else
+          gu.install_gem('html2haml', group: 'development')
+          installed_html2haml = true
+        end
+
+        # convert
+
+        backup_dir = "svelte_on_rails_backup_views_#{Time.now.strftime('%Y%m%d_%H%M%S')}"
+        FileUtils.mkdir_p(backup_dir)
+
+        Dir.chdir(Rails.root) do
+          files.each do |f|
+            stdout, stderr, status = Open3.capture3("html2haml #{f.join(' ')}")
+            if stderr.present?
+              raise stderr
+            else
+              view_dir = File.dirname(f.first).to_s.match(/(?<=app\/views\/)(.*)/).to_s
+              backup_view_dir = backup_dir + '/' + view_dir
+              FileUtils.mkdir_p(backup_view_dir)
+              FileUtils.mv(f.first, backup_view_dir)
+              puts "Converted #{f.join(' => ')}"
+            end
+          end
+        end
+
+        if installed_html2haml
+          system("bundle remove html2haml")
+          if $?.success?
+            puts "cleanup: removed html2haml from Gemfile"
+          else
+            puts "ERROR: failed to remove html2haml (please remove manually as it was only installed for this task)"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/svelte_on_rails/installer/hello_world.rb

@@ -0,0 +1,57 @@
+module SvelteOnRails
+  module Installer
+    module HelloWorld
+
+      def self.install_hello_world
+        utils_i = SvelteOnRails::Installer::Utils
+
+        # write templates
+
+        templates = %w[
+          app/controllers/svelte_on_rails_hello_world_controller.rb
+          app/views/svelte_on_rails_hello_world/index.haml
+          app/frontend/javascript/components/SvelteOnRailsHelloWorld.svelte
+        ]
+        utils_i.write_templates(templates)
+
+        # route
+
+        route = 'svelte_on_rails_hello_world#index'
+        rr = utils_i.which_root_route
+        root_url = "/"
+        url = root_url + route.sub('#', '/')
+
+        if rr && rr == route
+          puts "Root route «#{route}» already exists, skipping."
+          root_url
+        elsif rr && utils_i.route_exists?(route.sub('#', '/'))
+          puts "route «#{route}» already exists, skipping."
+          url
+        elsif rr
+          utils_i.add_route("  get \"#{route.sub('#', '/')}\"")
+          url
+        else
+          utils_i.add_route('  root "svelte_on_rails_hello_world#index"')
+          root_url
+        end
+
+      end
+
+      def self.remove_hello_world
+
+        utils = SvelteOnRails::Installer::Utils
+        if utils.ask_yn('Remove the Hello World component?')
+          files = %w[
+            app/views/svelte_on_rails_hello_world/index.haml
+            app/views/svelte_on_rails_hello_world
+            app/controllers/svelte_on_rails_hello_world_controller.rb
+            app/frontend/javascript/components/SvelteOnRailsHelloWorld.svelte
+          ]
+          utils.remove_files(files)
+          utils.remove_line_from_file('config/routes.rb', 'svelte_on_rails_hello_world')
+        end
+      end
+
+    end
+  end
+end

data/lib/svelte_on_rails/installer/javascript.rb

@@ -0,0 +1,55 @@
+module SvelteOnRails
+  module Installer
+    module Javascript
+
+      # check if import statement already exists and, if not, append it after the last import statement of that file
+      #
+
+      def self.append_import_statement(file_path, package_name_for_test_existence, import_statement)
+
+        # Read the file content
+        content = File.read(file_path)
+
+        # Split content into lines
+        lines = content.lines
+
+        already_exist = []
+        lines.each do |line|
+          if line.match(/^\s*import\s+.*['"]#{package_name_for_test_existence}['";].*$/)
+            already_exist.push(line)
+          end
+        end
+
+        if already_exist.present?
+          puts "skipping: #{import_statement} already exists in #{File.basename(file_path)}, found: «#{already_exist.join(' // ').strip}»."
+        else
+
+          # Find the index of the last import statement
+          last_import_index = -1
+          lines.each_with_index do |line, index|
+            if line.match?(/^\s*import\s+.*$/)
+              last_import_index = index
+            end
+          end
+
+          # Insert the import statement after the last import
+          if last_import_index >= 0
+            lines.insert(last_import_index + 1, import_statement)
+          else
+            # If no import statements, add at the beginning
+            lines.unshift(import_statement)
+          end
+
+          # Write the modified content back to the file
+          begin
+            File.write(file_path, lines.map{|l|l.gsub(/\n/, '')}.join("\n"))
+            puts "Successfully inserted «#{import_statement}» into '#{file_path}'"
+          rescue => e
+            raise "Error writing to #{file_path} => «#{e.message}»"
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/svelte_on_rails/installer/npm.rb

@@ -0,0 +1,90 @@
+module SvelteOnRails
+  module Installer
+    module Npm
+
+      def self.install_or_update_package(package_name, minimal_version: nil, update_to_latest: true)
+        pkg = inspect_package(package_name)
+        to_do = !check_version((pkg ? pkg[:version] : nil), minimal_version)
+        if to_do
+
+          cmd = if update_to_latest
+                  "npm install #{package_name}@latest"
+                else
+                  raise "ERROR: not implemented"
+                end
+
+          stdout, stderr, status = Open3.capture3(cmd)
+          if stderr.present?
+            raise "ERROR #{cmd} => #{stderr}"
+          end
+
+          notice = [
+            (pkg ? "Updated" : "Installed"),
+            package_name,
+            (pkg ? "from version #{pkg[:version].join('.')}" : nil),
+            (pkg ? "to" : nil),
+            "@latest"
+          ].compact.join(' ')
+
+          puts notice
+
+        else
+          min_str = minimal_version.present? ? ", required: >= #{minimal_version.join('.')}" : ''
+          puts "#{package_name} already installed (#{pkg[:version].join('.')}#{min_str}), skipping."
+        end
+      end
+
+      def self.inspect_package(package_name)
+        pkg = nil
+        version = nil
+
+        if File.exist?('package-lock.json')
+          pl = JSON.parse(File.read('package-lock.json'))
+          unless pl['packages']
+            raise "ERROR: package-lock.json found, but no packages found, seems to be corrupted."
+          end
+          pkg = pl['packages'].keys.grep(/\/#{package_name}$/).first
+          version = pl['packages'][pkg]['version'] if pkg
+        end
+
+        if pkg
+          {
+            type: pkg.match(/^.*?(?=\/[^\/]*$)/).to_s,
+            version: version.split('.').map(&:to_i)
+          }
+        end
+
+      end
+
+      def self.check_version(current_version, minimal_version)
+        if !current_version
+          return false
+        elsif !minimal_version.present?
+          return true
+        else
+          compare_version_arrays(current_version, minimal_version)
+        end
+      end
+
+      private
+
+      def self.compare_version_arrays(current_version, minimal_version)
+        raise "ERROR: current_version must be an array" unless current_version.is_a?(Array)
+        raise "ERROR: minimal_version must be an array" unless current_version.is_a?(Array)
+
+        current_version.each_with_index do |v, i|
+          raise "ERROR: current_version entries must be an integer" unless v.is_a?(Integer)
+
+          if minimal_version[i]
+            raise "ERROR: minimal_version entries must be an integer" unless minimal_version[i].is_a?(Integer)
+            if v < minimal_version[i]
+              return false
+            end
+          end
+        end
+        true
+      end
+
+    end
+  end
+end

data/lib/svelte_on_rails/installer/rails_template/app/controllers/svelte_on_rails_hello_world_controller.rb

@@ -0,0 +1,6 @@
+class SvelteOnRailsHelloWorldController < ApplicationController
+
+  def index
+  end
+
+end

data/lib/svelte_on_rails/installer/rails_template/app/frontend/initializers/svelte.js

@@ -0,0 +1,18 @@
+
+import { initializeSvelteComponents, cleanupSvelteComponents } from '@csedl/svelte-on-rails';
+
+const components = import.meta.glob('/javascript/components/**/*.svelte', { eager: true });
+const componentsRoot = '/javascript/components';
+
+// Initialize Svelte components
+initializeSvelteComponents(componentsRoot, components, true);
+
+// Turbo event listener for page load
+document.addEventListener('turbo:load', () => {
+    initializeSvelteComponents(componentsRoot, components, true);
+});
+
+// Turbo event listener for cleanup before page cache
+document.addEventListener('turbo:before-cache', () => {
+    cleanupSvelteComponents(false);
+});

data/lib/svelte_on_rails/installer/rails_template/app/frontend/javascript/components/SvelteOnRailsHelloWorld.svelte

@@ -0,0 +1 @@
+<h1>Hello Svelte</h1>

data/lib/svelte_on_rails/installer/rails_template/app/views/svelte_on_rails_hello_world/index.haml

@@ -0,0 +1,3 @@
+%h1 Hello
+
+= svelte_component "SvelteOnRailsHelloWorld"

data/lib/svelte_on_rails/installer/rails_template/config/svelte_on_rails.yml

@@ -0,0 +1,23 @@
+frontend_folder: "app/frontend"
+# the entrypoint that is your web root, example for vite: where @ points to
+# relative to Rails.root
+
+components_folder: "javascript/components"
+# relative to frontend_folder
+# where your svelte components are located
+
+ssr: :auto
+# options: true, false, :auto
+# :auto: render server side if request is initial request (works only with turbo, because it checks for the X-Turbo-Request-ID header)
+# when not server-side rendered the components must be built as custom elements, see node-package @csedl/svelte-on-rails
+
+development:
+  watch_changes: true
+  # Check on every request if any file within the svelte components folder have changed, for recompiling
+  # Case sensitive path checking, even the file system is case insensitive
+  # Make sure this ist set to tue for development and test, but not for production
+
+test:
+  watch_changes: true
+
+production:

data/lib/svelte_on_rails/installer/svelte.rb

@@ -0,0 +1,22 @@
+module SvelteOnRails
+  module Installer
+    module Svelte
+
+      def self.install_svelte
+        puts '-' * 80
+
+        # check npm package version
+
+        npm_i = SvelteOnRails::Installer::Npm
+        npm_i.install_or_update_package('svelte', minimal_version: [5])
+
+        # configure vite
+
+        vite_i = SvelteOnRails::Installer::Vite
+        vite_i.configure_for_svelte
+
+      end
+
+    end
+  end
+end

data/lib/svelte_on_rails/installer/utils.rb

@@ -0,0 +1,328 @@
+module SvelteOnRails
+
+  module Installer
+
+    module Utils
+      def self.install_npm_package
+        package_name = "@csedl/svelte-on-rails@latest"
+        puts "Installing #{package_name} via npm..."
+
+        if system("npm install #{package_name}")
+          puts "#{package_name} successfully installed."
+        else
+          abort "Failed to install #{package_name}. Please ensure npm is installed and try running 'npm install #{package_name}' manually."
+        end
+      end
+
+      def self.install_turbo
+
+        pkg_js = Rails.root.join("package.json")
+        package_name = "@hotwired/turbo-rails"
+        file_content = File.exist?(pkg_js) ? File.read(pkg_js) : ""
+
+        if file_content.match?(/#{package_name}/)
+          puts "#{package_name} is already present in package.json, assuming that it is set up well and working."
+        else
+          puts "Installing #{package_name} via npm..."
+          if system("npm install #{package_name}")
+            puts "#{package_name} successfully installed."
+            add_line_to_file(Rails.root.join("app", "frontend", "entrypoints", "application.js"), "import '#{package_name}';")
+          else
+            abort "Failed to install #{package_name}. Please ensure npm is installed and try running 'npm install #{package_name}' manually."
+          end
+        end
+
+      end
+
+      def self.create_folder(folder)
+        if Dir.exist?(folder)
+          puts "Folder already exists: #{folder}"
+        else
+          FileUtils.mkdir_p(folder)
+          puts "Created folder: #{folder}"
+        end
+      end
+
+      def self.add_line_to_file(file_path, line)
+        file_content = File.exist?(file_path) ? File.read(file_path) : ""
+
+        if file_content.match?(/#{line}/)
+          puts "#{line} already present in #{file_path}, nothing changed here."
+          return
+        end
+
+        File.open(file_path, 'a') do |file|
+          file.puts(line)
+        end
+        puts "added #{line} to #{file_path}."
+      rescue StandardError => e
+        puts "Error: #{e.message}"
+      end
+
+      def self.create_file(file_path)
+
+        unless File.exist?(file_path)
+          FileUtils.touch(file_path)
+          puts "Created empty file at file://#{file_path}"
+        end
+      end
+
+      def self.create_javascript_initializer
+        config_path = Rails.root.join("app", "frontend", "initializers", "svelte.js")
+        if File.exist?(config_path)
+          puts "Initializer already exists: file://#{config_path}"
+        else
+          File.write(config_path, <<~JAVASCRIPT)
+
+            import { initializeSvelteComponents, cleanupSvelteComponents } from '@csedl/svelte-on-rails';
+
+            const components = import.meta.glob('/javascript/components/**/*.svelte', { eager: true });
+            const componentsRoot = '/javascript/components';
+
+            // Initialize Svelte components
+            initializeSvelteComponents(componentsRoot, components, true);
+
+            // Turbo event listener for page load
+            document.addEventListener('turbo:load', () => {
+                initializeSvelteComponents(componentsRoot, components, true);
+            });
+
+            // Turbo event listener for cleanup before page cache
+            document.addEventListener('turbo:before-cache', () => {
+                cleanupSvelteComponents(false);
+            });
+          JAVASCRIPT
+          puts "Created initializer file at file://#{config_path}"
+        end
+      end
+
+      def self.create_svelte_hello_world
+        file_path = Rails.root.join("app", "frontend", "javascript", "components", "HelloWorld.svelte")
+        if File.exist?(file_path)
+          puts "Hello World file already exists: file://#{file_path}"
+        else
+          File.write(file_path, <<~HTML)
+            <script>
+                export let items
+                let count = 0;
+
+                function increment() {
+                    count += 1;
+                }
+            </script>
+
+            <h1>Greetings from svelte</h1>
+
+            <button on:click={increment}>Increment: {count}</button>
+            <ul>
+                {#each items as item}
+                    <li>{item}</li>
+                {/each}
+            </ul>
+
+            <style>
+                button {
+                    background-color: darkred;
+                    color: white;
+                    padding: 10px;
+                    border: none;
+                }
+            </style>
+          HTML
+          puts "Hello World file at file://#{file_path}"
+        end
+      end
+
+      def self.run_command(command)
+
+        Dir.chdir(Rails.root) do
+          stdout, stderr, status = Open3.capture3(command)
+          if stderr.present?
+            puts "Error running command «#{command}»:"
+            raise stderr
+          else
+            puts "#{command} => Success"
+          end
+        end
+
+      end
+
+      def self.check_file_exists(file_path)
+        unless File.exist?(file_path)
+          raise "ERROR: File not found: #{file_path}"
+        end
+      end
+
+      def self.check_folder_exists(folder_path)
+        unless File.exist?(folder_path)
+          raise "ERROR: Folder not found: #{folder_path}"
+        end
+      end
+
+      def self.check_file_not_exists(file_path)
+        if File.exist?(file_path)
+          raise "ERROR: File already exists: #{file_path}"
+        end
+      end
+
+      def self.check_folder_not_exists(folder_path)
+        if File.exist?(folder_path)
+          raise "ERROR: Folder already exists: #{folder_path}"
+        end
+      end
+
+      def self.write_templates(template_paths)
+
+        existing = template_paths.select { |p| File.exist?(p) }
+        verb = 'Created'
+
+        if existing.present?
+          begin
+            puts "#{'Template'.pluralize(existing.length)} already exists:\n#{existing.join("\n")}.\nOverwrite? (y/n)"
+            continue = STDIN.gets.chomp.downcase[0]
+          end until ['y', 'n'].include?(continue)
+          if continue == 'n'
+            puts "Skipping write #{'template'.pluralize(template_paths.length)}."
+            return
+          end
+          verb = 'Overwrote'
+        end
+
+        template_paths.each do |p|
+          source_path = File.expand_path('rails_template', __dir__) + '/' + p
+          FileUtils.mkdir_p(File.dirname(p))
+          FileUtils.cp(source_path, p)
+        end
+
+        puts "#{verb} #{'file'.pluralize(template_paths.length)}:\n#{template_paths.join("\n")}"
+      end
+
+      def self.ask_yn(question)
+        begin
+          puts "#{question} (y/n)"
+          continue = STDIN.gets.chomp.downcase[0]
+        end until ['y', 'n'].include?(continue)
+        continue == 'y'
+      end
+
+      def self.which_root_route
+
+        # Check if the root route is active (uncommented) or commented out
+
+        routes = File.read(Rails.root.join('config', 'routes.rb'))
+        m = routes.match(/^\s*root\s+['"]([^'"]+)['"]/m)
+        if m
+          m.to_s.match(/^\s*root\s*['"]([^'"]*)['"]/)[1]
+        end
+      end
+
+      def self.add_route(route)
+
+        file_path = 'config/routes.rb'
+
+        # Read the file content
+        content = File.read(file_path)
+
+        # Split content into lines
+        lines = content.lines
+
+        # Find the index of Rails.application.routes.draw do
+        ind = -1
+        lines.each_with_index do |line, i|
+          if line.match?(/^\s*Rails.application.routes.draw\s*do[\s\S]+$/)
+            ind = i
+          end
+        end
+
+        # Insert
+
+        if ind >= 0
+          lines.insert(ind + 1, route)
+        else
+          raise "ERROR: Could not find Rails.application.routes.draw do"
+        end
+
+        # Write the modified content back to the file
+        begin
+          File.write(file_path, lines.map { |l| l.gsub(/\n/, '') }.join("\n"))
+          puts "Successfully inserted «root '#{route}'» into '#{file_path}'"
+        rescue => e
+          raise "Error writing to #{file_path} => «#{e.message}»"
+        end
+
+      end
+
+      def self.route_exists?(target_route)
+
+        # check if exists
+        # Ensure the Rails environment is loaded
+        # require File.expand_path("../config/environment", __dir__)
+
+        # Get all routes from the Rails application
+        routes = Rails.application.routes.routes
+
+        # Check if the route exists
+        routes.any? do |route|
+          # Extract the path spec and remove any optional parts or constraints
+          path = route.path.spec.to_s
+          # Clean up the path to match the format (remove leading/trailing slashes, etc.)
+          cleaned_path = path.gsub(/\(.*\)/, "").gsub(/^\/|\/$/, "")
+          # Check if the cleaned path matches the target route
+          cleaned_path == target_route
+        end
+
+      end
+
+      def self.remove_files(file_paths)
+        file_paths.each do |f|
+          if File.exist?(f)
+            if File.directory?(f)
+              Dir.delete(f)
+              puts "  • Removed directory: #{f}"
+            else
+              File.delete(f)
+              puts "  • Removed file: #{f}"
+            end
+          else
+            puts "  • File/Path not found so not removed: #{f}"
+          end
+        end
+      end
+
+      def self.remove_line_from_file(file_path, string_to_find)
+
+        # Read the file content
+        content = File.read(file_path)
+
+        # Split content into lines
+        lines = content.lines
+
+        found_lines = []
+        modified_content = []
+        lines.each do |line|
+          if line.match(/^[\s\S]+#{string_to_find}[\s\S]+$/)
+            found_lines.push(line)
+          else
+            modified_content.push(line)
+          end
+        end
+
+        utils = SvelteOnRails::Installer::Utils
+        if found_lines.present? && utils.ask_yn("Remove lines\n  • #{found_lines.join("\n  • ")}\n from #{file_path}?")
+          # Write the modified content back to the file
+          begin
+            File.write(file_path, modified_content.map{|l|l.gsub(/\n/, '')}.join("\n"))
+            puts "Successfully removed #{found_lines.length} #{'line'.pluralize(found_lines.length)}."
+          rescue => e
+            raise "Error writing to #{file_path} => «#{e.message}»"
+          end
+        else
+
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/svelte_on_rails/installer/vite.rb

@@ -0,0 +1,91 @@
+module SvelteOnRails
+
+  module Installer
+
+    module Vite
+
+      def self.install_vite
+        iu = SvelteOnRails::Installer::Utils
+
+        puts '-' * 80
+
+        gu = SvelteOnRails::GemUtils
+        if gu.check_gem_version('vite_rails')
+          puts "vite_rails already installed, skipping this part."
+        else
+
+          # check non-existence
+
+          iu.check_file_not_exists('config/vite.json')
+          iu.check_file_not_exists('vite.config.ts')
+          iu.check_folder_not_exists('app/frontend')
+
+          # install
+
+          gu.install_gem('vite_rails')
+
+          Dir.chdir(Rails.root) do
+            `bundle exec vite install`
+          end
+
+        end
+
+        # check existence
+
+        iu.check_file_exists('config/vite.json')
+        iu.check_file_exists('vite.config.ts')
+        iu.check_file_exists('package.json')
+        iu.check_file_exists('package-lock.json')
+        iu.check_file_exists('app/frontend/entrypoints/application.js')
+        iu.check_folder_exists('app/frontend')
+
+        # check npm package version
+
+        ni = SvelteOnRails::Installer::Npm
+        ni.install_or_update_package('vite', minimal_version: [6, 1])
+
+      end
+
+      def self.configure_for_svelte
+
+        # add import statement
+
+        js_i = SvelteOnRails::Installer::Javascript
+        pkg = '@sveltejs/vite-plugin-svelte'
+        js_i.append_import_statement('vite.config.ts', pkg, "import {svelte} from '#{pkg}'")
+        npm_i = SvelteOnRails::Installer::Npm
+        npm_i.install_or_update_package(pkg)
+
+        # add plugin
+
+        file_content = File.read('vite.config.ts')
+
+        if file_content.match?(/svelte/)
+          puts "Svelte seams already configured in vite.config.ts, nothing changed here."
+        else
+
+          # Regex to match the plugins array and locate RubyPlugin()
+          plugins_regex = /(plugins:\s*\[\s*)(\s*)RubyPlugin\(\),\s*([^]]*?\])/m
+
+          # Check if plugins array with RubyPlugin exists
+          unless file_content.match?(plugins_regex)
+            puts "Error: No plugins array with RubyPlugin() found in the input."
+            return file_content
+          end
+
+          # Insert svelte({}), after RubyPlugin() with proper indentation
+          modified_content = file_content.gsub(plugins_regex) do |match|
+            prefix = $1 # Start of plugins array (e.g., "plugins: [")
+            indent = '    ' # Indentation before RubyPlugin()
+            rest = $3 # Remaining plugins and closing bracket
+            "#{prefix}#{indent}RubyPlugin(),\n#{indent}svelte({}),\n#{indent}#{rest}"
+          end
+
+          File.write('vite.config.ts', modified_content)
+          puts "Updated vite.config.ts with svelte() plugin."
+        end
+      end
+
+    end
+  end
+end

data/lib/tasks/svelte_on_rails_tasks.rake

@@ -3,38 +3,108 @@ Rake::Task["assets:precompile"].enhance do
   puts "Mount Svelte: Reset dist and compile-all executed"
 end
 
-require 'svelte_on_rails/installer_utils'
+require 'svelte_on_rails/installer/utils'
+require 'svelte_on_rails/installer/haml'
+utils = SvelteOnRails::Installer::Utils
+npm_i = SvelteOnRails::Installer::Npm
+application_js_path = Rails.root.join("app", "frontend", "entrypoints", "application.js")
 
 namespace :svelte_on_rails do
-  desc "Installs SvelteOnRails YAML configuration into your Rails application"
-  task :install do
 
-    create_configuration_file
+  desc "Installs SvelteOnRails for usage together with vite_rails, haml and @hotwired/turbo-rails"
+  task :install_haml_vite => :environment do
+
+    puts '-' * 80
+    puts 'STARTING SVELTE-ON-RAILS INSTALLATION'
+
+    # svelte_on_rails
+
+    utils.write_templates(['config/svelte_on_rails.yml'])
+    npm_i.install_or_update_package('@csedl/svelte-on-rails')
+    # insert_initializer
+    uts = SvelteOnRails::Installer::Utils
+    uts.write_templates(['app/frontend/initializers/svelte.js'])
+    # add import statements
+    js_i = SvelteOnRails::Installer::Javascript
+    init_stat = '../initializers/svelte.js'
+    js_i.append_import_statement(application_js_path, init_stat, "import '#{init_stat}';")
+
+
+    # haml
+
+    haml_i = SvelteOnRails::Installer::Haml
+    haml_i.install_haml_and_convert
+
+    # vite
+
+    vite_i = SvelteOnRails::Installer::Vite
+    vite_i.install_vite
+
+    # turbo
+
+    tr_pkg = '@hotwired/turbo-rails'
 
+    npm_i.install_or_update_package(tr_pkg)
+    
+    js_i = SvelteOnRails::Installer::Javascript
+    js_i.append_import_statement(application_js_path, tr_pkg, "import '#{tr_pkg}';")
+
+    # svelte
+
+    svelte_i = SvelteOnRails::Installer::Svelte
+    svelte_i.install_svelte
+
+    # Hello World
+
+    puts '-' * 80
+    hello_world_path = nil
+    if utils.ask_yn('Do you want to install the Hello World component?')
+      hw_i = SvelteOnRails::Installer::HelloWorld
+      hello_world_path = hw_i.install_hello_world
+    end
+
+    # finish
+
+    puts '-' * 80
+    puts 'FINISHED SVELTE INSTALLATION'
+    puts '-' * 80
+
+    puts "SvelteOnRails installed successfully!"
+    puts "Restart the server and check if it all works."
+    if hello_world_path
+      puts "You can now see the Hello World component on: #{hello_world_path}."
+    end
+    puts "Happy coding!"
+    #exit
   end
 
-  desc "Installs SvelteOnRails for usage together with vite_rails and @hotwired/turbo-rails"
-  task :install_for_vite_and_turbo do
+  desc "Installs SvelteOnRails YAML configuration into your Rails application"
+  task :install do
+
+    # svelte_on_rails
 
-    iu = SvelteOnRails::InstallerUtils
+    utils.write_templates(['config/svelte_on_rails.yml'])
+    npm_i.install_or_update_package('@csedl/svelte-on-rails')
 
-    iu.create_configuration_file
+  end
 
+  desc "Removes the Hello World component"
+  task :remove_hello_world do
 
-    iu.install_npm_package
-    iu.install_turbo
+      hw_i = SvelteOnRails::Installer::HelloWorld
+      hw_i.remove_hello_world
 
-    iu.create_folder(Rails.root.join("app", "frontend", "initializers"))
-    iu.create_folder(Rails.root.join("app", "frontend", "javascript", "components"))
-    iu.add_line_to_file(Rails.root.join("app", "frontend", "entrypoints", "application.js"), "import '../initializers/svelte.js';")
+  end
 
-    iu.create_javascript_initializer
-    iu.create_svelte_hello_world
+  desc "Add the Hello World component"
+  task :add_hello_world do
 
-    puts ''
-    puts 'SvelteOnRails installed successfully for using together with vite_rails and @hotwired/turbo-rails.'
-    puts 'Restart the server and check if it all works.'
-    puts 'Happy coding!'
+    puts '-' * 80
+    if utils.ask_yn('Do you want to install the Hello World component?')
+      hw_i = SvelteOnRails::Installer::HelloWorld
+      hello_world_path = hw_i.install_hello_world
+      puts "You can now see the Hello World component on: #{hello_world_path}."
+    end
 
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: svelte-on-rails
 version: !ruby/object:Gem::Version
-  version: 0.0.20
+  version: 0.0.21
 platform: ruby
 authors:
 - Christian Sedlmair
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-04-29 00:00:00.000000000 Z
+date: 2025-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: railties
@@ -34,7 +34,19 @@ files:
 - lib/svelte-on-rails.rb
 - lib/svelte_on_rails/compile.js
 - lib/svelte_on_rails/configuration.rb
-- lib/svelte_on_rails/installer_utils.rb
+- lib/svelte_on_rails/installer/gem_utils.rb
+- lib/svelte_on_rails/installer/haml.rb
+- lib/svelte_on_rails/installer/hello_world.rb
+- lib/svelte_on_rails/installer/javascript.rb
+- lib/svelte_on_rails/installer/npm.rb
+- lib/svelte_on_rails/installer/rails_template/app/controllers/svelte_on_rails_hello_world_controller.rb
+- lib/svelte_on_rails/installer/rails_template/app/frontend/initializers/svelte.js
+- lib/svelte_on_rails/installer/rails_template/app/frontend/javascript/components/SvelteOnRailsHelloWorld.svelte
+- lib/svelte_on_rails/installer/rails_template/app/views/svelte_on_rails_hello_world/index.haml
+- lib/svelte_on_rails/installer/rails_template/config/svelte_on_rails.yml
+- lib/svelte_on_rails/installer/svelte.rb
+- lib/svelte_on_rails/installer/utils.rb
+- lib/svelte_on_rails/installer/vite.rb
 - lib/svelte_on_rails/node_modules/@ampproject/remapping/LICENSE
 - lib/svelte_on_rails/node_modules/@ampproject/remapping/README.md
 - lib/svelte_on_rails/node_modules/@ampproject/remapping/dist/remapping.mjs

data/lib/svelte_on_rails/installer_utils.rb

@@ -1,170 +0,0 @@
-module SvelteOnRails
-
-  module InstallerUtils
-    def self.install_npm_package
-      package_name = "@csedl/svelte-on-rails@latest"
-      puts "Installing #{package_name} via npm..."
-
-      if system("npm install #{package_name}")
-        puts "#{package_name} successfully installed."
-      else
-        abort "Failed to install #{package_name}. Please ensure npm is installed and try running 'npm install #{package_name}' manually."
-      end
-    end
-
-    def self.install_turbo
-
-      pkg_js = Rails.root.join("package.json")
-      package_name = "@hotwired/turbo-rails"
-      file_content = File.exist?(pkg_js) ? File.read(pkg_js) : ""
-
-      if file_content.match?(/#{package_name}/)
-        puts "#{package_name} is already present in package.json, assuming that it is set up well and working."
-      else
-        puts "Installing #{package_name} via npm..."
-        if system("npm install #{package_name}")
-          puts "#{package_name} successfully installed."
-          add_line_to_file(Rails.root.join("app", "frontend", "entrypoints", "application.js"), "import '#{package_name}';")
-        else
-          abort "Failed to install #{package_name}. Please ensure npm is installed and try running 'npm install #{package_name}' manually."
-        end
-      end
-
-    end
-
-    def self.create_folder(folder)
-      if Dir.exist?(folder)
-        puts "Folder already exists: #{folder}"
-      else
-        FileUtils.mkdir_p(folder)
-        puts "Created folder: #{folder}"
-      end
-    end
-
-    def self.create_configuration_file
-      config_path = Rails.root.join("config", "svelte_on_rails.yml")
-      if File.exist?(config_path)
-        puts "Configuration file already exists at file://#{config_path}"
-      else
-        File.write(config_path, <<~YAML)
-        
-        frontend_folder: "app/frontend" 
-        # the entrypoint that is your web root, example for vite: where @ points to
-        # relative to Rails.root
-        
-        components_folder: "javascript/components" 
-        # relative to frontend_folder
-        # where your svelte components are located
-        
-        ssr: :auto 
-        # options: true, false, :auto
-        # :auto: render server side if request is initial request (works only with turbo, because it checks for the X-Turbo-Request-ID header)
-        # when not server-side rendered the components must be built as custom elements, see node-package @csedl/svelte-on-rails
-        
-        development:
-          watch_changes: true
-          # Check on every request if any file within the svelte components folder have changed, for recompiling
-          # Case sensitive path checking, even the file system is case insensitive
-          # Make sure this ist set to tue for development and test, but not for production
-          
-        test:
-          watch_changes: true
-          
-        production:
-      YAML
-        puts "Created configuration file at file://#{config_path}"
-      end
-    end
-
-    def self.add_line_to_file(file_path, line)
-      file_content = File.exist?(file_path) ? File.read(file_path) : ""
-
-      if file_content.match?(/#{line}/)
-        puts "#{line} already present in #{file_path}, nothing changed here."
-        return
-      end
-
-      File.open(file_path, 'a') do |file|
-        file.puts(line)
-      end
-      puts "added #{line} to #{file_path}."
-    rescue StandardError => e
-      puts "Error: #{e.message}"
-    end
-
-    def self.create_file(file_path)
-
-      unless File.exist?(file_path)
-        FileUtils.touch(file_path)
-        puts "Created empty file at file://#{file_path}"
-      end
-    end
-
-
-    def self.create_javascript_initializer
-      config_path = Rails.root.join("app", "frontend", "initializers", "svelte.js")
-      if File.exist?(config_path)
-        puts "Initializer already exists: file://#{config_path}"
-      else
-        File.write(config_path, <<~JAVASCRIPT)
-
-        import { initializeSvelteComponents, cleanupSvelteComponents } from '@csedl/svelte-on-rails';
-
-        const components = import.meta.glob('/javascript/components/**/*.svelte', { eager: true });
-        const componentsRoot = '/javascript/components';
-
-        // Initialize Svelte components
-        initializeSvelteComponents(componentsRoot, components, true);
-
-        // Turbo event listener for page load
-        document.addEventListener('turbo:load', () => {
-            initializeSvelteComponents(componentsRoot, components, true);
-        });
-
-        // Turbo event listener for cleanup before page cache
-        document.addEventListener('turbo:before-cache', () => {
-            cleanupSvelteComponents(false);
-        });
-      JAVASCRIPT
-        puts "Created initializer file at file://#{config_path}"
-      end
-    end
-
-    def self.create_svelte_hello_world
-      file_path = Rails.root.join("app", "frontend", "javascript", "components", "HelloWorld.svelte")
-      if File.exist?(file_path)
-        puts "Hello World file already exists: file://#{file_path}"
-      else
-        File.write(file_path, <<~HTML)
-        <script>
-            export let items
-            let count = 0;
-        
-            function increment() {
-                count += 1;
-            }
-        </script>
-        
-        <h1>Greetings from svelte</h1>
-        
-        <button on:click={increment}>Increment: {count}</button>
-        <ul>
-            {#each items as item}
-                <li>{item}</li>
-            {/each}
-        </ul>
-        
-        <style>
-            button {
-                background-color: darkred;
-                color: white;
-                padding: 10px;
-                border: none;
-            }
-        </style>
-      HTML
-        puts "Hello World file at file://#{file_path}"
-      end
-    end
-  end
-end