staticky 0.1.1 → 0.3.0

data/lib/staticky/cli.rb

@@ -4,66 +4,6 @@ require "dry/cli"
 
 module Staticky
   module CLI
-    module Commands
-      extend Dry::CLI::Registry
-
-      class Version < Dry::CLI::Command
-        desc "Print version"
-
-        def call(*) = puts VERSION
-      end
-
-      class Build < Dry::CLI::Command
-        desc "Build site"
-
-        def call(*) = Staticky.builder.call
-      end
-
-      class Generate < Dry::CLI::Command
-        desc "Create new site"
-
-        argument :path,
-                 required: true,
-                 desc: "Relative path where the site will be generated"
-
-        option :url,
-               default: "https://example.com",
-               desc: "Site URL",
-               aliases: ["-u"]
-        option :title,
-               default: "Example",
-               desc: "Site title",
-               aliases: ["-t"]
-        option :description,
-               default: "Example site",
-               desc: "Site description",
-               aliases: ["-d"]
-        option :twitter,
-               default: "",
-               desc: "Twitter handle",
-               aliases: ["-t"]
-
-        def call(path:, **)
-          path = Pathname.new(path).expand_path
-
-          Staticky.generator.call(path, **)
-
-          commands = [
-            "bundle install",
-            "bundle binstubs bundler rake rspec-core vite_ruby",
-            "yarn install",
-            "bin/rspec"
-          ].join(" && ")
-
-          system(commands, chdir: path) || abort("install failed")
-        end
-      end
-
-      register "version", Version
-      register "build", Build
-      register "new", Generate
-    end
-
     def self.new(...)
       Dry::CLI.new(Commands)
     end

data/lib/staticky/deps.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Staticky
-  Deps = Container.injector
+  Deps = Application.injector
 end

data/lib/staticky/filesystem.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "delegate"
-require "staticky-files"
-
 module Staticky
   class Filesystem < SimpleDelegator
     def self.test

data/lib/staticky/phlex/view_helpers.rb

@@ -3,10 +3,20 @@
 module Staticky
   module Phlex
     module ViewHelpers
-      def link_to(text, href, **, &block) # rubocop:disable Metrics/ParameterLists
+      def helpers
+        @_view_context
+      end
+
+      def staticky_live_reload_js(base_path = "/")
+        script(type: :module) do
+          unsafe_raw Staticky::Utils.live_reload_js(base_path)
+        end
+      end
+
+      def link_to(text = nil, href, **, &block) # rubocop:disable Style/OptionalArguments
         block ||= proc { text }
         href = Staticky.router.resolve(href)
-        href = href.url unless href.is_a?(String)
+        href = href.uri.to_s unless href.is_a?(String)
 
         a(href:, **, &block)
       end

data/lib/staticky/pluggable.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Staticky
+  module Pluggable
+    class Resolver < Dry::Container::Resolver
+      def initialize(klass)
+        @klass = klass
+      end
+
+      def call(container, key)
+        container.fetch(key.to_s).call
+      end
+    end
+
+    module ClassMethods
+      def load_plugin(key)
+        resolve(key)
+      end
+
+      def register_plugin(key, klass)
+        register(key.to_s, klass)
+      end
+    end
+
+    def self.included(base)
+      base.extend Dry::Container::Mixin
+      base.extend ClassMethods
+      base.config.resolver = Resolver.new(base)
+
+      base.define_singleton_method :namespace do
+        base.name.split("::")[0..-2].join("::")
+      end
+    end
+  end
+end

data/lib/staticky/resource.rb

@@ -1,25 +1,24 @@
 # frozen_string_literal: true
 
 module Staticky
-  Resource = Data.define(:url, :component) do
-    def full_filepath
-      Staticky.build_path.join(filepath)
-    end
+  class Resource
+    def self.plugin(plugin, ...)
+      plugin = Resources::Plugins.load_plugin(plugin) if plugin.is_a?(Symbol)
+      unless plugin.is_a?(Module)
+        raise ArgumentError, "Invalid plugin type: #{plugin.class.inspect}"
+      end
 
