staticky 0.1.0 → 0.2.0

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,9 +3,14 @@
 module Staticky
   module Phlex
     module ViewHelpers
-      def link_to(text, href, **, &block) # rubocop:disable Metrics/ParameterLists
+      def helpers
+        @_view_context
+      end
+
+      def link_to(text = nil, href, **, &block) # rubocop:disable Style/OptionalArguments
         block ||= proc { text }
-        href = Staticky.router.resolve(href).url
+        href = Staticky.router.resolve(href)
+        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,74 @@
+# 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 filepath
+            destination.join(basename)
+          end
+
+          def read
+            filepath.read
+          end
+
+          def basename
+            root? ? "index.html" : "#{url}.html"
+          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,26 +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
+      if plugin.respond_to?(:load_dependencies)
+        plugin.load_dependencies(self, ...)
+      end
 
-    def resources
-      @definition.resources
-    end
+      include plugin::InstanceMethods if defined?(plugin::InstanceMethods)
+      extend plugin::ClassMethods if defined?(plugin::ClassMethods)
 
-    def resolve(path)
-      @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

@@ -14,6 +14,7 @@ module Staticky
 
     plugin :common_logger, Staticky.server_logger, method: :debug
     plugin :render, engine: "html"
+    plugin :public
 
     plugin :not_found do
       raise NotFound if Staticky.env.test?
@@ -29,7 +30,7 @@ module Staticky
 
     route do |r|
       Staticky.resources.each do |resource|
-        case resource.filepath
+        case resource.filepath.basename.to_s
         when "index.html"
           r.root do
             render(inline: resource.read)
@@ -41,8 +42,7 @@ module Staticky
         end
       end
 
-      # Need to return nil or Roda is unhappy
-      nil
+      r.public
     end
   end
 end

data/lib/staticky/version.rb

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

data/lib/staticky.rb

@@ -1,17 +1,27 @@
 # frozen_string_literal: true
 
+require "uri"
+require "delegate"
+
 require "phlex"
+require "dry/container"
 require "dry/system"
 require "dry/configurable"
 require "dry/logger"
-require "uri"
 require "tilt"
+require "staticky-files"
 
 module Staticky
   GEM_ROOT = Pathname.new(__dir__).join("..").expand_path
 end
 
-require_relative "staticky/container"
+require_relative "staticky/pluggable"
+require_relative "staticky/resources/plugins"
+require_relative "staticky/resources/plugins/prelude"
+require_relative "staticky/resources/plugins/phlex"
+require_relative "staticky/routing/plugins"
+require_relative "staticky/routing/plugins/prelude"
+require_relative "staticky/application"
 
 module Staticky
   # DOCS: Module for static site infrastructure such as:
@@ -24,7 +34,7 @@ module Staticky
 
   extend Dry::Configurable
 
-  setting :env, default: :development
+  setting :env, default: ENV.fetch("RACK_ENV", "development").to_sym
   setting :build_path, default: Pathname.new("build")
   setting :root_path, default: Pathname(__dir__)
   setting :logger, default: Dry.Logger(:staticky, template: :details)
@@ -34,18 +44,18 @@ module Staticky
     formatter: :rack
   )
 
-  def monitor(...) = container.monitor(...)
-  def server_logger =config.server_logger
+  def monitor(...) = application.monitor(...)
+  def server_logger = config.server_logger
   def logger = config.logger
   def build_path = config.build_path
   def root_path = config.root_path
   def resources = router.resources
-  def router = container[:router]
-  def builder = container[:builder]
-  def generator = container[:generator]
-  def container = Container
+  def router = application[:router]
+  def builder = application[:builder]
+  def generator = application[:generator]
+  def application = Application
 
   def env
-    @env ||= Environment.new container.env
+    Environment.new config.env.to_sym
   end
 end

data/site_template/.gitignore

@@ -9,3 +9,17 @@ node_modules
 
 .bundle
 /tmp/
+
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/sdks
+!.yarn/versions
+
+# Swap the comments on the following lines if you wish to use zero-installs
+# In that case, don't forget to run `yarn config set enableGlobalCache false`!
+# Documentation here: https://yarnpkg.com/features/caching#zero-installs
+
+#!.yarn/cache
+.pnp.*

data/site_template/.ruby-version

@@ -1 +1 @@
-3.3.4
+3.3.5

data/site_template/Dockerfile

@@ -40,8 +40,8 @@ COPY nginx.conf /etc/nginx/nginx.conf
 # Copy the static site files to the Nginx HTML directory
 COPY --from=builder /app/build /usr/share/nginx/html/
 
-# Expose port 80 to the Docker host
-EXPOSE 80
+# Expose port to the Docker host (default is 5000 for dokku)
+EXPOSE 5000
 
 # Start Nginx when the container launches
-CMD ["nginx", "-g", "daemon off;"]
+CMD ["nginx", "-c", "/etc/nginx/nginx.conf"]

