purity 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: aa91bae52c808d7124074905c5ab0b1f69c1d46e8e7390f5e1bf0392d66c5112
+  data.tar.gz: 2a8794641f2a09e56f80a1d878b6f72fb21e99cc3f7fd397b958f0ae0c472bd2
+SHA512:
+  metadata.gz: 6824c06ce5a20b9209a43ad4d6cb23593f0b015117d55761205dd839da144740cee3ecac321ebbe2fb0b25ba12187d9c7928efb83cf70eb9663410c2b6a0c86e
+  data.tar.gz: c7569a15cdb6e316e78b310199a362022510c2cffab07ac21d4e51d810af07d82256d9941a55587c880c9a0f0b8fbfe98ad33d47ea8b8ba53d5dab57b435d973

data/exe/purity

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "purity"
+
+Purity::CLI.run

data/lib/purity/cli.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module Purity
+
+  class CLI
+    class << self
+      def run(args = ARGV.dup)
+        include_drafts = !!args.delete("--drafts")
+
+        case args[0]
+        when "new", "n"
+          new_site(args[1])
+        when "serve", "s"
+          ENV["PURITY_ENV"] ||= "development"
+          port = args[1] ? args[1].to_i : 4567
+          Site.new.serve(port: port)
+        when "watch", "w"
+          ENV["PURITY_ENV"] ||= "development"
+          port = args[1] ? args[1].to_i : 4567
+          Site.new.watch(port: port)
+        when "help", "h", "-h", "--help"
+          help
+        when "version", "-v", "--version"
+          puts("purity #{VERSION}")
+        else
+          ENV["PURITY_ENV"] ||= "production"
+          Site.new.build(include_drafts: include_drafts)
+        end
+      end
+
+      private
+
+      def new_site(dir)
+        unless dir
+          puts("usage: purity new <directory>")
+          return
+        end
+        Scaffold.new(dir).run
+      end
+
+      def help
+        puts("purity #{VERSION}")
+        puts("")
+        puts("usage: purity [command] [options]")
+        puts("")
+        puts("commands:")
+        puts("  new <dir>     create a new site")
+        puts("  (none)        build the site")
+        puts("  serve, s      build and serve on localhost")
+        puts("  watch, w      build, serve, and rebuild on changes")
+        puts("  help, h       this message")
+        puts("  version       show version")
+        puts("")
+        puts("options:")
+        puts("  --drafts      include pages with draft: true")
+        puts("  [port]        port for serve/watch (default: 4567)")
+        puts("")
+        puts("template variables:")
+        puts("  site.title          from _site.yml")
+        puts("  page.title          from front matter")
+        puts("  page.url            clean URL path of the current page")
+        puts("  page.content        rendered page body (in layouts)")
+        puts("  data.nav            from _data/nav.yml")
+        puts("  data.posts          configured collection")
+        puts("  data.pages          all non-standalone, non-draft pages")
+        puts("")
+        puts("front matter:")
+        puts("  layout: name    use _name.html (default: _layout.html)")
+        puts("  layout: false   copy file as-is, no layout")
+        puts("  draft: true     skip unless --drafts")
+        puts("  date: YYYY-MM-DD  date for feed generation")
+        puts("  permalink: /p/  custom output path")
+        puts("")
+        puts("config (_site.yml):")
+        puts("  url: https://...      enables sitemap + feed generation")
+        puts("  site_name: My Site    used in feed title")
+        puts("  clean_urls: true      rewrite to clean URLs (default)")
+        puts("  strict_variables: true  raise on undefined variables")
+        puts("  collections:          directory-based collections")
+        puts("    posts:")
+        puts("      sort_by: date")
+        puts("      order: desc")
+        puts("  environments:         per-environment overrides")
+        puts("    production:")
+        puts("      strict_variables: false")
+        puts("")
+        puts("plugins (src/_plugins/*.rb):")
+        puts("  hook :after_parse  { |config, pages| }")
+        puts("  hook :before_render { |ctx, rel| }")
+        puts("  hook :before_layout { |content, meta, ctx| content }")
+        puts("  hook :after_render { |html, ctx, rel| html }")
+        puts("  hook :after_build  { |config, dest| }")
+      end
+    end
+  end
+end

