vizbuilder 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 51f92c1fd3944056565422dd247601a8b15ba9e5e173edd596689b1511469e39
+  data.tar.gz: '029ed027b6ca7620051c6a3003f6d4dcb646faf9cb7699af5dda3bddf56be122'
+SHA512:
+  metadata.gz: 4f46a7be4d80cf2f2cc1b4b77d667ace49f540896397b0509aaca1149df7a0ef711b56b7d51dc26f9d390d33f69138d215759f860417c3671c261024383f4aeb
+  data.tar.gz: a9af4e089431d541b393a2b881d7a446d03a6597b858f0cf2c59d3d9b380a80d85b1c968c8c23006801fe74c08a25f6a7eda7372ec3dd7d8208763a7c5ac876e

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.gem
+.DS*

data/.rubocop.yml

@@ -0,0 +1,53 @@
+AllCops:
+  Include:
+    - '**/Rakefile'
+    - '*gemspec'
+    - '**/*.rb'
+
+Style/GuardClause:
+  Enabled: false
+
+Style/FileName:
+  Enabled: false
+
+Style/LineLength:
+  Max: 100
+
+Style/NumericLiterals:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/SignalException:
+  EnforcedStyle: only_raise
+
+Style/ClassLength:
+  Enabled: false
+
+Style/MethodLength:
+  Enabled: false
+
+Style/GuardClause:
+  Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Style/Alias:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Layout/EmptyLineAfterGuardClause:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in autotune-client.gemspec
+gemspec
+
+gem 'pry'
+gem 'rubocop'