-    def read
-      full_filepath.read
-    end
+      if plugin.respond_to?(:load_dependencies)
+        plugin.load_dependencies(self, ...)
+      end
 
-    def filepath
-      root? ? "index.html" : "#{url}.html"
-    end
+      include plugin::InstanceMethods if defined?(plugin::InstanceMethods)
+      extend plugin::ClassMethods if defined?(plugin::ClassMethods)
 
-    def root?
-      url == "/"
+      plugin.configure(self, ...) if plugin.respond_to?(:configure)
     end
 
-    def build(view_context: ViewContext.new(self))
-      component.call(view_context:)
-    end
+    plugin :prelude
+    plugin :phlex
   end
 end

data/lib/staticky/resources/plugins/phlex.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Staticky
+  module Resources
+    module Plugins
+      module Phlex
+        class ViewContext < SimpleDelegator
+          def initialize(resource)
+            super
+            @resource = resource
+          end
+
+          def root?
+            @resource.root?
+          end
+
+          def current_path
+            @resource.url
+          end
+        end
+
+        module InstanceMethods
+          def component=(component)
+            @component = component
+          end
+
+          def component
+            return @component if defined?(@component)
+
+            raise ArgumentError, "component is required"
+          end
+
+          def build(view_context: ViewContext.new(self))
+            component.call(view_context:)
+          end
+        end
+      end
+
+      register_plugin(:phlex, Phlex)
+    end
+  end
+end

data/lib/staticky/resources/plugins/prelude.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Staticky
+  module Resources
+    module Plugins
+      module Prelude
+        module ClassMethods
+          def new(**env)
+            super().tap do |resource|
+              env.each do |key, value|
+                resource.send(:"#{key}=", value)
+              end
+            end
+          end
+        end
+
+        module InstanceMethods
+          def build_path
+            destination.join(filepath)
+          end
+
+          def filepath
+            return Pathname.new("index.html") if root?
+
+            Pathname.new("#{uri.path.gsub(%r{^/}, "")}.html")
+          end
+
+          def read
+            Staticky.files.read(build_path)
+          end
+
+          def root?
+            url == "/"
+          end
+
+          def uri
+            return @uri if defined?(@uri)
+
+            raise ArgumentError, "url is required"
+          end
+
+          def destination
+            @destination ||= Staticky.build_path
+          end
+
+          def destination=(destination)
+            @destination = Pathname(destination)
+          end
+
+          def url
+            return @url if defined?(@url)
+
+            raise ArgumentError, "url is required"
+          end
+
+          def url=(url)
+            @url = url
+            @uri = parse_url(url)
+          end
+
+          private
+
+          def parse_url(url)
+            URI(url).tap do |uri|
+              uri.path = "/#{uri.path}" unless uri.path.start_with?("/")
+            end
+          rescue URI::InvalidURIError => e
+            raise ArgumentError, e.message
+          end
+        end
+      end
+
+      register_plugin(:prelude, Prelude)
+    end
+  end
+end

data/lib/staticky/resources/plugins.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Staticky
+  module Resources
+    module Plugins
+      include Pluggable
+    end
+  end
+end

data/lib/staticky/router.rb

@@ -10,29 +10,24 @@ module Staticky
     # In Staticky when we build we need to do a lot of introspection to link
     # routes to resources on the file system.
 
-    def initialize
-      @definition = Staticky::Router::Definition.new
-    end
+    Error = Class.new(Staticky::Error)
 
-    def define(&block)
-      tap do
-        @definition.instance_eval(&block)
+    def self.plugin(plugin, ...)
+      plugin = Routing::Plugins.load_plugin(plugin) if plugin.is_a?(Symbol)
+      unless plugin.is_a?(Module)
+        raise ArgumentError, "Invalid plugin type: #{plugin.class.inspect}"
       end
-    end
-
-    def filepaths
-      @definition.filepaths
-    end
 
-    def resources
-      @definition.resources
-    end
+      if plugin.respond_to?(:load_dependencies)
+        plugin.load_dependencies(self, ...)
+      end
 