data/lib/purity/context.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Purity
+  class UndefinedVariableError < StandardError; end
+
+  class Context
+    def initialize(data, strict: false)
+      @data = data || {}
+      @strict = strict
+    end
+
+    def [](key)
+      wrap(@data[key.to_s])
+    end
+
+    def []=(key, value)
+      @data[key.to_s] = value
+    end
+
+    def key?(key)
+      @data.key?(key.to_s)
+    end
+
+    def merge(other)
+      self.class.new(@data.merge(other.transform_keys(&:to_s)), strict: @strict)
+    end
+
+    def method_missing(name, *args)
+      key = name.to_s
+      if @data.key?(key)
+        wrap(@data[key])
+      elsif @strict
+        raise UndefinedVariableError, "undefined variable: #{key}"
+      else
+        nil
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      true
+    end
+
+    def to_s
+      ""
+    end
+
+    private
+
+    def wrap(val)
+      case val
+      when Hash then self.class.new(val, strict: @strict)
+      when Array then val.map { |v| v.is_a?(Hash) ? self.class.new(v, strict: @strict) : v }
+      else val
+      end
+    end
+  end
+end

data/lib/purity/data_store.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Purity
+  class DataStore
+    def initialize(dir, strict: false)
+      @dir = dir
+      @cache = {}
+      @strict = strict
+    end
+
+    def [](key)
+      raw = raw_get(key.to_s)
+      wrap(raw)
+    end
+
+    def []=(key, value)
+      @cache[key.to_s] = value
+    end
+
+    def key?(key)
+      @cache.key?(key.to_s) || !!find_file(key.to_s)
+    end
+
+    def empty?
+      !Dir.exist?(@dir) || Dir.glob(File.join(@dir, "**/*.{yml,yaml,json}")).empty?
+    end
+
+    def to_s
+      ""
+    end
+
+    def method_missing(name, *args)
+      key = name.to_s
+      if @cache.key?(key) || find_file(key)
+        self[key]
+      elsif @strict
+        raise UndefinedVariableError, "undefined data key: #{key}"
+      else
+        nil
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      true
+    end
+
+    private
+
+    def raw_get(key)
+      return @cache[key] if @cache.key?(key)
+      path = find_file(key)
+      return nil unless path
+      @cache[key] = parse(path)
+    end
+
+    def find_file(key)
+      base = File.join(@dir, key.tr(".", "/"))
+      %w[.yml .yaml .json].each do |ext|
+        path = "#{base}#{ext}"
+        return path if File.exist?(path)
+      end
+      nil
+    end
+
+    def parse(path)
+      content = File.read(path)
+      if path.end_with?(".json")
+        JSON.parse(content)
+      else
+        YAML.safe_load(content, permitted_classes: [Date])
+      end
+    end
+
+    def wrap(val)
+      case val
+      when Hash then Context.new(val, strict: @strict)
+      when Array then val.map { |v| v.is_a?(Hash) ? Context.new(v, strict: @strict) : v }
+      else val
+      end
+    end
+  end
+end

data/lib/purity/plugins/feed.rb

@@ -0,0 +1,30 @@
+hook :after_build do |config, dest|
+  next unless config["url"]
+
+  url = config["url"].chomp("/")
+  posts = config["data"]["pages"]
+    .select { |p| p["date"] }
+    .sort_by { |p| p["date"].to_s }
+    .reverse
+    .first(20)
+
+  doc = REXML::Document.new
+  doc << REXML::XMLDecl.new("1.0", "UTF-8")
+  rss = doc.add_element("rss", "version" => "2.0")
+  channel = rss.add_element("channel")
+  channel.add_element("title").add_text(config["site_name"].to_s)
+  channel.add_element("link").add_text(url)
+  channel.add_element("description").add_text(config["description"].to_s)
+
+  posts.each do |p|
+    item = channel.add_element("item")
+    item.add_element("title").add_text(p["title"].to_s)
+    item.add_element("link").add_text("#{url}#{p["url"]}")
+    item.add_element("pubDate").add_text(p["date"].to_s)
+  end
+
+  out = +""
+  doc.write(out, 2)
+  File.write(File.join(dest, "feed.xml"), out << "\n")
+  puts("  feed.xml")
+end

data/lib/purity/plugins/sitemap.rb

