vite_ruby 1.0.0

data/lib/vite_ruby/cli.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+
+# Public: Command line interface that allows to install the library, and run
+# simple commands.
+class ViteRuby::CLI
+  extend Dry::CLI::Registry
+
+  register 'build', Build, aliases: ['b']
+  register 'dev', Dev, aliases: %w[d serve]
+  register 'install', Install, aliases: %w[setup init]
+  register 'version', Version, aliases: ['v', '-v', '--version', 'info']
+end

data/lib/vite_ruby/cli/build.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class ViteRuby::CLI::Build < Dry::CLI::Command
+  CURRENT_ENV = ENV['RACK_ENV'] || ENV['RAILS_ENV']
+  DEFAULT_ENV = CURRENT_ENV || 'production'
+
+  def self.shared_options
+    option(:mode, default: self::DEFAULT_ENV, values: %w[development production], aliases: ['m'], desc: 'The build mode for Vite.')
+  end
+
+  desc 'Bundle all entrypoints using Vite.'
+  shared_options
+
+  def call(mode:)
+    ViteRuby.env['VITE_RUBY_MODE'] = mode
+    block_given? ? yield(mode) : ViteRuby.commands.build_from_task
+  end
+end

data/lib/vite_ruby/cli/dev.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class ViteRuby::CLI::Dev < ViteRuby::CLI::Build
+  DEFAULT_ENV = CURRENT_ENV || 'development'
+
+  desc 'Start the Vite development server.'
+  shared_options
+
+  def call(mode:, args: [])
+    super(mode: mode) { ViteRuby.run(args) }
+  end
+end

data/lib/vite_ruby/cli/install.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require 'dry/cli/utils/files'
+require 'stringio'
+require 'open3'
+
+class ViteRuby::CLI::Install < Dry::CLI::Command
+  desc 'Performs the initial configuration setup to get started with Vite Ruby.'
+
+  def call(**)
+    $stdout.sync = true
+
+    say 'Creating binstub'
+    ViteRuby.commands.install_binstubs
+
+    say 'Creating configuration files'
+    create_configuration_files
+
+    say 'Installing sample files'
+    install_sample_files
+
+    say 'Installing js dependencies'
+    install_js_dependencies
+
+    say 'Adding files to .gitignore'
+    install_gitignore
+
+    say "\nVite ⚡️ Ruby successfully installed! 🎉"
+  end
+
+protected
+
+  # Internal: Setup for a plain Rack application.
+  def setup_app_files
+    copy_template 'config/vite.json', to: config.config_path
+
+    if (rackup_file = root.join('config.ru')).exist?
+      inject_line_after_last rackup_file, 'require', 'use(ViteRuby::DevServerProxy, ssl_verify_none: true) if ViteRuby.run_proxy?'
+    end
+  end
+
+  # Internal: Create a sample JS file and attempt to inject it in an HTML template.
+  def install_sample_files
+    copy_template 'entrypoints/application.js', to: config.resolved_entrypoints_dir.join('application.js')
+  end
+
+private
+
+  extend Forwardable
+
+  def_delegators 'ViteRuby', :config
+
+  %i[append cp inject_line_after inject_line_after_last inject_line_before write].each do |util|
+    define_method(util) { |*args, **opts, &block|
+      Dry::CLI::Utils::Files.send(util, *args, **opts, &block) rescue nil
+    }
+  end
+
+  TEMPLATES_PATH = Pathname.new(File.expand_path('../../../templates', __dir__))
+
+  def copy_template(path, to:)
+    cp TEMPLATES_PATH.join(path), to
+  end
+
+  # Internal: Creates the Vite and vite-plugin-ruby configuration files.
+  def create_configuration_files
+    copy_template 'config/vite.config.ts', to: root.join('vite.config.ts')
+    setup_app_files
+    ViteRuby.reload_with('VITE_RUBY_CONFIG_PATH' => config.config_path)
+  end
+
+  # Internal: Installs vite and vite-plugin-ruby at the project level.
+  def install_js_dependencies
+    package_json = root.join('package.json')
+    write(package_json, '{}') unless package_json.exist?
+    Dir.chdir(root) do
+      deps = "vite@#{ ViteRuby::DEFAULT_VITE_VERSION } vite-plugin-ruby@#{ ViteRuby::DEFAULT_PLUGIN_VERSION }"
+      stdout, stderr, status = Open3.capture3({ 'CI' => 'true' }, "npx ni -D #{ deps }")
+      stdout, stderr, = Open3.capture3({}, "yarn add -D #{ deps }") unless status.success?
+      say(stdout, "\n", stderr)
+    end
+  end
+
+  # Internal: Adds compilation output dirs to git ignore.
+  def install_gitignore
+    return unless (gitignore_file = root.join('.gitignore')).exist?
+
+    append(gitignore_file, <<~GITIGNORE)
+
+      # Vite Ruby
+      /public/vite
+      /public/vite-dev
+      /public/vite-test
+      node_modules
+      *.local
+      .DS_Store
+    GITIGNORE
+  end
+
+  # Internal: The root path for the Ruby application.
+  def root
+    @root ||= silent_warnings { config.root }
+  end
+
+  def say(*args)
+    $stdout.puts(*args)
+  end
+
+  # Internal: Avoid printing warning about missing vite.json, we will create one.
+  def silent_warnings
+    old_stderr = $stderr
+    $stderr = StringIO.new
+    yield
+  ensure
+    $stderr = old_stderr
+  end
+end
+
+# NOTE: This allows framework-specific variants to extend the installation.
+ViteRuby.framework_libraries.each do |_framework, library|
+  require "#{ library.name }/installation"
+end

