statique 0.1.0

data/lib/statique/cli/server.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+class Statique
+  class CLI
+    class Server
+      class LoggerWrapper
+        def <<(msg)
+          method, uri, status, time, content_type = msg.chomp.split(":")
+          log(:info, "#{method} #{uri}", status: status.to_i, time: time.to_f, content_type:)
+        end
+
+        def log(type, msg, attrs = {})
+          Statique.ui.public_send(type, msg, attrs.merge(app: "webrick"))
+        end
+
+        %i[unknown fatal error warn info debug].each do |type|
+          define_method(type) do |msg|
+            log(type, msg)
+          end
+
+          define_method(:"#{type}?") do
+            Statique.ui.compare_levels(Statique.ui.class.config.level, type.to_sym) != :lt
+          end
+        end
+      end
+
+      def initialize(port: 3000)
+        @port = port
+      end
+
+      def run
+        Statique.ui.info "Starting server", port: @port
+
+        logger = LoggerWrapper.new
+
+        Rack::Handler::WEBrick.run(Statique::App.freeze,
+          Port: @port,
+          Host: "localhost",
+          Logger: logger,
+          AccessLog: [[logger, "%m:%U:%s:%T:%{Content-Type}o"]])
+      end
+
+      def stop
+        Statique.ui.info "Stopping server"
+        Rack::Handler::WEBrick.shutdown
+      end
+
+      class EventStream
+        def initialize(type)
+          @type = type
+        end
+
+        def puts(message)
+          Statique.ui.public_send(@type, message)
+        end
+
+        def write(message)
+          puts(message)
+        end
+
+        def sync
+          true
+        end
+      end
+    end
+  end
+end

data/lib/statique/cli.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "thor"
+
+class Statique
+  class CLI < Thor
+    autoload :Server, "statique/cli/server"
+    autoload :Build, "statique/cli/build"
+    autoload :Init, "statique/cli/init"
+
+    package_name "Statique"
+
+    COMMAND_ALIASES = {
+      "version" => %w[-v --version]
+    }.freeze
+
+    def initialize(*args)
+      super
+    end
+
+    def self.exit_on_failure?
+      true
+    end
+
+    def self.aliases_for(command_name)
+      COMMAND_ALIASES.select { |k, _| k == command_name }.invert
+    end
+
+    desc "init", "Initialize new Statique website"
+    argument :name, optional: true, desc: "Name of the directory to initialise the Statique website in"
+    def init
+      Init.new(name).run
+    end
+
+    desc "server", "Start Statique server"
+    def server
+      Statique.mode.server!
+      Server.new.run
+    end
+
+    desc "build", "Build Statique site"
+    def build
+      Statique.mode.build!
+      Build.new(options.dup).run
+    end
+
+    desc "version", "Prints the statique's version information"
+    def version
+      Statique.ui.info "Statique v#{Statique::VERSION}"
+    end
+
+    map aliases_for("version")
+  end
+end

data/lib/statique/discover.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+class Statique
+  class Discover
+    attr_reader :documents, :collections, :files
+
+    SUPPORTED_EXTENSIONS = %w[
+      slim
+      md
+      builder
+    ].freeze
+
+    GLOB = "**/*.{#{SUPPORTED_EXTENSIONS.join(",")}}"
+
+    def initialize(root)
+      @root = root
+      @documents = []
+      @collections = Hashie::Mash.new { |hash, key| hash[key] = Set.new }
+
+      discover_files!
+      discover!
+
+      Statique.mode.build do
+        @files.freeze
+        @documents.freeze
+        @collections.freeze
+      end
+
+      watch_for_changes if Statique.mode.server?
+    end
+
+    private
+
+    def discover_files!
+      @files = @root.glob(GLOB)
+    ensure
+      Statique.ui.debug "Discovered files", count: @files.size
+    end
+
+    def discover!
+      @files.each do |file|
+        process(file)
+      end
+    end
+
+    def process(file)
+      document = Document.new(file)
+
+      documents << document
+
+      Array(document.meta.collection).each do |collection|
+        collections[collection] << document
+      end
+    end
+
+    def watch_for_changes
+      require "filewatcher"
+
+      @filewatcher = Filewatcher.new([Statique.paths.content, Statique.paths.layouts])
+      @filewatcher_thread = Thread.new(@filewatcher) do |watcher|
+        watcher.watch do |file, event|
+          Statique.ui.debug "File change event", file: file, event: event
+          discover_files!
+          path = Pathname.new(file)
+          remove_file!(path)
+          process(path) unless event == :deleted
+        end
+      end
+      Statique.ui.debug "Started file watcher", filewatcher: @filewatcher, thread: @filewatcher_thread
+
+      at_exit do
+        Statique.ui.debug "Closing file watcher", thread: @filewatcher_thread
+        @filewatcher.stop
+        @filewatcher.finalize
+        @filewatcher_thread.join
+      end
+    end
+
+    def remove_file!(path)
+      documents.delete_if { _1.file == path }
+      collections.each_value do |collection|
+        # TODO: See if set can index by some particular property to avoid looping
+        collection.delete_if { _1.file == path }
+      end
+    end
+  end
+end