@@ -0,0 +1,18 @@
+hook :after_build do |config, dest|
+  next unless config["url"]
+
+  url = config["url"].chomp("/")
+  pages = config["data"]["pages"]
+
+  doc = REXML::Document.new
+  doc << REXML::XMLDecl.new("1.0", "UTF-8")
+  urlset = doc.add_element("urlset", "xmlns" => "http://www.sitemaps.org/schemas/sitemap/0.9")
+  pages.each do |page|
+    urlset.add_element("url").add_element("loc").add_text("#{url}#{page["url"]}")
+  end
+
+  out = +""
+  doc.write(out, 2)
+  File.write(File.join(dest, "sitemap.xml"), out << "\n")
+  puts("  sitemap.xml")
+end

data/lib/purity/render_context.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Purity
+  class RenderContext
+    def initialize(site:, context: {}, content_for_blocks: {}, strict: false)
+      @_site = site
+      @_context = context
+      @_content_for = content_for_blocks
+      @_strict = strict
+      @_erbout = +""
+      extend(site.helpers_module) if site.helpers_module
+    end
+
+    def content_for(name, &block)
+      key = name.to_s
+      if block
+        @_content_for[key] = capture(&block)
+        ""
+      else
+        @_content_for[key] || ""
+      end
+    end
+
+    def content_for?(name)
+      @_content_for.key?(name.to_s) && !@_content_for[name.to_s].empty?
+    end
+
+    def partial(name, **locals)
+      path = File.join(@_site.src, name)
+      return "" unless File.exist?(path)
+      _, body = @_site.send(:parse, path)
+      merged = @_context.dup
+      merged[:page] = (merged[:page] || {}).merge(locals.transform_keys(&:to_s))
+      @_site.send(:erb_render, body, context: merged, content_for_blocks: @_content_for)
+    end
+
+    def get_binding
+      binding
+    end
+
+    def method_missing(name, *args)
+      if @_strict
+        raise UndefinedVariableError, "undefined variable: #{name}"
+      else
+        nil
+      end
+    end
+
+    def respond_to_missing?(name, include_private = false)
+      true
+    end
+
+    private
+
+    def capture(&block)
+      old = @_erbout
+      @_erbout = +""
+      block.call
+      result = @_erbout
+      @_erbout = old
+      result
+    end
+  end
+end

data/lib/purity/scaffold.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Purity
+
+  class Scaffold
+    def initialize(dir)
+      @dir = File.expand_path(dir)
+      @src = File.join(@dir, "src")
+    end
+
+    def run
+      if Dir.exist?(@dir) && !Dir.empty?(@dir)
+        puts("#{@dir} already exists and is not empty")
+        return false
+      end
+
+      create_directories
+      create_gemfile
+      create_site_config
+      create_layout
+      create_index
+      puts("created #{@dir}")
+      puts("  cd #{File.basename(@dir)} && purity watch")
+      true
+    end
+
+    private
+
+    def create_directories
+      FileUtils.mkdir_p(File.join(@src, "_plugins"))
+      FileUtils.mkdir_p(File.join(@src, "_helpers"))
+    end
+
+    def create_gemfile
+      File.write(File.join(@dir, "Gemfile"), <<~RUBY)
+        source "https://rubygems.org"
+
+        gem "purity"
+      RUBY
+    end
+
+    def create_site_config
+      File.write(File.join(@src, "_site.yml"), <<~YAML)
+        site_name: my site
+        description: a site built with purity
+      YAML
+    end
+
+    def create_layout
+      File.write(File.join(@src, "_layout.html"), <<~'HTML')
+        <!doctype html>
+        <html lang="en">
+        <head>
+          <meta charset="utf-8">
+          <meta name="viewport" content="width=device-width, initial-scale=1">
+          <title><%= page.title %></title>
+          <%= content_for :head %>
+        </head>
+        <body>
+          <%= page.content %>
+          <%= content_for :scripts %>
+        </body>
+        </html>
+      HTML
+    end
+
+    def create_index
+      File.write(File.join(@src, "index.html"), <<~'HTML')
+        ---
+        title: home
+        ---
+        <h1><%= page.title %></h1>
+        <p>edit src/index.html to get started.</p>
+      HTML
+    end
+  end
+end

