staticky 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 41fa452e7c74ade67ffd58486af13cb4b121eda6cd51ffd5dc25105981cea0c2
+  data.tar.gz: c8c2a3a15bc2cf0225d7763a825e8c1a34af2a0762777091e0c6c581723d485f
+SHA512:
+  metadata.gz: ff6e8e759028df62d4ce1a9304c2b8caa7fd38c5684e9a653445d14a46ffd4b880fd3c05bb393890d055262db28d37384c47af02ff72c1ce37dafaed33842d33
+  data.tar.gz: 3aa63ca27344d93d99a92463e85f4cd75a547360da6682f6727cbd022b258c540df7dd39b4631f15f08f8f19bcb08bc21aedfe07736aab3267092d4d1db5ec9d

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,11 @@
+require:
+  - rubocop-inhouse
+  - rubocop-capybara
+
+inherit_gem:
+  rubocop-inhouse:
+    - config/default.yml
+    - config/capybara.yml
+
+AllCops:
+  TargetRubyVersion: 3.3

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2024-07-08
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Nolan J Tait
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,163 @@
+# Staticky
+
+Staticky is a static site builder for Ruby maximalists. I built this library
+because I wanted something more scriptable than Bridgetown and Jekyll that had
+first-class support for Phlex components.
+
+[Phlex](https://phlex.fun) makes building component based frontends fun and
+I wanted to extend the developer experience of something like Rails but focused
+on static sites.
+
+I am using this at https://taintedcoders.com. (soon)
+
+- Hot reloading in development with Roda serving static files
+- Docker deployment with NGINX
+
+You can find a working setup in `site_template` folder.
+
+## Installation
+
+Install the gem and add to the application's Gemfile by executing:
+
+    $ bundle add staticky
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+    $ gem install staticky
+
+## Usage
+
+First you can use the CLI to generate a new template:
+
+```
+staticky new my_blog --url "https://example.com"
+```
+
+This will generate a new site at `./my_blog`, install your dependencies and run
+`rspec` just to make sure everything got set up correctly.
+
+Once your site is generated you can use the router to define how your content
+maps to routes in `config/routes.rb`:
+
+```ruby
+Staticky.router.define do
+  root to: Pages::Home
+  match "404", to: Errors::NotFound
+  match "500", to: Errors::ServiceError
+
+  # Write your own logic to parse your data into components
+  Site.posts.each_value do |model|
+    match model.relative_url, to: Posts::Show.new(model)
+  end
+end
+```
+
+Each route takes a Phlex component (or any object that outputs a string from
+`#call`). We can either pass the class for a default initialization (we just
+call `.new`) or initialize it ourselves.
+
+Here is an example of what the `Posts::Show` component might look like. We are
+using a [protos](https://github.com/inhouse-work/protos) component, but you can
+use plain old Phlex components if you like.
+
+```ruby
+module Posts
+  class Show < Protos::Component
+    param :post, reader: false
+
+    def around_template(&)
+      render Layouts::Post.new(class: css[:layout], &)
+    end
+
+    def view_template
+      render Posts::Header.new(@post)
+      render Posts::Outline.new(@post, class: css[:outline])
+      render Posts::Markdown.new(@post, class: css[:post])
+      render Posts::Footer.new(@post)
+    end
+
+    private
+
+    def theme
+      {
+        layout: "mr-0 lg:mr-[--sidebar-width] md:ml-[--sidebar-width]",
+        outline: %w[
+          my-md
+          md:fixed
+          md:left-0
+          md:top-[--navbar-height]
+          md:pl-[--viewport-padding]
+          md:w-[--sidebar-width]
+        ],
+        post: "prose mx-auto pb-lg"
+      }
+    end
+  end
+end
+```
+
+When you are developing your site you run `bin/dev` to start your development
+server on http://localhost:9292. This will automatically reload after a short
+period when you make changes.
+
+Assets are handled by Vite by default, but you can have whatever build process
+you like just by tweaking `Procfile.dev` and your `Rakefile`. You will also need
+to create your own view helpers for linking your assets.
+
+By default, to build your site you run the builder, usually inside a Rakefile:
+
+```ruby
+require "vite_ruby"
+
+ViteRuby.install_tasks
+
+desc "Precompile assets"
+task :environment do
+  require "./config/boot"
+end
+
+namespace :site do
+  desc "Precompile assets"
+  task build: :environment do
+    Rake::Task["vite:build"].invoke
+    Staticky.builder.call
+  end
+end
+```
+
+This will output your site to `./build` by default.
+
+## Configuration
+
+We can override the configuration according to the settings defined on the main
+module:
+
+```ruby
+Staticky.configure do |config|
+  config.env = :test
+  config.build_path = Pathname.new("dist")
+  config.root_path = Pathname(__dir__)
+  config.logger = Logger.new($stdout)
+  config.server_logger = Logger.new($stdout)
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run
+`bin/rspec` to run the tests. You can also run `bin/console` for an interactive
+prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To
+release a new version, update the version number in `version.rb`, and then run
+`bundle exec rake release`, which will create a git tag for the version, push
+git commits and the created tag, and push the `.gem` file to
+[rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/nolantait/staticky.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[spec rubocop]

data/bin/staticky

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "staticky"
+
+Staticky::CLI.new.call

data/lib/staticky/builder.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Staticky
+  class Builder
+    include Dry::Events::Publisher[:builder]
+    include Deps[:files, :router]
+
+    register_event("started")
+    register_event("finished")
+    register_event("before_resource")
+    register_event("after_resource")
+
+    def self.call(...) = new(...).call
+
+    def on(event_type, &block) = subscribe(event_type, &block)
+
+    def call
+      publish("started")
+      copy_public_files
+      build_site
+      publish("finished")
+    end
+
+    private
+
+    def build_site
+      @router
+        .resources
+        .each do |resource|
+          publish("before_resource", resource:)
+          compile output_path(resource.filepath), resource.build
+          publish("after_resource", resource:)
+        end
+    end
+
+    def copy_public_files
+      public_folder = Staticky.root_path.join("public")
+      return unless @files.exist? public_folder
+
+      @files.children(public_folder).each do |file|
+        # file => "favicon.ico"
+        copy(public_path(file), output_path(file))
+      end
+    end
+
+    def compile(destination, content)
+      @files.write destination, content
+    end
+
+    def copy(source, destination)
+      @files.cp source, destination
+    end
+
+    def public_path(path)
+      Staticky.root_path.join("public", path)
+    end
+
+    def output_path(path)
+      Staticky.build_path.join(path)
+    end
+  end
+end

data/lib/staticky/cli.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+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
+  end
+end

data/lib/staticky/container.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Staticky
+  class Container < Dry::System::Container
+    use :env
+    use :zeitwerk
+    use :monitoring
+
+    configure do |config|
+      config.root = Pathname(__dir__).join("..").join("..")
+      config.inflector = Dry::Inflector.new do |inflections|
+        inflections.acronym("CLI")
+      end
+      config.component_dirs.add "lib" do |dir|
+        dir.add_to_load_path = false
+        dir.auto_register = false
+        dir.namespaces.add "staticky", key: nil
+      end
+    end
+
+    register(:files, Staticky::Filesystem.real)
+    register(:router, Staticky::Router.new)
+    register(:builder, Staticky::Builder.new)
+    register(:generator, Staticky::Generator.new)
+  end
+end

data/lib/staticky/deps.rb

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

data/lib/staticky/environment.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Staticky
+  Environment = Data.define(:name) do
+    def development? = name == :development
+    def test? = name == :test
+  end
+end

data/lib/staticky/error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Staticky
+  class Error < StandardError; end
+end

data/lib/staticky/filesystem.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "delegate"
+require "staticky-files"
+
+module Staticky
+  class Filesystem < SimpleDelegator
+    def self.test
+      files = Staticky::Files.new(memory: true)
+      new(files)
+    end
+
+    def self.real
+      files = Staticky::Files.new
+      new(files)
+    end
+
+    def touch(*files)
+      files.each do |file|
+        super(file)
+      end
+    end
+
+    def children(directory)
+      tokens = [".", ".."]
+      entries(directory).reject { |entry| tokens.include?(entry) }
+    end
+  end
+end

data/lib/staticky/generator.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Staticky
+  class Generator
+    include Deps[:files]
+
+    class ViewContext
+      attr_reader :title, :description, :twitter, :url
+
+      def initialize(url:, title: "", description: "", twitter: "")
+        @title = title
+        @description = description
+        @twitter = twitter
+        @url = URI(url)
+
+        raise ArgumentError, "Must be a full url: #{@url}" unless @url.host
+      end
+    end
+
+    def initialize(**kwargs)
+      super
+      @path = GEM_ROOT.join("site_template")
+    end
+
+    def call(output_dir, **)
+      view_context = ViewContext.new(**)
+      output_dir = Pathname.new(output_dir).expand_path
+
+      Pathname.glob(@path.join("**/*"), File::FNM_DOTMATCH).each do |file|
+        build_file(file:, output_dir:, view_context:)
+      end
+    end
+
+    private
+
+    def build_file(file:, output_dir:, view_context:)
+      return if file.directory?
+
+      relative_path = file.relative_path_from(@path)
+      target = output_dir.join(relative_path)
+
+      # This handles files like:
+      # - index.html.erb -> index.html
+      # - site.erb -> site.rb
+      if target.extname == ".erb"
+        target = target.sub_ext("")
+        target = target.sub_ext(".rb") if target.extname == ""
+      end
+
+      build_template(file:, target:, view_context:)
+    end
+
+    def build_template(file:, target:, view_context:)
+      files.write(target, render_template(file, view_context))
+    end
+
+    def render_template(file, view_context)
+      return file.read unless file.extname == ".erb"
+
+      Tilt::ERBTemplate.new(file).render(view_context)
+    end
+  end
+end

data/lib/staticky/phlex/view_helpers.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Staticky
+  module Phlex
+    module ViewHelpers
+      def link_to(text, href, **, &block) # rubocop:disable Metrics/ParameterLists
+        block ||= proc { text }
+        href = Staticky.router.resolve(href).url
+
+        a(href:, **, &block)
+      end
+    end
+  end
+end
+
+Phlex::SGML.prepend Staticky::Phlex::ViewHelpers

data/lib/staticky/resource.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Staticky
+  Resource = Data.define(:url, :component) do
+    def full_filepath
+      Staticky.build_path.join(filepath)
+    end
+
+    def read
+      full_filepath.read
+    end
+
+    def filepath
+      root? ? "index.html" : "#{url}.html"
+    end
+
+    def root?
+      url == "/"
+    end
+
+    def build(view_context: ViewContext.new(self))
+      component.call(view_context:)
+    end
+  end
+end

data/lib/staticky/router/definition.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Staticky
+  class Router
+    class Definition
+      attr_reader :resources
+
+      def initialize
+        @routes_by_path = {}
+        @routes_by_component = {}
+        @resources = []
+      end
+
+      def match(path, to:)
+        component = to.then do |object|
+          object.is_a?(Class) ? object.new : object
+        end
+
+        @resources << resource = Resource.new(url: path, component:)
+        @routes_by_path[path] = resource
+        @routes_by_component[component.class] = resource
+      end
+
+      def root(to:)
+        match("/", to:)
+      end
+
+      def resolve(path)
+        @routes_by_path.fetch(path) { @routes_by_component.fetch(path) }
+      end
+
+      def delete(path)
+        @routes.delete(path)
+      end
+
+      def filepaths
+        @resources.map { |resource| rename_key(resource.url) }
+      end
+
+      private
+
+      def rename_key(key)
+        return "index.html" if key == "/"
+
+        "#{key}.html"
+      end
+    end
+  end
+end

data/lib/staticky/router.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Staticky
+  class Router
+    # DOCS: Holds routes as a class instance variable. This class is expected to
+    # be used as a singleton by requiring the "routes.rb" file.
+    #
+    # NOTE: Why do we need our own router? Why not just use Roda for these
+    # definitions? Roda is a routing tree and cannot be introspected easily.
+    # 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
+
+    def define(&block)
+      tap do
+        @definition.instance_eval(&block)
+      end
+    end
+
+    def filepaths
+      @definition.filepaths
+    end
+
+    def resources
+      @definition.resources
+    end
+
+    def resolve(path)
+      @definition.resolve(path)
+    end
+  end
+end

data/lib/staticky/server.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "roda"
+
+require_relative "../staticky"
+
+module Staticky
+  class Server < Roda
+    # This runs a local development server that serves the static files
+    # Require this in your config.ru file and run something like `rackup` to
+    # start the server
+
+    NotFound = Class.new(Staticky::Error)
+
+    plugin :common_logger, Staticky.server_logger, method: :debug
+    plugin :render, engine: "html"
+
+    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
+
+    route do |r|
+      Staticky.resources.each do |resource|
+        case resource.filepath
+        when "index.html"
+          r.root do
+            render(inline: resource.read)
+          end
+        else
+          r.get resource.url do
+            render(inline: resource.read)
+          end
+        end
+      end
+
+      # Need to return nil or Roda is unhappy
+      nil
+    end
+  end
+end