data/lib/vite_ruby/cli/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class ViteRuby::CLI::Version < Dry::CLI::Command
+  desc 'Print version'
+
+  def call(**)
+    ViteRuby.commands.print_info
+  end
+end

data/lib/vite_ruby/commands.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+# Public: Encapsulates common tasks, available both programatically and from the
+# CLI and Rake tasks.
+class ViteRuby::Commands
+  def initialize(vite_ruby)
+    @vite_ruby = vite_ruby
+  end
+
+  # Public: Defaults to production, and exits if the build fails.
+  def build_from_task
+    with_node_env(ENV.fetch('NODE_ENV', 'production')) {
+      ensure_log_goes_to_stdout {
+        build || exit!
+      }
+    }
+  end
+
+  # Public: Builds all assets that are managed by Vite, from the entrypoints.
+  def build
+    builder.build.tap { manifest.refresh }
+  end
+
+  # Public: Removes all build cache and previously compiled assets.
+  def clobber
+    config.build_output_dir.rmtree if config.build_output_dir.exist?
+    config.build_cache_dir.rmtree if config.build_cache_dir.exist?
+    config.vite_cache_dir.rmtree if config.vite_cache_dir.exist?
+  end
+
+  # Public: Receives arguments from a rake task.
+  def clean_from_task(args)
+    ensure_log_goes_to_stdout {
+      clean(keep_up_to: Integer(args.keep || 2), age_in_seconds: Integer(args.age || 3600))
+    }
+  end
+
+  # Public: Cleanup old assets in the output directory.
+  #
+  # keep_up_to - Max amount of backups to preserve.
+  # age_in_seconds - Amount of time to look back in order to preserve them.
+  #
+  # NOTE: By default keeps the last version, or 2 if created in the past hour.
+  #
+  # Examples:
+  #   To force only 1 backup to be kept: clean(1, 0)
+  #   To only keep files created within the last 10 minutes: clean(0, 600)
+  def clean(keep_up_to: 2, age_in_seconds: 3600)
+    return false unless may_clean?
+
+    versions
+      .each_with_index
+      .drop_while { |(mtime, _), index|
+        max_age = [0, Time.now - Time.at(mtime)].max
+        max_age < age_in_seconds || index < keep_up_to
+      }
+      .each do |(_, files), _|
+        clean_files(files)
+      end
+    true
+  end
+
+  # Internal: Installs the binstub for the CLI in the appropriate path.
+  def install_binstubs
+    `bundle binstub vite_ruby --path #{ config.root.join('bin') }`
+  end
+
+  # Internal: Verifies if ViteRuby is properly installed.
+  def verify_install
+    unless File.exist?(config.root.join('bin/vite'))
+      warn <<~WARN
+        vite binstub not found.
+        Have you run `bundle binstub vite`?
+        Make sure the bin directory and bin/vite are not included in .gitignore
+      WARN
+    end
+
+    config_path = config.root.join(config.config_path)
+    unless config_path.exist?
+      warn <<~WARN
+        Configuration #{ config_path } file for vite-plugin-ruby not found.
+        Make sure `bundle exec vite install` has run successfully before running dependent tasks.
+      WARN
+      exit!
+    end
+  end
+
+  # Internal: Prints information about ViteRuby's environment.
+  def print_info
+    Dir.chdir(config.root) do
+      $stdout.puts "Is bin/vite present?: #{ File.exist? 'bin/vite' }"
+
+      $stdout.puts "vite_ruby: #{ ViteRuby::VERSION }"
+      ViteRuby.framework_libraries.each do |framework, library|
+        $stdout.puts "#{ library.name }: #{ library.version }"
+        $stdout.puts "#{ framework }: #{ Gem.loaded_specs[framework]&.version }"
+      end
+
+      $stdout.puts "node: #{ `node --version` }"
+      $stdout.puts "npm: #{ `npm --version` }"
+      $stdout.puts "yarn: #{ `yarn --version` }"
+      $stdout.puts "ruby: #{ `ruby --version` }"
+
+      $stdout.puts "\n"
+      $stdout.puts "vite-plugin-ruby: \n#{ `npm list vite-plugin-ruby version` }"
+    end
+  end
+
+private
+
+  extend Forwardable
+
+  def_delegators :@vite_ruby, :config, :builder, :manifest, :logger, :logger=
+
+  def may_clean?
+    config.build_output_dir.exist? && config.manifest_path.exist?
+  end
+
+  def clean_files(files)
+    files.select { |file| File.file?(file) }.each do |file|
+      File.delete(file)
+      logger.info("Removed #{ file }")
+    end
+  end
+
+  def versions
+    all_files = Dir.glob("#{ config.build_output_dir }/**/*")
+    entries = all_files - [config.manifest_path] - current_version_files
+    entries.reject { |file| File.directory?(file) }
+      .group_by { |file| File.mtime(file).utc.to_i }
+      .sort.reverse
+  end
+
+  def current_version_files
+    Dir.glob(manifest.refresh.values.map { |value| config.build_output_dir.join("#{ value['file'] }*") })
+  end
+
+  def with_node_env(env)
+    original = ENV['NODE_ENV']
+    ENV['NODE_ENV'] = env
+    yield
+  ensure
+    ENV['NODE_ENV'] = original
+  end
+
+  def ensure_log_goes_to_stdout
+    old_logger = logger
+    self.logger = Logger.new($stdout)
+    yield
+  ensure
+    self.logger = old_logger
+  end
+end