data/lib/purity/server.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Purity
+
+  module Server
+    def serve(port: 4567)
+      build
+      server = make_server(port: port)
+      puts("serving at http://localhost:#{port}")
+      trap("INT") { server.shutdown }
+      server.start
+    end
+
+    def watch(port: 4567)
+      @livereload = true
+      build
+      @build_time = Time.now.to_i
+      server = make_server(port: port)
+      server.mount_proc("/__livereload") do |_, res|
+        res.content_type = "text/plain"
+        res.body = @build_time.to_s
+      end
+      puts("watching #{src}/ and serving at http://localhost:#{port}")
+      start_watcher
+      trap("INT") { server.shutdown }
+      server.start
+    end
+
+    private
+
+    def make_server(port:)
+      dest_dir = dest
+      server = WEBrick::HTTPServer.new(Port: port, Logger: WEBrick::Log.new("/dev/null"), AccessLog: [])
+      server.mount_proc("/") do |req, res|
+        path = req.path.chomp("/")
+        base = File.join(dest_dir, path)
+        found = [base, "#{base}.html", File.join(base, "index.html")].find { |f| File.file?(f) }
+        if found
+          res.body = File.binread(found)
+          res.content_type = WEBrick::HTTPUtils.mime_type(found, WEBrick::HTTPUtils::DefaultMimeTypes)
+        else
+          res.status = 404
+          custom_404 = File.join(dest_dir, "404.html")
+          if File.file?(custom_404)
+            res.body = File.binread(custom_404)
+            res.content_type = "text/html"
+          else
+            res.body = "not found"
+          end
+        end
+      end
+      server
+    end
+
+    def start_watcher
+      mtimes = {}
+      Dir.glob(File.join(src, "**/*")).select { |f| File.file?(f) }.each { |f| mtimes[f] = File.mtime(f) }
+      Thread.new do
+        loop do
+          sleep(1)
+          changed = false
+          Dir.glob(File.join(src, "**/*")).select { |f| File.file?(f) }.each do |f|
+            mt = File.mtime(f)
+            if mtimes[f] != mt
+              mtimes[f] = mt
+              changed = true
+            end
+          end
+          if changed
+            puts("rebuilding...")
+            build
+            @build_time = Time.now.to_i
+          end
+        end
+      end
+    end
+
+    def inject_livereload(html:)
+      script = "<script>(function(){var t;setInterval(function(){fetch('/__livereload').then(function(r){return r.text()}).then(function(s){if(t&&s!==t)location.reload();t=s})},1000)})()</script>"
+      html.sub("</body>", "#{script}\n</body>")
+    end
+  end
+end

