svelte-on-rails 0.0.18 → 0.0.21

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/svelte_on_rails/render_server_side.rb

@@ -3,11 +3,14 @@ module SvelteOnRails
 
     require 'open3'
 
-    def initialize(filename)
+    def initialize(filename, base_path: SvelteOnRails::Configuration.instance.components_folder_full)
 
-      @svelte_file = SvelteOnRails::Configuration.instance.components_folder_full + filename
+      fn = (filename.match(/\.svelte$/) ? filename[0..-8] : filename)
+      @svelte_file = base_path + filename
       @svelte_filename = filename
-      @compiled_file = "#{SvelteOnRails::Configuration.instance.dist_folder}/#{(filename.match(/\.svelte$/) ? filename[0..-8] : filename)}"
+      cnf = SvelteOnRails::Configuration.instance
+      cf = cnf.dist_folder + cnf.components_folder + fn
+      @compiled_file = cf.to_s
 
     end
 
@@ -62,7 +65,7 @@ module SvelteOnRails
 
       stdout, stderr, status = Open3.capture3(cmd, chdir: self.class.gem_app_dir)
       unless status.to_s.match(/^pid [0-9]+ exit 0$/)
-        raise "Render Svelte Server-side:\n" + stderr
+        raise "Render Svelte Server-side:\nrender.js => #{compiled_js_file}\n" + stderr
       end
 
       begin
@@ -88,13 +91,15 @@ module SvelteOnRails
 
       start_time = Time.now
 
-      dist = SvelteOnRails::Configuration.instance.dist_folder
+      cnf = SvelteOnRails::Configuration.instance
       subs = @svelte_filename.split('/')[0..-2].join('/')
+      dist = cnf.dist_folder + cnf.components_folder + subs
+
       cmd = [
         'node',
         self.class.gem_app_dir + 'compile.js',
         @svelte_file,
-        dist.join(subs),
+        dist,
         self.class.gem_app_dir
       ].join(' ')
 
@@ -112,6 +117,17 @@ module SvelteOnRails
       File.expand_path('../svelte_on_rails', __dir__) + '/'
     end
 
+    def self.file_exist_case_sensitive?(containing_dir, filename)
+      # Combine the directory path and filename
+      full_path = File.join(containing_dir, filename)
+
+      # Check if the file exists and the path matches case-sensitively
+      File.exist?(full_path) && Dir[File.join(containing_dir, "**/*")].any? do |f|
+        f == full_path
+      end
+    end
+
+    # assets:precompile
     def self.reset_dist
       unless Dir.exist?(SvelteOnRails::Configuration.instance.dist_folder)
         FileUtils.mkdir_p(SvelteOnRails::Configuration.instance.dist_folder)
@@ -120,16 +136,21 @@ module SvelteOnRails
       FileUtils.touch SvelteOnRails::Configuration.instance.dist_folder.join('reset_timestamp')
     end
 
-    def self.file_exist_case_sensitive?(containing_dir, filename)
-      # Combine the directory path and filename
-      full_path = File.join(containing_dir, filename)
+    def self.reset_and_compile_all
+      SvelteOnRails::RenderServerSide.reset_dist
+      cnf = SvelteOnRails::Configuration.instance
+      frontend_folder = cnf.frontend_folder_full
+      sveltes = Dir.glob(cnf.frontend_folder_full.join('**/*.svelte'))
+      sveltes.each_with_index do |file, ind|
+        comp_name = file.to_s[(cnf.frontend_folder_full.to_s.length + 1)..-1]
+
+        n = SvelteOnRails::RenderServerSide.new(comp_name, base_path: frontend_folder)
+        n.compile
+
+        puts "compiled #{ind + 1}/#{sveltes.length}: #{comp_name}"
 
-      # Check if the file exists and the path matches case-sensitively
-      File.exist?(full_path) && Dir[File.join(containing_dir, "**/*")].any? do |f|
-        f == full_path
       end
     end
 
-
   end
 end

data/lib/svelte_on_rails/view_helpers.rb

@@ -18,15 +18,15 @@ module SvelteOnRails
 
       # check what to do
 
-      rss = if props.key?(:render_server_side)
-              props.delete(:render_server_side)
+      rss = if props.key?(:ssr)
+              props.delete(:ssr)
             else
-              conf.render_server_side
+              conf.ssr
             end
       unless [true, false, :auto].include?(rss)
-        raise "Only true, false or auto are allowed for the argument #render_server_side"
+        raise "Only true, false or auto are allowed for the argument #ssr"
       end
-      render_server_side = (rss == :auto && request.headers['X-Turbo-Request-ID'].blank? || rss)
+      ssr = (rss == :auto && request.headers['X-Turbo-Request-ID'].blank? || rss)
 
       hydrate = if props.key?(:hydrate)
                   props[:hydrate]
@@ -37,7 +37,7 @@ module SvelteOnRails
       # separate hashes
 
       props.delete(:hydrate)
-      props.delete(:render_server_side)
+      props.delete(:ssr)
       options = props.slice(:class, :id, :style)
       props.delete(:class)
       props.delete(:id)
@@ -45,13 +45,13 @@ module SvelteOnRails
 
       # set up html
 
-      options[:class] = options[:class].to_s
-      options[:class] += ' svelte-component svelte-on-rails-not-initialized-component'
+      options[:class] = options[:class].to_s + ' svelte-component'
+      options[:class] += ' please-hydrate-me-svelte-on-rails' if hydrate
       options[:data] ||= {}
       options[:data][:props] = props.to_json
       options[:data][:svelte_component] = filename
 
-      if render_server_side
+      if ssr
 
         # render server side