-    def resolve(path)
-      # Return absolute paths as is
-      return path if path.is_a?(String) && path.start_with?("http")
+      include plugin::InstanceMethods if defined?(plugin::InstanceMethods)
+      extend plugin::ClassMethods if defined?(plugin::ClassMethods)
 
-      @definition.resolve(path)
+      plugin.configure(self, ...) if plugin.respond_to?(:configure)
     end
+
+    plugin :prelude
   end
 end

data/lib/staticky/routing/plugins/prelude.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Staticky
+  module Routing
+    module Plugins
+      module Prelude
+        module ClassMethods
+          def new(**env)
+            super().tap do |router|
+              env.each do |key, value|
+                router.send(:"#{key}=", value)
+              end
+            end
+          end
+        end
+
+        module InstanceMethods
+          def define(&block)
+            tap do
+              instance_eval(&block)
+            end
+          end
+
+          def match(path, to:, as: Resource)
+            path = strip_leading_slash(path)
+
+            resource = case to
+            when ->(x) { x.is_a?(Class) || x.is_a?(::Phlex::HTML) }
+              component = ensure_instance(to)
+              as.new(component:, url: path)
+            else
+              raise Router::Error, "Invalid route target: #{to.inspect}"
+            end
+
+            resources << resource
+            index_resource(path, resource)
+          end
+
+          def root(to:)
+            match("/", to:)
+          end
+
+          def resolve(path)
+            return path if path.is_a?(String) && path.start_with?("#")
+            return lookup(path) if path.is_a?(Class)
+
+            path = strip_leading_slash(path)
+            uri = URI(path)
+            # Return absolute paths as is
+            return path if uri.absolute?
+
+            if uri.path.size > 1 && uri.path.start_with?("/")
+              uri.path = uri.path[1..]
+            end
+
+            lookup(uri.path)
+          rescue URI::InvalidURIError
+            raise Router::Error, "Invalid path: #{path}"
+          rescue KeyError
+            raise Router::Error, "No route matches #{path}"
+          end
+
+          def resources = @resources ||= []
+          def filepaths = resources.map(&:filepath)
+
+          private
+
+          def lookup(path)
+            @routes_by_path.fetch(path) do
+              @routes_by_component.fetch(path)
+            end
+          end
+
+          def index_resource(path, resource)
+            routes_by_path[path] = resource
+            routes_by_component[resource.component.class] = resource
+          end
+
+          def routes_by_path = @routes_by_path ||= {}
+          def routes_by_component = @routes_by_component ||= {}
+
+          def ensure_instance(component)
+            component.is_a?(Class) ? component.new : component
+          end
+
+          def strip_leading_slash(path)
+            return path if path == "/"
+
+            path.to_s.gsub(%r{^/}, "")
+          end
+        end
+      end
+
+      register_plugin(:prelude, Prelude)
+    end
+  end
+end

data/lib/staticky/routing/plugins.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Staticky
+  module Routing
+    module Plugins
+      include Pluggable
+    end
+  end
+end

data/lib/staticky/server.rb

@@ -3,6 +3,7 @@
 require "roda"
 
 require_relative "../staticky"
+require_relative "server_plugin"
 
 module Staticky
   class Server < Roda
@@ -12,25 +13,13 @@ module Staticky
 
     NotFound = Class.new(Staticky::Error)
 
-    plugin :common_logger, Staticky.server_logger, method: :debug
-    plugin :render, engine: "html"
-    plugin :public
-
-    plugin :not_found do
-      raise NotFound if Staticky.env.test?
-
-      Staticky.build_path.join("404.html").read
-    end
-
-    plugin :error_handler do |e|
-      raise e if Staticky.env.test?
-
-      Staticky.build_path.join("500.html").read
-    end
+    plugin :staticky_server
 
     route do |r|
+      r.staticky
+
       Staticky.resources.each do |resource|
-        case resource.filepath
+        case resource.filepath.to_s
         when "index.html"
           r.root do
             render(inline: resource.read)