data/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2019, Vox Media, Inc., Ryan Mark
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the {organization} nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,331 @@
+A fast, simple static site builder, inspired by [Middleman](https://middlemanapp.com/). Built for news.
+
+## Why another static site generator?
+
+We've been using Middleman in Vox Media newsrooms for many years to build static articles and embeddable interactives. But as we've built larger projects and projects that require frequent updates, we've found that Middleman's extensive dependencies and complexity can cause high resource use and long build times. This is not a criticism of Middleman, Middleman is great and you should use it if it does what you need.
+
+We need something simple and fast. Something that provides only the functionality we need and uses a few simple dependencies.
+
+This is a simple ruby library and doesn't include any setup or project creation tools. If you want a helpful setup wizard or an ecosystem of extensions and tooling, checkout Middleman or a different static site generator.
+
+## Quick Start
+
+Viz Builder is a simple library that leaves it to you to load and invoke it. There is no shell command for running it or setting up a new project.
+
+To your project's `Gemfile`, add:
+
+```ruby
+gem 'vizbuilder'
+```
+
+Then in a new or existing file, you will `require` it, configure it and either run as a development server or to create static html and assets ready for upload.
+
+Here is an example file `app.rb` that will load, configure and run Viz Builder:
+
+```ruby
+require 'vizbuilder'
+
+app = VizBuilder.new do
+  set :some_global_config_thing, 'hello world'
+  add_page 'index.html', template: 'index.html.erb'
+end
+
+# if run with the argument `runserver` run as a development server
+if ARGV[0] == 'runserver'
+  app.runserver
+else
+  app.build
+end
+```
+
+And then execute your app:
+
+```
+$ bundle exec ruby app.rb runserver
+```
+
+## Data
+
+Viz Builder manages configuration, sitemap and project data in three hashes that you can access directly in templates or the configuration block.
+
+Configuration variables added via the `set` method and can be accessed in the `config` Hash:
+
+```ruby
+set :foo, 'bar'
+config[:foo] == 'bar'
+```
+
+Data variables can be added via the `add_data` method and can be accessed in the `data` Hash:
+
+```ruby
+add_data :scraped, foo: 'bar'
+data[:scraped] == { foo: 'bar' }
+# data[:scraped][:foo]
+#   or
+# data.dig(:scraped, :foo)
+```
+
+Viz Builder automatically loads all JSON and YAML files located in the `data` directory. The base file name will be used as the name:
+
+```ruby
+# assuming a file called `data/my_content.json`
+data[:my_content] == JSON.parse(File.read('data/my_content.json'))
+```
+
+Viz Builder keeps track of pages in a `sitemap` Hash. Pages are added with `add_page`:
+
+```ruby
+add_page 'index.html', template: 'index.html.erb', foo: 'bar'
+# sitemap['index.html'] == { template: 'index.html.erb', foo: 'bar' }
+```
+
+In the context of the template for this page, the data given to `add_page` is accessible in the `page` hash.
+
+In `index.html.erb`:
+```ERB
+<% page == { template: 'index.html.erb', foo: 'bar' } %>
+<%=page[:foo] # 'bar' %>
+```
+
+## Configuration
+
+A new `VizBuilder` instance can be configured directly or via a block passed into the constructor:
+
+```ruby
+app = VizBuilder.new
+app.set :some_global_config_thing, 'hello world'
+app.add_page 'index.html', template: 'index.html.erb'
+```
+
+Or you can use a block:
+
+```ruby
+app = VizBuilder.new do
+  set :some_global_config_thing, 'hello world'
+  add_page 'index.html', template: 'index.html.erb'
+end
+```
+
+There are a few config settings used by Viz Builder:
+
+#### http_prefix
+
+Used during building for setting canonical urls and links between pages of the site. Used by the `canonical_url` helper detailed below.
+
+#### asset_http_prefix
+
+Used during building for setting asset urls. Used by the `asset_path` helper detailed below.
+
+#### layout
+
+An optional setting that will render all pages inside the specified ERB layout file.
+
+## Templates
+
+Templates are loaded by path from the root of your project directory. There are currently no special locations from which template files are loaded.  If you keep your templates in a subdirectory of your project, you'll need to include the directory when specifying the file:
+
+```ruby
+# keeping our templates in a subdirectory called 'templates'
+app = VizBuilder.new do
+  add_page 'index.html', template: 'templates/index.html.erb'
+  add_page 'article.html', template: 'templates/article.html.erb'
+end
+```
+
+#### Layouts
+
+You can have your templates render inside a `layout` file by either setting a global `:layout` or by setting the layout on a page-by-page basis.
+
+To render all pages in the app in a layout:
+
+```ruby
+app = VizBuilder.new do
+  set :layout, 'layout.html.erb'
+  add_page 'index.html', template: 'index.html.erb'
+  add_page 'article.html', template: 'article.html.erb'
+end
+```
+
+If you don't want a layout used for all pages, or if one page needs to use a different layout, you can pass `layout` to `add_page`:
+
+```ruby
+app = VizBuilder.new do
+  add_page 'index.html', template: 'index.html.erb', layout: 'layout.html.erb'
+  add_page 'article.html', template: 'article.html.erb', layout: 'article_layout.html.erb'
+  add_page 'snippet.html', template: 'snippet.html.erb' # no layout is used for this one
+end
+```
+
+## Helpers
+
+There are a few helpers included in Viz Builder, and you can add your own as well. Helpers are methods that are usable from a template or from the configuration block.
+
+To add helpers:
+
+```ruby
+app = VizBuilder.new do
+  ...
+
+  helpers do
+    def do_something(args)
+      # do stuff
+      'stuff is done'
+    end
+  end
+end
+```
+
+You can also break your helpers out into a separate file and module.
+
+So in a new file called `helpers.rb` we add:
+
+```ruby
+module MyHelpers
+  def do_something(args)
+    # do stuff
+    'stuff is done'
+  end
+end
+```
+
+Then in your `app.rb` add:
+
+```ruby
+require 'helpers.rb'
+
+app = VizBuilder.new do
+  ...
+
+  helpers MyHelpers
+end
+```
+
+Helpers can be used immediately in the configuration block in addition to in the template:
+
+```ruby
+app = VizBuilder.new do
+  ...
+
+  helpers do
+    def do_something(args)
+      # do stuff
+      'stuff is done'
+    end
+  end
+
+  do_something :stuff
+end
+```
+
+WARNING: You should probably not use instance variables in helpers (`@myvariable`), because the instance variables are not shared between the configuration block and templates. You can use `set` and `add_data` to stash data between helper uses.
+
+### Built-in helpers
+
+#### render
+
+Render a template or partial and return the output. Takes the path to the template and a hash of local variables.
+
+```ruby
+<%=render 'list.html.erb', list_items: items %>
+```
+
+#### include_file
+
+Load and return the contents of a file. Good for inlining CSS or SVG content.
+
+```erb
+<%=include_file 'logo.svg' %>
+```
+
+#### http_prefix
+
+Returns the value of the config item `http_prefix`. Should represent the root path to the site.
+
+#### asset_http_prefix
+
+Returns the value of the config item `asset_http_prefix` or `http_prefix`. Should represent the root path to all assets for the site.
+
+#### asset_path
+
+Returns a working url pointing to a given asset. Any provided arguments will be added to the returned url:
+
+```erb
+<%=asset_path :images, 'logo.png' %>
+<!-- outputs {asset_http_prefix}/images/logo.png --->
+<%=asset_path 'images/logo.png' %>
+<!-- also outputs {asset_http_prefix}/images/logo.png --->
+```
+
+#### canonical_url
+
+Returns the full domain name and path to the root of the site. Any provided arguments will be added to the returned url:
+
+```erb
+<%=canonical_url 'page1' %>
+<!-- outputs {http_prefix}/page1 --->
+```
+
+#### build?
+
+True if Viz Builder is building out all the pages and not running as a rack app (aka web server).
+
+#### server?
+
+True if Viz Builder is running as a rack app (aka web server).
+
+#### development?
+
+True if Viz Builder is running in development mode. Usually synonymous with `server?`.
+
+#### production?
+
+True if Viz Builder is running in production mode. Usually synonymous with `build?`.
+
+## Assets
+
+You can generate Javascript and CSS using the same template processing used for HTML files. Just add a JS or CSS file as a page in your app configuration:
+
+```ruby
+app = VizBuilder.new do
+  add_page 'index.html', template: 'index.html.erb'
+  add_page 'app.js', template: 'app.js.erb'
+  add_page 'app.css', template: 'app.css.erb'
+end
+```
+
+Viz Builder will also look in the `prebuild` directory for static assets. The builder will copy these files into the `build` directory during the build process, or it will serve these files directly during development server.
+
+Viz Builder will not transform or minify assets for you. It will not handle SCSS and it will not compile ES6+ down to ES5 Javascript. I recommend using something like [webpack](https://webpack.js.org/) to handle processing javascript and stylesheets. Whatever tool you use should be configured to save output files to `prebuild`.
+
+If you only have a little script and style in your site, we recommend just using vanilla Javascript and CSS.
+
+#### Asset hashing
+
+Viz Builder automatically adds sha1 crypto hashes to the filenames of certain asset files when building out a site. Any files from the `prebuild` directory will get these hashes. You can have these crypto hashes added to any page with the `digest` option:
+
+```ruby
+app = VizBuilder.new do
+  add_page 'app.js', template: 'app.js.erb', digest: true
+end
+```
+
+WARNING: You probably don't want to use the `digest` on HTML pages.
+
+You must use the `asset_path` helper to always get a proper URL for your asset files:
+
+```ERB
+<script src="<%=asset_path 'javascript/app.js' %>"></script>
+<link ref="stylesheet" href="<%=asset_path 'stylesheets/app.css' %>" />
+```
+
+WARNING: If you do not use the `asset_path` helper, stuff will work in development but will break when you deploy.
+
+## Contributing
+
+Fork this repo, create a new branch on your fork, and make your changes there.
+Open a pull request on this repo for consideration.
+
+If its a small bugfix, feel free making the changes and opening a PR. If it's a
+feature addition or a more substantial change, please open a github issue
+outlining the feature or change. This is just to save you time and make sure
+your efforts can get aligned with other folks' plans.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/*/test_*.rb']
+end
+
+task default: :test

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/do_release.sh

@@ -0,0 +1,35 @@
+#!/bin/bash
+
+if ! git diff-index --quiet HEAD --; then
+  echo You must commit all your changes before updating the version
+  exit 1
+fi
+
+old_version=$(cat VERSION)
+
+if [ $# -ne 1 ]; then
+  read -p "Current version is $old_version. Enter a new version: " version
+else
+  version=$1
+fi
+
+if [ "$old_version" = "$version" ]; then
+  echo Already at version $version
+  exit 1
+fi
+
+echo Updating version to $version
+
+echo $version > VERSION
+
+read -p "Do you wish to commit the new version, tag and push? [y/N] " tyn
+if echo "$tyn" | grep -iq "^y"; then
+  git commit -am "bump to $version" && git tag v$version && git push && git push --tags
+
+  read -p "Do you wish to build and publish the release? [y/N] " pyn
+  if echo "$pyn" | grep -iq "^y"; then
+    rm *.gem
+    gem build vizbuilder.gemspec
+    gem push *.gem
+  fi
+fi

data/lib/viz-builder.rb

@@ -0,0 +1 @@
+require 'vizbuilder'

data/lib/viz_builder.rb

@@ -0,0 +1 @@
+require 'vizbuilder'

data/lib/vizbuilder.rb

@@ -0,0 +1,420 @@
+require 'psych'
+require 'fileutils'
+require 'erb'
+require 'json'
+require 'rack'
+require 'mimemagic'
+require 'active_support/all'
+require 'ruby_dig'
+require 'base64'
+require 'digest'
+require 'english'
+
+# The VizBuilder class does all the stuff for a viz builder app
+class VizBuilder
+  attr_reader :config
+  delegate :sitemap, :data, :hooks, :helper_modules, to: :config
+
+  BUILD_DIR = 'build'.freeze
+  PREBUILT_DIR = 'prebuild'.freeze
+  DATA_DIR = 'data'.freeze
+
+  def initialize(config = {}, &blk)
+    # Config is an object used as the context for the given block
+    @config = Config.new(config: config)
+    # Load data into @data
+    reload_data!
+    # Execute the given block as a method of this class. The block can then use
+    # the methods `add_page`, `add_data`, and `set`
+    @config.instance_exec(&blk) if block_given?
+    # Run any after load data hooks since they got added after the first load
+    # data was called.
+    run_hook!(:after_load_data)
+    # Add helpers to the TemplateContext class
+    TemplateContext.include(*helper_modules) unless helper_modules.empty?
+  end
+
+  # Generate all pages in the sitemap and save to `build/`
+  def build!(silent: false)
+    ctx = TemplateContext.new(:production, :build, @config)
+    index_prebuilt!
+    # First we build prebuilt pages that need digests calculated by build_page
+    digested = sitemap.select { |_path, page| page[:digest] == true }
+    digested.each { |path, _page| build_page(path, ctx, silent: silent) }
+    # Then we build all other pages
+    undigested = sitemap.reject { |_path, page| page[:digest] == true }
+    undigested.each { |path, _page| build_page(path, ctx, silent: silent) }
+  end
+
+  # Run this builder as a server
+  def runserver!(host: '127.0.0.1', port: '3456')
+    status = 0 # running: 0, reload: 1, exit: 2
+    # spawn a thread to watch the status flag and trigger a reload or exit
+    monitor = Thread.new do
+      sleep 0.1 while status.zero?
+      # Shutdown the server, wait for it to finish and then wait a tick
+      Rack::Handler::WEBrick.shutdown
+      sleep 0.1
+      # Use ps to get the command that the user executed, and use Kernel.exec
+      # to execute the command, replacing the current process.
+      # Basically restart everything.
+      Kernel.exec(`ps #{$PID} -o command`.split("\n").last) if status == 1
+    end
+
+    # trap ctrl-c and set status flag
+    trap('SIGINT') do
+      if status == 1
+        status = 2 # ctrl-c hit twice or more, set status to exit
+      elsif status.zero?
+        # ctrl-c hit once, notify user and set status to reload
+        puts "\nReloading the server, hit ctrl-c twice to exit\n"
+        status = 1
+      end
+    end
+
+    puts "\nStarting Dev server, hit ctrl-c once to reload, twice to exit\n"
+    Rack::Handler::WEBrick.run(self, Host: host, Port: port)
+    monitor.join # let the monitor thread finish its work
+  end
+
+  # Support the call method so an instance can act as a Rack app
+  def call(env)
+    # Only support GET, OPTIONS, HEAD
+    unless env['REQUEST_METHOD'].in?(%w[GET HEAD OPTIONS])
+      return [405, { 'Content-Type' => 'text/plain' }, ['METHOD NOT ALLOWED']]
+    end
+
+    # default response is 404 not found
+    status = 404
+    content_type = 'text/plain'
+    content = '404 File not found'
+
+    # Validate the requested path
+    path = env['PATH_INFO']
+    if path =~ %r{/$}
+      # path is for a directory
+      path += 'index.html'
+    elsif path =~ %r{/[^./]+$}
+      # path looks like a directory but is missing a trailing slash
+      path += '/index.html'
+    end
+
+    # remove any leading slashes
+    path = path[1..-1] if path =~ %r{^/}
+
+    # filename for a potential prebuilt asset
+    build_filename = File.join(PREBUILT_DIR, path)
+
+    # Check our sitemap then our prebuilt folder for content to serve
+    if sitemap[path].present?
+      content_type = MimeMagic.by_path(path).to_s
+      ctx = TemplateContext.new(:development, :server, @config)
+      content = build_page(path, ctx)
+      status = 200
+    elsif File.exist?(build_filename)
+      content_type = MimeMagic.by_path(path).to_s
+      content = File.read(build_filename)
+      status = 200
+    end
+
+    # Status code, headers and content for this response
+    [status, { 'Content-Type' => content_type }, [content]]
+  end
+
+  # Force a reload of data files in `data/`
+  def reload_data!
+    data.merge!(load_data)
+    # TODO: after load hooks only run once, not every time reload_data! is called
+    run_hook!(:after_load_data)
+  end
+
+  # Like File.extname, but gets all extensions if multiple are present
+  def self.fullextname(path)
+    fname = File.basename(path)
+    parts = fname.split('.')
+    ".#{parts[1..-1].join('.')}"
+  end
+
+  # Convenience methods for configuring the site
+  class Config
+    attr_accessor :data, :config, :sitemap, :hooks, :helper_modules
+    delegate :[], :[]=, :key?, to: :config
+
+    def initialize(config: {})
+      # Config is a Hash of site wide configuration variables
+      @config = config.with_indifferent_access
+      # Data contains content and data that needs displaying
+      @data = {}.with_indifferent_access
+      # Hooks is a hash of hook names and arrays of blocks registered to be
+      # executed when those hooks are reached
+      @hooks = {}.with_indifferent_access
+      # Sitemap is a hash representing the documents in the site that will be
+      # processed by Builder. No indifferent access since the keys are all
+      # file paths.
+      @sitemap = {}
+      # Helpers is an array of Modules that will get mixed into the template
+      # context and with the current Config instance
+      @helper_modules = []
+    end
+
+    # Add a page to the sitemap
+    def add_page(path, kwargs)
+      @sitemap[path] = kwargs.with_indifferent_access
+      self
+    end
+
+    # Add or replace data
+    def add_data(key, val)
+      @data[key] = val.is_a?(Hash) ? val.with_indifferent_access : val
+      self
+    end
+
+    # Set a global config option
+    def set(key, val)
+      @config[key] = val.is_a?(Hash) ? val.with_indifferent_access : val
+      self
+    end
+
+    # Add code to run after data is loaded or reloaded. Is also run after object
+    # is created.
+    def after_load_data(&blk)
+      hook(:after_load_data, &blk)
+      self
+    end
+
+    # Add a block to a hook name
+    def hook(name, &blk)
+      @hooks[name.to_sym] ||= []
+      @hooks[name.to_sym] << blk
+      self
+    end
+
+    # Add helper modules or define helpers in a block
+    def helpers(*mods, &blk)
+      new_helpers = []
+      # loop over the list of arguments, making sure they're all modules, and
+      # then add them to the list of new helpers
+      mods.each do |mod|
+        unless mods.is_a?(Module)
+          raise ArgumentError, 'Helpers must be defined in a module or block'
+        end
+
+        new_helpers << mod
+      end
+      # if block is given, turn it into a module and add it to the helpers list
+      new_helpers << Module.new(&blk) if blk
+
+      if new_helpers.present?
+        # extend the current Config instance with the helpers, making them available
+        # to the rest of the configuration block
+        extend(*new_helpers)
+        # add our new helpers to our array of all helpers
+        @helper_modules += new_helpers
+      end
+
+      self
+    end
+
+    def respond_to_missing?(sym, *)
+      config.key?(sym) || super
+    end
+
+    # Treat config options as local
+    def method_missing(sym)
+      return config[sym] if config.key?(sym)
+
+      super
+    end
+  end
+
+  # Templates are rendered using this class. Templates are effectively treated
+  # as methods of this class when rendered. So any methods or attributes exposed
+  # in this class are available inside of templates.
+  class TemplateContext
+    attr_accessor :page
+    delegate :data, :sitemap, :config, to: :@config_obj
+
+    def initialize(target, mode, config)
+      # Target is development or production
+      @target = target.to_sym
+      # Mode is build or server
+      @mode = mode.to_sym
+      # Config is our Builder config object
+      @config_obj = config
+      # Page is a hash representing the page. Is the same as whats in sitemap
+      # for a given page path
+      @page = {}
+      # Locals is a hash thats used to resolve missing methods, making them
+      # seem like local variables
+      @locals = {}
+    end
+
+    # Render any given template and return as a string. Can be used to render
+    # partials.
+    def render(template_path, locals = {})
+      old_locals = @locals
+      @locals = locals.with_indifferent_access
+      erb = ERB.new(File.read(template_path), trim_mode: '-')
+      erb.filename = File.expand_path(template_path)
+      ret = erb.result(binding)
+      @locals = old_locals
+      ret
+    end
+
+    # Load the content of a pre-rendered file and return it
+    def include_file(filepath)
+      content = File.read(filepath)
+      mime = MimeMagic.by_path(filepath)
+      if mime.text?
+        return content
+      elsif mime.image?
+        return Base64.strict_encode64(content)
+      else
+        raise "File '${filepath}' of type '${mime}' can't be included as text"
+      end
+    end
+
+    # HELPERS
+
+    # Get the full URL to the root of this site
+    def http_prefix
+      return '/' if server? && development?
+      prefix = config[:http_prefix] || '/'
+      prefix += '/' unless prefix =~ %r{/$}
+      prefix
+    end
+
+    # Get the full URL to the root of where assets are stored
+    def asset_http_prefix
+      return '/' if server? && development?
+      prefix = config[:asset_http_prefix] || http_prefix
+      prefix += '/' unless prefix =~ %r{/$}
+      prefix
+    end
+
+    # Generate and return the URL to any asset
+    def asset_path(*args)
+      path = args.join('/')
+      page = sitemap[path]
+      if production? && page[:digest] == true
+        raise "Missing digest for #{path}" if page[:digest_path].blank?
+        path = page[:digest_path]
+      end
+      asset_http_prefix + path
+    end
+
+    # Generate and return the URL to any page
+    def canonical_url(*args)
+      http_prefix + args.join('/')
+    end
+
+    # Are we running as a server?
+    def server?
+      @mode == :server
+    end
+
+    # Are we building this app out?
+    def build?
+      @mode == :build
+    end
+
+    # Is this in production?
+    def production?
+      @target == :production
+    end
+
+    # Is this in development?
+    def development?
+      @target == :development
+    end
+
+    # Looks for an invoked method name in locals then in config, so locals
+    # and config vars can be used as if they're local vars in the template
+    def method_missing(sym)
+      return @locals[sym] if @locals.key?(sym)
+      return config[sym] if config.key?(sym)
+      super
+    end
+
+    def respond_to_missing?(sym, *)
+      @locals.key?(sym) || config.key?(sym) || super
+    end
+  end
+
+  private
+
+  # Generate one page from the sitemap and save to `build/`
+  def build_page(path, ctx, silent: false)
+    ctx.page = sitemap[path]
+    out_fname = File.join(BUILD_DIR, path)
+
+    # Check page data for info on how to build this path
+    if ctx.page['template'].present?
+      content = ctx.render(ctx.page['template'])
+    elsif ctx.page['json'].present?
+      content = ctx.page['json'].to_json
+    elsif ctx.page['yaml'].present?
+      content = ctx.page['yaml'].to_yaml
+    elsif ctx.page['file'].present?
+      content = File.read(ctx.page['file'])
+    else
+      raise(
+        ArgumentError,
+        "Page '#{path}' missing one of required attributes: 'template', 'json', 'yaml', 'file'."
+      )
+    end
+
+    # Check if we have a layout defined, use it
+    layout_fname = ctx.page['layout'] || config['layout']
+    content = ctx.render(layout_fname) { content } if layout_fname.present?
+
+    # If page data includes a digest flag, add sha1 digest to output filename
+    if ctx.page['digest'] == true
+      ext = Builder.fullextname(path)
+      fname = File.basename(path, ext)
+      dir = File.dirname(path)
+      digest = Digest::SHA1.hexdigest(content)
+      digest_fname = "#{fname}-#{digest}#{ext}"
+      ctx.page['digest_path'] = "#{dir}/#{digest_fname}"
+      out_fname = File.join(BUILD_DIR, dir, digest_fname)
+    end
+
+    puts "Writing #{out_fname}..." unless silent
+    FileUtils.mkdir_p(File.dirname(out_fname))
+    File.write(out_fname, content)
+    content
+  end
+
+  # Read json and yaml files from `data/` and load them into a Hash using the
+  # basename of the file names.
+  def load_data
+    data = {}.with_indifferent_access
+
+    Dir.glob("#{DATA_DIR}/*.json") do |fname|
+      key = File.basename(fname, '.json').to_sym
+      puts "Loading data[:#{key}] from #{fname}..."
+      data[key] = JSON.parse(File.read(fname))
+    end
+
+    Dir.glob("#{DATA_DIR}/*.yaml") do |fname|
+      key = File.basename(fname, '.yaml').to_sym
+      puts "Loading data[:#{key}] from #{fname}..."
+      data[key] = Psych.parse(fname)
+    end
+
+    data
+  end
+
+  # Execute all blocks in config registered with the given hook name.
+  def run_hook!(name)
+    return unless hooks[name.to_sym]
+    hooks[name.to_sym].each { |blk| config.instance_exec(&blk) }
+  end
+
+  # Find prebuilt assets and add them to the sitemap
+  def index_prebuilt!
+    Dir.glob("#{PREBUILT_DIR}/**/[^_]*.*") do |filename|
+      sitemap[filename.sub("#{PREBUILT_DIR}/", '')] = { file: filename, digest: true }
+    end
+  end
+end

data/vizbuilder.gemspec

@@ -0,0 +1,26 @@
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'vizbuilder'
+  spec.version       = File.read('VERSION').strip
+  spec.authors       = ['Ryan Mark']
+  spec.email         = ['ryan@mrk.cc']
+
+  spec.summary       = 'Simple and fast static site generator'
+  spec.homepage      = 'https://github.com/ryanmark/vizbuilder-ruby'
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activesupport', '~> 5.2'
+  spec.add_dependency 'mimemagic', '~> 0.3'
+  spec.add_dependency 'rack', '~> 2.0'
+  spec.add_dependency 'ruby_dig', '~> 0.0.2'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'minitest', '~> 5.11'
+  spec.add_development_dependency 'rake', '~> 12.3'
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: vizbuilder
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Ryan Mark
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-04-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: mimemagic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: ruby_dig
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+description: 
+email:
+- ryan@mrk.cc
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- do_release.sh
+- lib/viz-builder.rb
+- lib/viz_builder.rb
+- lib/vizbuilder.rb
+- vizbuilder.gemspec
+homepage: https://github.com/ryanmark/vizbuilder-ruby
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: Simple and fast static site generator
+test_files: []