data/lib/purity/site.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+module Purity
+
+  class Site
+    include Template
+    include Server
+
+    attr_reader :src, :dest, :config, :helpers_module
+
+    def initialize(src: nil, dest: nil)
+      @src = File.expand_path(src || "src")
+      @dest_override = dest
+      @hooks = Hash.new { |h, k| h[k] = [] }
+      @livereload = false
+      @build_time = 0
+    end
+
+    def hook(name, &block)
+      @hooks[name] << block
+    end
+
+    def build(include_drafts: false)
+      load_plugins
+      load_helpers
+      @config = load_site
+      @dest = File.expand_path(@dest_override || @config.delete("dest") || "build")
+      env = ENV.fetch("PURITY_ENV", "development")
+      @config["env"] = env
+      merge_env_config(env)
+      strict = @config.fetch("strict_variables", false)
+      @config["data"] = DataStore.new(File.join(@src, "_data"), strict: strict)
+
+      parsed = collect_pages(include_drafts: include_drafts)
+
+      all_pages = parsed.filter_map do |rel, meta, _|
+        next if meta["layout"].to_s == "false"
+        next if meta["draft"]
+        path = output_path(rel: rel, meta: meta)
+        page_url = "/#{path}".sub(/index\.html$/, "")
+        meta.merge("rel" => rel, "url" => page_url)
+      end
+
+      @config["data"]["pages"] = all_pages
+      build_collections(parsed: parsed)
+
+      @hooks[:after_parse].each { |fn| fn.call(@config, parsed) }
+
+      parsed.each do |rel, meta, body|
+        path = output_path(rel: rel, meta: meta)
+        page_url = "/#{path}".sub(/index\.html$/, "")
+
+        page_hash = meta.merge(
+          "url" => page_url,
+          "og_title" => meta["og_title"] || meta["title"],
+          "og_description" => meta["og_description"] || meta["description"]
+        )
+
+        ctx = { site: @config, page: page_hash, data: @config["data"] }
+        @hooks[:before_render].each { |fn| fn.call(ctx, rel) }
+        html = render_page(meta: meta, body: body, context: ctx)
+        html = @hooks[:after_render].reduce(html) { |h, fn| fn.call(h, ctx, rel) }
+        html = inject_livereload(html: html) if @livereload
+        write_output(html: html, rel: path)
+        label = meta["layout"].to_s == "false" ? " (standalone)" : ""
+        puts("  #{path}#{label}")
+      end
+
+      copied = copy_assets
+      @hooks[:after_build].each { |fn| fn.call(@config, @dest) }
+      stats = "built #{parsed.length} pages"
+      stats += ", copied #{copied} assets" if copied > 0
+      puts(stats)
+    end
+
+    private
+
+    attr_reader :hooks
+
+    def load_plugins
+      @hooks.clear
+      builtin = File.join(File.dirname(__FILE__), "plugins")
+      Dir.glob(File.join(builtin, "*.rb")).sort.each { |f| instance_eval(File.read(f), f) }
+      Dir.glob(File.join(@src, "_plugins", "*.rb")).sort.each { |f| instance_eval(File.read(f), f) }
+    end
+
+    def load_helpers
+      @helpers_module = Module.new
+      Dir.glob(File.join(@src, "_helpers", "*.rb")).sort.each do |f|
+        @helpers_module.module_eval(File.read(f), f)
+      end
+    end
+
+    def load_site
+      path = File.join(@src, "_site.yml")
+      config = File.exist?(path) ? YAML.safe_load(File.read(path), permitted_classes: [Date]) || {} : {}
+      config
+    end
+
+    def merge_env_config(env)
+      envs = @config.delete("environments") || {}
+      env_config = envs[env] || {}
+      @config.merge!(env_config)
+    end
+
+    def parse(path)
+      raw = File.read(path)
+      return [{}, raw] unless raw.start_with?("---\n")
+
+      parts = raw.split("---\n", 3)
+      [YAML.safe_load(parts[1], permitted_classes: [Date]) || {}, parts[2] || ""]
+    end
+
+    def collect_pages(include_drafts:)
+      Dir.glob(File.join(@src, "**/*.{html,md}"))
+        .reject { |f| File.basename(f).start_with?("_") }
+        .sort
+        .filter_map do |path|
+          rel = path.sub("#{@src}/", "")
+          meta, body = parse(path)
+          meta["format"] = File.extname(rel).delete_prefix(".")
+          rel = rel.sub(/\.md$/, ".html")
+          next if meta["draft"] && !include_drafts
+          meta["excerpt"] ||= extract_excerpt(body)
+          [rel, meta, body]
+        end
+    end
+
+    def extract_excerpt(body)
+      if body.include?("<!-- more -->")
+        body.split("<!-- more -->", 2).first.strip
+      else
+        first_para = body.strip.split(/\n\n/, 2).first
+        first_para&.strip || ""
+      end
+    end
+
+    def build_collections(parsed:)
+      collections_config = @config.fetch("collections", {})
+      return unless collections_config
+
+      collections_config.each do |name, opts|
+        opts ||= {}
+        items = parsed.filter_map do |rel, meta, _|
+          next unless rel.start_with?("#{name}/")
+          next if meta["draft"]
+          path = output_path(rel: rel, meta: meta)
+          page_url = "/#{path}".sub(/index\.html$/, "")
+          meta.merge("rel" => rel, "url" => page_url)
+        end
+        if opts["sort_by"]
+          items.sort_by! { |p| p[opts["sort_by"]].to_s }
+          items.reverse! if opts["order"] == "desc"
+        end
+        @config["data"][name] = items
+      end
+    end
+
+    def output_path(rel:, meta:)
+      if meta["permalink"]
+        p = meta["permalink"].sub(/^\//, "")
+        return "index.html" if p.empty?
+        return p.end_with?("/") ? "#{p}index.html" : p
+      end
+
+      return rel unless @config.fetch("clean_urls", true)
+      return rel if File.basename(rel) == "index.html"
+      return rel if File.basename(rel, ".html").match?(/\A\d{3}\z/)
+
+      rel.sub(/\.html$/, "/index.html")
+    end
+
+    def write_output(html:, rel:)
+      out = File.join(@dest, rel)
+      FileUtils.mkdir_p(File.dirname(out))
+      File.write(out, html)
+    end
+
+    def copy_assets
+      count = 0
+      Dir.glob(File.join(@src, "**/*"), File::FNM_DOTMATCH)
+        .select { |f| File.file?(f) }
+        .each do |path|
+          rel = path.sub("#{@src}/", "")
+          next if rel.end_with?(".html", ".md")
+          next if rel.split("/").any? { |seg| seg.start_with?("_") }
+
+          out = File.join(@dest, rel)
+          FileUtils.mkdir_p(File.dirname(out))
+          FileUtils.cp(path, out)
+          count += 1
+        end
+      count
+    end
+
+  end
+end

data/lib/purity/template.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Purity
+  module Template
+    def render(body:, context:)
+      erb_render(body, context: context)
+    end
+
+    def render_page(meta:, body:, context:)
+      return body if meta["layout"].to_s == "false"
+
+      captured = {}
+      context[:page]["content"] = erb_render(body, context: context, content_for_blocks: captured)
+      context[:page]["content"] = @hooks[:before_layout].reduce(context[:page]["content"]) { |c, fn| fn.call(c, meta, context) }
+      apply_layout(meta: meta, context: context, content_for_blocks: captured)
+    end
+
+    private
+
+    def erb_render(body, context:, content_for_blocks: {})
+      strict = (context[:site] || {}).fetch("strict_variables", false)
+      ctx = RenderContext.new(site: self, context: context, content_for_blocks: content_for_blocks, strict: strict)
+      b = ctx.get_binding
+      b.local_variable_set(:site, Context.new(context[:site] || {}, strict: strict))
+      b.local_variable_set(:page, Context.new(context[:page] || {}, strict: strict))
+      b.local_variable_set(:data, context[:data]) if context[:data]
+      ERB.new(body, trim_mode: "-", eoutvar: "@_erbout").result(b)
+    end
+
+    def apply_layout(meta:, context:, content_for_blocks: {})
+      layout_name = meta.key?("layout") ? meta["layout"] : "layout"
+      lpath = File.join(src, "_#{layout_name}.html")
+      return context[:page]["content"] unless File.exist?(lpath)
+
+      lmeta, lbody = parse(lpath)
+      result = erb_render(lbody, context: context, content_for_blocks: content_for_blocks)
+      while lmeta["layout"]
+        context[:page]["content"] = result
+        lp = File.join(src, "_#{lmeta['layout']}.html")
+        break unless File.exist?(lp)
+        lmeta, lbody = parse(lp)
+        result = erb_render(lbody, context: context, content_for_blocks: content_for_blocks)
+      end
+      result
+    end
+  end
+end

data/lib/purity/version.rb

@@ -0,0 +1,3 @@
+module Purity
+  VERSION = "1.0.0"
+end

data/lib/purity.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "yaml"
+require "date"
+require "json"
+require "webrick"
+require "erb"
+require "rexml/document"
+
+require "purity/version"
+require "purity/context"
+require "purity/data_store"
+require "purity/render_context"
+require "purity/template"
+require "purity/server"
+require "purity/site"
+require "purity/scaffold"
+require "purity/cli"

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: purity
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Josh Brody
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: webrick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: templates, partials, conditionals, loops, layouts, blog, plugins. nothing
+  else.
+email: josh@josh.mn
+executables:
+- purity
+extensions: []
+extra_rdoc_files: []
+files:
+- exe/purity
+- lib/purity.rb
+- lib/purity/cli.rb
+- lib/purity/context.rb
+- lib/purity/data_store.rb
+- lib/purity/plugins/feed.rb
+- lib/purity/plugins/sitemap.rb
+- lib/purity/render_context.rb
+- lib/purity/scaffold.rb
+- lib/purity/server.rb
+- lib/purity/site.rb
+- lib/purity/template.rb
+- lib/purity/version.rb
+homepage: https://github.com/joshmn/purity
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.1
+specification_version: 4
+summary: a simple static site generator
+test_files: []