data/lib/vite_ruby/config.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'json'
+
+# Public: Allows to resolve configuration sourced from `config/vite.json` and
+# environment variables, combining them with the default options.
+class ViteRuby::Config
+  def protocol
+    https ? 'https' : 'http'
+  end
+
+  def host_with_port
+    "#{ host }:#{ port }"
+  end
+
+  # Internal: Path where Vite outputs the manifest file.
+  def manifest_path
+    build_output_dir.join('manifest.json')
+  end
+
+  # Internal: Path where vite-plugin-ruby outputs the assets manifest file.
+  def assets_manifest_path
+    build_output_dir.join('manifest-assets.json')
+  end
+
+  # Public: The directory where Vite will store the built assets.
+  def build_output_dir
+    root.join(public_dir, public_output_dir)
+  end
+
+  # Public: The directory where the entries are located.
+  def resolved_entrypoints_dir
+    root.join(source_code_dir, entrypoints_dir)
+  end
+
+  # Internal: The directory where Vite stores its processing cache.
+  def vite_cache_dir
+    root.join('node_modules/.vite')
+  end
+
+  # Public: Sets additional environment variables for vite-plugin-ruby.
+  def to_env
+    CONFIGURABLE_WITH_ENV.each_with_object({}) do |option, env|
+      unless (value = @config[option]).nil?
+        env["#{ ViteRuby::ENV_PREFIX }_#{ option.upcase }"] = value.to_s
+      end
+    end.merge(ViteRuby.env)
+  end
+
+private
+
+  # Internal: Coerces all the configuration values, in case they were passed
+  # as environment variables which are always strings.
+  def coerce_values(config)
+    config['mode'] = config['mode'].to_s
+    config['port'] = config['port'].to_i
+    config['root'] = Pathname.new(config['root'])
+    config['build_cache_dir'] = config['root'].join(config['build_cache_dir'])
+    coerce_booleans(config, 'auto_build', 'hide_build_console_output', 'https')
+  end
+
+  # Internal: Coerces configuration options to boolean.
+  def coerce_booleans(config, *names)
+    names.each { |name| config[name] = [true, 'true'].include?(config[name]) }
+  end
+
+  def initialize(attrs)
+    @config = attrs.tap { |config| coerce_values(config) }.freeze
+  end
+
+  class << self
+    private :new
+
+    # Public: Returns the project configuration for Vite.
+    def resolve_config(**attrs)
+      config = config_defaults.merge(attrs.transform_keys(&:to_s))
+      file_path = File.join(config['root'], config['config_path'])
+      file_config = config_from_file(file_path, mode: config['mode'])
+      new DEFAULT_CONFIG.merge(file_config).merge(config_from_env).merge(config)
+    end
+
+  private
+
+    # Internal: Converts camelCase to snake_case.
+    SNAKE_CASE = ->(camel_cased_word) {
+      camel_cased_word.to_s.gsub(/::/, '/')
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+        .tr('-', '_')
+        .downcase
+    }
+
+    # Internal: Default values for a Ruby application.
+    def config_defaults(asset_host: nil, mode: ENV.fetch('RACK_ENV', 'production'), root: Dir.pwd)
+      {
+        'asset_host' => option_from_env('asset_host') || asset_host,
+        'config_path' => option_from_env('config_path') || DEFAULT_CONFIG.fetch('config_path'),
+        'mode' => option_from_env('mode') || mode,
+        'root' => option_from_env('root') || root,
+      }
+    end
+
+    # Internal: Used to load a JSON file from the specified path.
+    def load_json(path)
+      JSON.parse(File.read(File.expand_path(path))).each do |_env, config|
+        config.transform_keys!(&SNAKE_CASE) if config.is_a?(Hash)
+      end.tap do |config|
+        config.transform_keys!(&SNAKE_CASE)
+      end
+    end
+
+    # Internal: Retrieves a configuration option from environment variables.
+    def option_from_env(name)
+      ViteRuby.env["#{ ViteRuby::ENV_PREFIX }_#{ name.upcase }"]
+    end
+
+    # Internal: Extracts the configuration options provided as env vars.
+    def config_from_env
+      CONFIGURABLE_WITH_ENV.each_with_object({}) do |option, env_vars|
+        if value = option_from_env(option)
+          env_vars[option] = value
+        end
+      end
+    end
+
+    # Internal: Loads the configuration options provided in a JSON file.
+    def config_from_file(path, mode:)
+      multi_env_config = load_json(path)
+      multi_env_config.fetch('all', {})
+        .merge(multi_env_config.fetch(mode, {}))
+    rescue Errno::ENOENT => error
+      warn "Check that your vite.json configuration file is available in the load path:\n\n\t#{ error.message }\n\n"
+      {}
+    end
+  end
+
+  # Internal: Shared configuration with the Vite plugin for Ruby.
+  DEFAULT_CONFIG = load_json("#{ __dir__ }/../../default.vite.json").freeze
+
+  # Internal: Configuration options that can not be provided as env vars.
+  NOT_CONFIGURABLE_WITH_ENV = %w[watch_additional_paths].freeze
+
+  # Internal: Configuration options that can be provided as env vars.
+  CONFIGURABLE_WITH_ENV = (DEFAULT_CONFIG.keys + %w[mode root] - NOT_CONFIGURABLE_WITH_ENV).freeze
+
+public
+
+  # Define getters for the configuration options.
+  (CONFIGURABLE_WITH_ENV + NOT_CONFIGURABLE_WITH_ENV).each do |option|
+    define_method(option) { @config[option] }
+  end
+end