data/lib/statique/document.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require "hashie"
+
+class Statique
+  class Document
+    attr_reader :file, :meta, :content
+
+    def initialize(file)
+      parsed = FrontMatterParser::Parser.parse_file(file)
+      @file, @meta, @content = file.freeze, Hashie::Mash.new(parsed.front_matter).freeze, parsed.content.freeze
+    end
+
+    def path
+      case basename
+      when "index.slim" then "/"
+      when "index.md" then "/"
+      else
+        "/#{meta.permalink || basename.delete_suffix(extname).delete_prefix(Statique.paths.content.to_s)}"
+      end.freeze
+    end
+
+    def view_name
+      basename.delete_suffix(extname).freeze
+    end
+
+    def engine_name
+      extname.delete_prefix(".").freeze
+    end
+
+    def layout_name
+      meta.fetch("layout") { "layout" }.freeze
+    end
+
+    def title
+      meta.title.freeze
+    end
+
+    def body
+      content
+    end
+
+    def pagination_pages
+      return unless Statique.discover.collections.key?(meta.paginates)
+      collection = Statique.discover.collections[meta.paginates]
+      (collection.size.to_f / Pagy::DEFAULT[:items]).ceil
+    end
+
+    def published_at
+      @published_at ||= file.ctime.freeze
+    end
+
+    private
+
+    def basename
+      @basename ||= file.basename.to_s.freeze
+    end
+
+    def extname
+      @extname ||= file.extname.to_s.freeze
+    end
+  end
+end

data/lib/statique/mode.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+class Statique
+  class Mode
+    MODE_BUILD = "build"
+    MODE_SERVER = "server"
+    MODES = [MODE_BUILD, MODE_SERVER].freeze
+
+    def initialize(mode = MODE_SERVER)
+      raise ArgumentError, "Mode can't be empty" if mode.nil? || mode.empty?
+      raise ArgumentError, "Mode must be one of #{MODES}" unless MODES.include?(mode.to_s)
+
+      @mode = mode == MODE_SERVER ? MODE_SERVER : MODE_BUILD
+    end
+
+    def server!
+      @mode = MODE_SERVER
+    end
+
+    def build!
+      @mode = MODE_BUILD
+    end
+
+    def server?
+      @mode == MODE_SERVER
+    end
+
+    def build?
+      @mode == MODE_BUILD
+    end
+
+    def server
+      yield if server?
+    end
+
+    def build
+      yield if build?
+    end
+  end
+end

data/lib/statique/paginator.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+class Statique
+  class Paginator
+    attr_reader :documents
+
+    def initialize(pagy, documents, path)
+      @pagy, @documents, @path = pagy, documents, path
+    end
+
+    def page
+      @pagy.page
+    end
+
+    def total_pages
+      @pagy.pages
+    end
+
+    def total_documents
+      @pagy.count
+    end
+
+    def previous_page
+      @pagy.prev
+    end
+
+    def previous_page_path
+      page_path(@pagy.prev)
+    end
+
+    def next_page
+      @pagy.next
+    end
+
+    def next_page_path
+      page_path(@pagy.next)
+    end
+
+    def per_page
+      @pagy.items
+    end
+
+    private
+
+    def page_path(page)
+      return unless page
+
+      if page == 1
+        Statique.url(File.join(@path))
+      else
+        Statique.url(File.join(@path, "page", page.to_s))
+      end
+    end
+  end
+end

data/lib/statique/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Statique
+  VERSION = "0.1.0"
+end