data/lib/staticky/server_plugin.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Staticky
+  module ServerPlugin
+    def self.load_dependencies(app)
+      app.plugin :common_logger, Staticky.server_logger, method: :debug
+      app.plugin :render, engine: "html"
+      app.plugin :public
+      app.plugin :exception_page
+
+      app.plugin :not_found do
+        raise Staticky::Server::NotFound if Staticky.env.test?
+
+        Staticky.build_path.join("404.html").read
+      end
+
+      app.plugin :error_handler do |error|
+        raise error if Staticky.env.test?
+        next exception_page(error) if Staticky.env.development?
+
+        Staticky.build_path.join("500.html").read
+      end
+    end
+
+    module RequestMethods
+      def staticky
+        unless Staticky.env.development? && Staticky.config.live_reloading
+          return
+        end
+
+        ServerPlugins::LiveReloading.setup_live_reload(scope)
+      end
+    end
+
+    Roda::RodaPlugins.register_plugin(:staticky_server, self)
+  end
+end

data/lib/staticky/server_plugins/live_reloading.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Staticky
+  module ServerPlugins
+    module LiveReloading
+      def self.setup_live_reload(app) # rubocop:disable Metrics
+        sleep_interval = 0.5
+        file_to_check = Staticky.build_path.join("index.html")
+        errors_file = Staticky.build_path.join("errors.json")
+
+        app.request.get "_staticky/live_reload" do # rubocop:disable Metrics/BlockLength
+          @_mod = if Staticky.files.exist?(file_to_check)
+            file_to_check.mtime.to_i
+          else
+            0
+          end
+
+          event_stream = proc do |stream|
+            Thread.new do
+              loop do
+                new_mod = if Staticky.files.exist?(file_to_check)
+                  file_to_check.mtime.to_i
+                else
+                  0
+                end
+
+                if @_mod < new_mod
+                  stream.write "data: reloaded!\n\n"
+                  break
+                elsif Staticky.files.exist?(errors_file)
+                  stream.write "event: builderror\n" \
+                               "data: #{errors_file.read.to_json}\n\n"
+                else
+                  stream.write "data: #{new_mod}\n\n"
+                end
+
+                sleep sleep_interval
+              rescue Errno::EPIPE # User refreshed the page
+                break
+              end
+            ensure
+              stream.close
+            end
+          end
+
+          app.request.halt [
+            200,
+            {
+              "Content-Type" => "text/event-stream",
+              "cache-control" => "no-cache"
+            },
+            event_stream
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/staticky/utils.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Staticky
+  module Utils
+    module_function
+
+    def live_reload_js(base_path) # rubocop:disable Metrics/MethodLength
+      return "" unless Staticky.env.development?
+
+      path = File.join(base_path, "/_staticky/live_reload")
+
+      <<~JAVASCRIPT
+        let lastmod = 0
+        let reconnectAttempts = 0
+
+        function statickyReload() {
+          if (window.Turbo) {
+            Turbo.visit(window.location)
+          } else {
+            location.reload()
+          }
+        }
+
+        function startLiveReload() {
+          const connection = new EventSource("#{path}")
+
+          connection.addEventListener("message", event => {
+            reconnectAttempts = 0
+
+            if (event.data == "reloaded!") {
+              statickyReload()
+            } else {
+              const newmod = Number(event.data)
+
+              if (lastmod < newmod) {
+                statickyReload()
+                lastmod = newmod
+              }
+            }
+          })
+
+          connection.addEventListener("error", () => {
+            if (connection.readyState === 2) {
+              // reconnect with new object
+              connection.close()
+              reconnectAttempts++
+              if (reconnectAttempts < 25) {
+                console.warn("Live reload: attempting to reconnect in 3 seconds...")
+                setTimeout(() => startLiveReload(), 3000)
+              } else {
+                console.error(
+                  "Too many live reload connections failed. Refresh the page to try again."
+                )
+              }
+            }
+          })
+        }
+
+        startLiveReload()
+      JAVASCRIPT
+    end
+  end
+end

data/lib/staticky/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Staticky
-  VERSION = "0.1.1"
+  VERSION = "0.3.0"
 end