data/site_template/Gemfile

@@ -13,7 +13,6 @@ gem "protos-markdown"
 gem "dry-inflector"
 gem "front_matter_parser"
 gem "rack"
-gem "rackup"
 gem "rake"
 gem "rouge"
 gem "staticky", github: "nolantait/staticky", branch: "master"
@@ -28,6 +27,8 @@ group :test do
 end
 
 group :development do
-  gem "rerun"
-  gem "rubocop-inhouse", require: false
+  gem "filewatcher", require: false
+  gem "puma"
+  gem "rubocop"
+  gem "rubocop-inhouse"
 end

data/site_template/Procfile.dev

@@ -1,3 +1,3 @@
-server: bin/bundle exec rackup
-builder: rerun --dir app,lib,content --exit --verbose -- bin/rake site:build
+server: bin/bundle exec puma -C config/puma.rb
+builder: bin/rake site:watch
 vite: bin/vite dev

data/site_template/README.md

@@ -9,7 +9,7 @@ assets by default and hooks into the build command defined in your `Rakefile`
 Your development server runs with `bin/dev`
 
 Everything is ruby, there is no html or erb. It outputs a static site to the
-`build/` folder by default, but that can be configured.
+`./build` folder by default, but that can be configured.
 
 ## Usage
 
@@ -36,7 +36,7 @@ Your site should not be accessible at http://localhost:9292
 
 ## Building
 
-During development `rerun` watches your files and rebuilds the site when they
+During development `filewatcher` watches your files and rebuilds the site when they
 change by running `bin/rake site:build`. These files are served by a Roda app.
 
 In production you simply output the files to a folder and serve them statically
@@ -46,6 +46,26 @@ can be tweaked however you like.
 Building takes all the definitions inside your `config/routes` and outputs
 static files to `./build` or wherever you have configured it.
 
+## Development and hot reloading
+
+By default your site will use `puma` to run a `roda` server that serves the
+files inside your `Staticky.build_path` (`./build` by default).
+
+You can access your site at:
+
+```
+http://localhost:3000
+```
+
+You can change these settings inside your `Procfile.dev` which starts the
+processes required for development.
+
+When your site triggers a rebuild and you are connected to the page. The vite
+server will trigger a page reload after 500ms.
+
+If this is too fast and you find yourself having to refresh the page yourself
+you can tweak this inside your `vite.config.ts`.
+
 ## Views
 
 Views are defined in `app/views`. They should be phlex components and you can
@@ -80,12 +100,12 @@ Staticky.router.define do
   # Write your own custom logic for parsing your markdown
   Dir["content/**/*.md"].each do |file|
     parsed = FrontMatterParser::Parser.parse_file(file, loader:)
+    basenames = file.gsub("content/", "").gsub(".md", "")
+    front_matter = parsed.front_matter.transform_keys(&:to_sym)
 
-    match file.gsub("content/", "").gsub(".md", ""),
-          to: Pages::Post.new(
-            parsed.content,
-            front_matter: parsed.front_matter.transform_keys(&:to_sym)
-          )
+    basename.each do |path|
+      match path, to: Pages::Post.new(parsed.content, front_matter:)
+    end
   end
 end
 ```
@@ -96,3 +116,7 @@ The router is your definition for how to build your static site.
 
 Deployment is done through a simple Dockerfile. This setup is optimized for
 deploying onto Dokku servers.
+
+By default Dokku expects the app to be exposed on port 5000 which we do through
+our Dockerfile. Dokku will scan the Dockerfile for an `EXPOSE` directive and
+automatically setup the port routing for you.

data/site_template/Rakefile

@@ -7,12 +7,41 @@ ViteRuby.install_tasks
 desc "Precompile assets"
 task :environment do
   require "./config/boot"
+
+  Staticky.application.monitor(:builder, methods: %i[call]) do |event|
+    Staticky.logger.info "Built site in #{event[:time]}ms"
+  end
 end
 
 namespace :site do
-  desc "Precompile assets"
+  desc "Build the site and its assets into the Staticky.build_path (./build)"
   task build: :environment do
-    Rake::Task["vite:build"].invoke
+    Staticky.logger.info "Building site in #{Staticky.env.name} environment..."
     Staticky.builder.call
   end
+
+  desc "Watch the site and its assets for changes"
+  task watch: :environment do
+    require "filewatcher"
+
+    Rake::Task["site:build"].execute unless Staticky.build_path.exist?
+
+    Staticky.logger.info "Watching site in #{Staticky.env.name} environment..."
+
+    Filewatcher.new(
+      [
+        "app/**/*.rb",
+        "lib/**/*.rb",
+        "content/**/*"
+      ]
+    ).watch do
+      Staticky.logger.info "Change detected, rebuilding site..."
+      sh("bin/rake site:build") do |ok, res|
+        unless ok
+          Staticky.logger.error "Error rebuilding site:"
+          puts res
+        end
+      end
+    end
+  end
 end