data/lib/statique.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "front_matter_parser"
+require "hashie"
+require "pathname"
+require "pagy"
+require "rack"
+require "tty-logger"
+require "dry-configurable"
+
+::FrontMatterParser::SyntaxParser::Builder = FrontMatterParser::SyntaxParser::MultiLineComment["=begin", "=end"]
+
+$LOAD_PATH.unshift(File.expand_path("..", __FILE__))
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect(
+  "cli" => "CLI"
+)
+loader.setup
+
+class Statique
+  extend Dry::Configurable
+
+  class Error < StandardError; end
+
+  setting :paths, reader: true do
+    setting :pwd, default: Pathname.pwd, constructor: -> { Pathname(_1) }
+    setting :public, default: Pathname.pwd.join("public"), constructor: -> { Statique.pwd.join(_1) }
+    setting :content, default: Pathname.pwd.join("content"), constructor: -> { Statique.pwd.join(_1) }
+    setting :layouts, default: Pathname.pwd.join("layouts"), constructor: -> { Statique.pwd.join(_1) }
+    setting :assets, default: Pathname.pwd.join("assets"), constructor: -> { Statique.pwd.join(_1) }
+    setting :destination, default: Pathname.pwd.join("dist"), constructor: -> { Statique.pwd.join(_1) }
+  end
+  setting :root_url, default: "/", reader: true
+
+  class << self
+    def discover
+      @discover ||= Discover.new(paths.content)
+    end
+
+    def mode
+      @mode ||= Mode.new
+    end
+
+    def pwd
+      @pwd ||= Pathname.pwd.freeze
+    end
+
+    def version
+      VERSION
+    end
+
+    def ui
+      @ui ||= TTY::Logger.new(output: $stdout) do |config|
+        config.level = :debug if ENV["DEBUG"] == "true"
+      end
+    end
+
+    def url(document_or_path)
+      File.join(root_url, document_or_path.is_a?(Document) ? document_or_path.path : document_or_path)
+    end
+
+    def build_queue
+      @build_queue ||= Queue.new
+    end
+  end
+end

data/lib/templates/index.md

@@ -0,0 +1,5 @@
+## Welcome
+
+Hello from Statique!
+
+Find me in `content/index.md`.

data/lib/templates/layout.slim

@@ -0,0 +1,13 @@
+doctype html
+html
+  head
+    meta charset="UTF-8"
+    meta name="generator" content="Statique #{Statique.version}"
+    title Statique Website
+    == assets(:css)
+    == assets(:js)
+  body
+    header
+      h1 Statique Website
+    main== yield
+    footer Made with Statique v#{Statique.version}

data/sig/statique/mode.rbs

@@ -0,0 +1,16 @@
+class Statique
+  class Mode
+    MODE_BUILD: "build"
+    MODE_SERVER: "server"
+    MODES: ["build", "server"]
+    @mode: "build" | "server"
+
+    def initialize: (?mode: "build" | "server") -> void
+    def server!: -> "server"
+    def build!: -> "build"
+    def server?: -> bool
+    def build?: -> bool
+    def server: -> nil
+    def build: -> nil
+  end
+end

data/sig/statique/version.rbs

@@ -0,0 +1,3 @@
+class Statique
+  VERSION: String
+end

data/sig/statique.rbs

@@ -0,0 +1,4 @@
+class Statique
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/statique.gemspec

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "lib/statique/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "statique"
+  spec.version = Statique::VERSION
+  spec.authors = ["Piotr Usewicz"]
+  spec.email = ["piotr@layer22.com"]
+
+  spec.summary = "Static website generator"
+  spec.description = "Statique is a static website generator written in Ruby using Roda"
+  spec.homepage = "https://github.com/pusewicz/statique"
+  spec.license = "MIT"
+  spec.required_ruby_version = ">= 2.6.0"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/pusewicz/statique"
+  spec.metadata["changelog_uri"] = "https://raw.githubusercontent.com/pusewicz/statique/v#{spec.version}/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency "builder", "~> 3.2.4"
+  spec.add_dependency "commonmarker", "~> 0.23.2"
+  spec.add_dependency "dry-configurable", "~> 0.14.0"
+  spec.add_dependency "filewatcher", "~> 1.1.1"
+  spec.add_dependency "front_matter_parser", "~> 1.0.1"
+  spec.add_dependency "hashie", "~> 5.0.0"
+  spec.add_dependency "memo_wise", "~> 1.6.0"
+  spec.add_dependency "pagy", "~> 5.9.3"
+  spec.add_dependency "rack-rewrite", "~> 1.5.1"
+  spec.add_dependency "roda", "~> 3.52"
+  spec.add_dependency "sassc", "~> 2.4.0"
+  spec.add_dependency "slim", "~> 4.1.0"
+  spec.add_dependency "thor", "~> 1.2.1"
+  spec.add_dependency "tilt", "~> 2.0.10"
+  spec.add_dependency "tty-logger", "~> 0.6.0"
+  spec.add_dependency "webrick", "~> 1.7.0"
+  spec.add_dependency "zeitwerk", "~> 2.5.4"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end