rails_build 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cd82bac7610eed4089c5be9667a685dea9ebd327
+  data.tar.gz: 99110d59847285fad099e0769f333f49aded632f
+SHA512:
+  metadata.gz: 4c4ddd3929c28ada377db4c57811e3934aaeeaae6e30e6fa920f158e5cd7c9bce2276111fbda6f15b23685658fe88cb107593d981e8bf4d0dd9788036eb9f8be
+  data.tar.gz: e1203289ae526130f34645705cefc37edf2409065671bd591991084755eabe7e0aeb1a37838dc9d94bde6a9793d370163f24cce9ccac9843cf443322c2a55642

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 ahoward
+
+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,179 @@
+# RailsBuild
+
+A very small, very simple, very fast, and bullet proof static site generator
+built as a Rails 5 engine.
+
+
+
+## How It Works
+
+RailsBuild bundles all your assets, public directory, and configured urls into
+a static site suitable for deployment to Netlify, Amazon S3, or your favorite
+static website hosting solution.  It does this by:
+
+- Booting your application in *production* mode
+- Precompiling all assets
+- Including every static resource in ./public/
+- GET'ing every configured url via super fast parallel downloading
+
+RailsBuild let's you leverage the entire Rails' ecosystem for your static
+sites and requires learning practically no new techniques to make super fast
+building static websites.
+
+
+
+## Configuration
+
+Configuration is quite simple, typically it will be much less than comparable
+static site generators.  You need to drop a *./config/rails_build.rb* looking
+something like this into your app:
+
+```ruby
+
+  RailsBuild.configure do |rails_build|
+
+    urls = rails_build.urls
+
+    urls << "/"
+
+    urls << "/about/"
+
+    urls << "/contact/"
+
+ 
+    Post.each do |post|
+      urls << blog_path(post) 
+    end
+
+  end
+
+
+```
+
+That's it: simply enumerate the urls - anything additional to your assets and
+./public/ directory - that you want to include in your build.
+
+## On Trailing Slashes
+
+Most static hosting solutions support Apache style directory indexing will be
+better behaved with urls that look like
+
+```markdown
+
+  http://my.site.com/blog/
+
+```
+
+vs.
+
+```markdown
+
+  http://my.site.com/blog
+
+```
+
+RailsBuild tries to help you do this with a little bit of Rails' config that
+is turned on by default but which can be turned off via
+
+```ruby
+
+  RailsBuild.configure do |rails_build|
+
+    rails_build.trailing_slash false  # the default is 'true'
+
+  end
+
+```
+
+The only real impact will be felt if you are using relative urls in your site
+like './about' vs. '../about'
+
+
+
+## Optimization and Notes
+
+
+RailsBuild is fast.  Very fast.  [DOJO4](http://dojo4.com) has seen optimized [Middleman](https://middlemanapp.com/) builds of > 30 minutes dropped to *60 seconds* by simply making basic use of Rails' built-in caching facilites.
+
+When trying to squeeze out performance just remember that RailsBuild runs in
+production mode and, therefore, making a build go fast follows the *exact same
+rules* as making anything other Rails' application fast.  The first place to
+reach is typically fragment caching of partials used in your app.
+
+Finally, don't forget about *./config/initializers/assets.rb* - RailsBuild
+doesn't do anything special to the asset pipeline and only those assets
+normally built when
+
+```bash
+
+  ~> rake assets:precompile
+
+```
+
+is run will be included in the build.
+
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+
+  gem 'rails_build'
+
+
+```
+
+And then execute:
+
+```bash
+
+$ bundle
+
+$ bundle binstubs rails_build
+
+
+```
+
+
+
+## Building Your Site
+
+
+After installation and configuration simply run
+
+```bash
+
+  ~> ./bin/rails_build
+
+
+# or, if you prefer, simply
+
+  ~> rails build
+
+
+```
+
+
+
+## Netlfiy
+
+We love Netlify at [DOJO4](http://dojo4.com).  RailsBuild works with netlify
+out of the box and simply requires
+
+```yaml
+
+  build_command : rails_build
+
+  build_directory: build
+
+```
+
+to be configured as the build command and directory respectively.
+
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,37 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'RailsBuild'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+load 'rails/tasks/statistics.rake'
+
+
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/assets/config/rails_build_manifest.js

@@ -0,0 +1,2 @@
+//= link_directory ../javascripts/rails_build .js
+//= link_directory ../stylesheets/rails_build .css

data/app/assets/javascripts/rails_build/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file. JavaScript code in this file should be added after the last require_* statement.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/app/assets/stylesheets/rails_build/application.css

@@ -0,0 +1,32 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */
+
+body{
+  font-size: 150%;
+}
+
+a:link,
+a:visited,
+a:active
+{
+  color: black;
+}
+a:hover
+{
+  color: #FF69B4;
+}
+
+

data/app/controllers/rails_build/application_controller.rb

@@ -0,0 +1,12 @@
+module RailsBuild
+  class ApplicationController < ActionController::Base
+    protect_from_forgery with: :exception
+
+    def index
+    end
+
+    def configuration
+      render :json => RailsBuild.configuration, :layout => false
+    end
+  end
+end

data/app/helpers/rails_build/application_helper.rb

@@ -0,0 +1,4 @@
+module RailsBuild
+  module ApplicationHelper
+  end
+end

data/app/jobs/rails_build/application_job.rb

@@ -0,0 +1,4 @@
+module RailsBuild
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/rails_build/application_mailer.rb

@@ -0,0 +1,6 @@
+module RailsBuild
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/rails_build/application_record.rb

@@ -0,0 +1,5 @@
+module RailsBuild
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/views/layouts/rails_build/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Rails build</title>
+  <%= stylesheet_link_tag    "rails_build/application", media: "all" %>
+  <%= javascript_include_tag "rails_build/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/app/views/rails_build/application/index.html.erb

@@ -0,0 +1,20 @@
+<%
+  @links = [
+
+    rails_build.url_for(:action => :index, :only_path => true),
+
+    rails_build.url_for(:action => :configuration, :only_path => true)
+
+  ].map{|href| link_to(href, href)}
+%>
+
+<br>
+<hr>
+
+<ul>
+<% @links.each do |link| %>
+  <li>
+    <%= link %>
+  </li>
+<% end %>
+</ul>

data/bin/rails

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails gems
+# installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('../..', __FILE__)
+ENGINE_PATH = File.expand_path('../../lib/rails_build/engine', __FILE__)
+
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../Gemfile', __FILE__)
+require 'bundler/setup' if File.exist?(ENV['BUNDLE_GEMFILE'])
+
+require 'rails/all'
+require 'rails/engine/commands'

data/bin/rails_build

@@ -0,0 +1,730 @@
+#!/usr/bin/env ruby
+
+# file : ./bin/rails_build
+
+END{ 
+
+  RailsBuild::CLI.build!  
+
+}
+
+
+module RailsBuild
+	class CLI
+		def CLI.usage
+			<<-__
+				NAME
+					rails_build
+
+				SYNOPSIS
+          a small, simple, bullet proof, and very fast static site generator built on rails 5
+
+        USAGE
+          rails_build [rails_root] *(options)
+
+          options:
+            --help, -h       : this message
+            --rails_root,--r : specifiy the RAILS_ROOT, default=./
+            --parallel,--p   : how many requests to make in parallel, default=n_cpus/2
+            --env,--e        : speciify the RAILS_ENV, default=production
+            --server, -s     : provide the url of the build server, do *not* start separate one
+            --log, -l        : specify the logfile, default=STDERR
+            --verbose, -v    : turn on verbose logging
+			__
+		end
+
+		def CLI.opts
+			GetoptLong.new(
+				[ '--help'			 , '-h' , GetoptLong::NO_ARGUMENT ]				, 
+				[ '--server'		 , '-s' , GetoptLong::REQUIRED_ARGUMENT ] , 
+				[ '--parallel'	 , '-p' , GetoptLong::REQUIRED_ARGUMENT ] , 
+				[ '--rails_root' , '-r' , GetoptLong::REQUIRED_ARGUMENT ] , 
+				[ '--env'				 , '-e' , GetoptLong::REQUIRED_ARGUMENT ] , 
+				[ '--log'	       , '-l' , GetoptLong::REQUIRED_ARGUMENT ] , 
+				[ '--verbose'		 , '-v' , GetoptLong::NO_ARGUMENT ]				, 
+			)
+		end
+
+		def build!
+			prepare!
+
+			mkdir!
+
+			start_server! unless server
+
+			clear_cache!
+
+			extract_urls! url_for('/rails_build/configuration.json')
+
+			precompile_assets!
+
+			rsync_public!
+
+			parallel_build!
+
+			finalize!
+		end
+
+	#
+		def CLI.build!(*args, &block)
+			new(*args, &block).build!
+		end
+
+	#
+		attr_accessor :rails_root
+		attr_accessor :server
+		attr_accessor :directory
+		attr_accessor :uuid
+		attr_accessor :id
+		attr_accessor :env
+		attr_accessor :puma
+		attr_accessor :passenger
+		attr_accessor :url
+
+	#
+		def initialize(*args, &block)
+      setup!
+
+			@args = parse_args! 
+
+			@opts = parse_opts!
+
+			if @opts[:help]
+				usage!
+				exit(42)
+			end
+		end
+
+  #
+    def setup!
+		#
+			STDOUT.sync = true
+			STDERR.sync = true
+
+		#
+			ENV['SPRING_DISABLE'] = 'true'
+			ENV['DISABLE_SPRING'] = 'true'
+
+		#
+			%w[
+				fileutils pathname thread socket timeout time uri etc open-uri securerandom logger getoptlong rubygems json
+			].each do |stdlib|
+				require(stdlib)
+			end
+    end
+
+	#
+		def prepare!
+    #
+			@rails_root = find_rails_root!(@args[0] || '.')
+
+    #
+			Dir.chdir(@rails_root)
+
+    #
+			if File.exists?('./Gemfile')
+				require 'bundler/setup'
+				Bundler.setup(:require => false)
+			end
+
+		#
+			%w[
+        threadify persistent_http phusion_passenger
+			].each do |gem|
+        begin
+          require(gem)
+        rescue LoadError
+          abort "add gem 'rails_build' to your Gemfile"
+        end
+			end
+
+    #
+			begin
+				require('pry')
+			rescue LoadError
+				nil
+			end
+
+		#
+			@logger = Logger.new(@opts[:log] || STDERR)
+
+			@uuid			= ENV['RAILS_BUILD']
+			@time			= ENV['RAILS_BUILD_TIME']
+			@server		= @opts[:server] || ENV['RAILS_BUILD_SERVER']
+			@env			= @opts[:env] || ENV['RAILS_BUILD_ENV'] || ENV['RAILS_ENV']
+			@parallel = @opts[:parallel] || ENV['RAILS_BUILD_PARALLEL']
+			@verbose	= @opts[:verbose] || ENV['RAILS_BUILD_VERBOSE']
+
+			@uuid			||= SecureRandom.uuid
+			@time			||= Time.now.utc
+			@env			||= 'production'
+			@parallel ||= (Etc.nprocessors/2)
+
+			unless @time.is_a?(Time)
+				@time = Time.parse(@time.to_s).utc
+			end
+
+			@parallel = @parallel.to_i
+
+
+			@puma = 'bundle exec puma'
+			@pumactl = 'bundle exec pumactl'
+
+			@passenger = 'bundle exec passenger'
+
+			if ENV['RAILS_BUILD_DIRECTORY']
+				@build_directory = File.expand_path(ENV['RAILS_BUILD_DIRECTORY']) 
+			else
+				@build_directory = File.join(@rails_root, 'builds')
+			end
+
+			@directory = File.join(@build_directory, @uuid)
+
+			ENV['RAILS_ENV']				= @env
+			ENV['RAILS_BUILD']			= @uuid
+			ENV['RAILS_BUILD_ENV']	= @env
+			ENV['RAILS_BUILD_TIME'] = @time.httpdate
+
+			@urls = []
+
+			@started_at = Time.now
+		end
+
+  #
+    def find_rails_root!(path)
+      rails_root = File.expand_path(path.to_s)
+
+      loop do
+        is_rails_root = %w[ app lib config public ].all?{|dir| test(?d, File.join(rails_root, dir))}
+
+        if is_rails_root
+          return(rails_root)
+        else
+          rails_root = File.dirname(rails_root)
+          break if rails_root == '/'
+        end
+      end
+
+      abort("could not find a rails_root in or above #{ path }!?")
+    end
+
+	#
+		def parse_args!
+			@args = ARGV.map{|arg| "#{ arg }"}
+		end
+
+	#
+		def parse_opts!
+			@opts = Hash.new
+
+			CLI.opts.each do |opt, arg|
+				key, val = opt.split('--').last, arg
+				@opts[key] = (val == '' ? true : val)
+			end
+
+			@opts
+		end
+
+	#
+		def usage!
+			lines = CLI.usage.strip.split(/\n/)
+			n			 = lines[1].to_s.scan(/^\s+/).size
+			indent = ' ' * n
+			re		 = /^#{ Regexp.escape(indent) }/
+			usage  = lines.map{|line| line.gsub(re, '')}.join("\n")
+			STDERR.puts(usage)
+		end
+
+	#
+		def mkdir!
+			FileUtils.rm_rf(@directory)
+			FileUtils.mkdir_p(@directory)
+			log(:info, "directory: #{ @directory }")
+		end
+
+	#
+		def start_server!
+			@server =
+				nil
+
+			@port =
+				nil
+
+			ports =
+				(2000 .. 9000).to_a
+
+# TODO - get puma working...
+=begin
+			pidfile = File.join(@directory, "puma.pid")
+			statefile = File.join(@directory, "puma-state.txt")
+			configfile = File.join(@directory, "puma-config.rb")
+			FileUtils.touch(configfile)
+=end
+
+			start_server, stop_server = nil
+
+			ports.each do |port|
+				next unless port_open?(port)
+
+# TODO - get puma working...
+=begin
+				start_server =
+					"puma --port=#{ port } --environment=#{ @env } --pidfile=#{ pidfile } --state=#{ statefile } --config=#{ configfile } --daemon --preload config.ru"
+				stop_server =
+					"#{ @pumactl } --pidfile=#{ pidfile } --state=#{ statefile } stop"
+=end
+				start_server =
+					"#{ @passenger } start --daemonize --environment #{ @env } --port #{ port } --max-pool-size 16"
+				stop_server =
+					"#{ @passenger } stop --port #{ port }"
+
+				`#{ stop_server } 2>&1`.strip
+
+				log(:info, "cmd: #{ start_server }")
+				server_output = `#{ start_server } 2>&1`.strip
+
+				log(:info, "status: #{ $?.exitstatus }")
+
+				t = Time.now.to_f
+				timeout = 10
+				i = 0
+
+				loop do
+					i += 1
+
+					begin
+						url = "http://localhost:#{ port }"
+						open(url){|socket| socket.read}
+						@server = url
+						@port = port
+						break
+					rescue Object => e
+						if i > 2
+							log :error, "#{ e.message }(#{ e.class })\n"
+							log :error, "#{ server_output }\n\n"
+						end
+
+						if((Time.now.to_f - t) > timeout)
+							abort("could not start server inside of #{ timeout } seconds ;-/")
+						else
+							sleep(rand(0.42))
+						end
+					end
+				end
+
+				break if @server
+			end
+
+		# barf if server could not be started
+		#
+			unless @server
+				abort("could not start server on any of ports #{ ports.first } .. #{ ports.last }")
+			else
+				log(:info, "started server on #{ @server }")
+			end
+
+		# set assassins to ensure the server daemon never outlives the build script
+		# no matter how it is killed (even -9)
+		#
+			at_exit{
+				log(:info, "cmd: #{ stop_server }")
+				`#{ stop_server } >/dev/null 2>&1`
+				log(:info, "status: #{ $?.exitstatus }")
+				log(:info, "stopped server #{ @server }")
+			}
+
+			assassin = <<-__
+				pid = #{ Process.pid }
+
+				4242.times do
+					begin
+						Process.kill(0, pid)
+					rescue Object => e
+						if e.is_a?(Errno::ESRCH)
+							`#{ stop_server } >/dev/null 2>&1`
+							Process.kill(-15, pid) rescue nil
+							sleep(rand + rand)
+							Process.kill(-9, pid) rescue nil
+						end
+						exit
+					end
+					sleep(1 + rand)
+				end
+			__
+			IO.binwrite('tmp/build-assassin.rb', assassin)
+			cmd = "nohup ruby tmp/build-assassin.rb >/dev/null 2>&1 &"
+			system cmd
+
+		#
+			@started_at = Time.now
+			@server
+		end
+
+	#
+		def extract_urls!(build_url)
+			urls = []
+
+			code, body = http_get(build_url)
+
+			unless code == 200
+				raise "failed to get build urls from #{ build_url }"
+			end
+
+			@_build = JSON.parse(body)
+
+			unless @_build['urls'].is_a?(Array)
+				raise "failed to find any build urls at #{ build_url }"
+			end
+
+			urls = @_build['urls']
+
+			urls.map!{|url| url_for(url)}
+
+			log(:info, "extracted #{ urls.size } urls to build from #{ build_url }")
+
+			@urls = urls
+		end
+
+	#
+		def clear_cache!
+			#spawn "rake tmp:cache:clear"
+			spawn "rails runner 'Rails.cache.clear'"
+		end
+
+	#
+		def precompile_assets!
+			@asset_dir = File.join(@rails_root, "public/assets")
+			@asset_tmp = false
+
+			if test(?d, @asset_dir)
+				@asset_tmp = File.join(@rails_root, "tmp/assets-build-#{ @uuid }")
+				FileUtils.mv(@asset_dir, @asset_tmp) 
+			end
+
+			spawn "RAILS_ENV=production rake assets:precompile"
+
+			assets = Dir.glob(File.join(@rails_root, 'public/assets/**/**'))
+
+			log(:info, "precompiled #{ assets.size } assets")
+
+			ensure_non_digested_assets_also_exist!(assets)
+		end
+
+	#
+		def rsync_public!
+			spawn "rsync -avz ./public/ #{ @directory }"
+
+			count = 0
+			
+			Dir.glob(File.join(@directory, '**/**')).each{ count += 1 }
+
+			log(:info, "rsync'd #{ count } files")
+
+			if @asset_tmp
+				FileUtils.rm_rf(@asset_dir)
+				FileUtils.mv(@asset_tmp, @asset_dir) 
+			end
+		end
+
+	#
+		def parallel_build!(n = nil)
+			n ||= @parallel
+
+			stats = {
+				:success => [], :missing => [], :failure => [],
+			}
+
+			times = Queue.new
+
+			avg = nil
+
+			Thread.new do
+				Thread.current.abort_on_exception = true
+				total = 0.0
+				n = 0
+				loop do
+					while(time = times.pop)
+						total += time
+						n += 1
+						avg = (total / n).round(2) 
+					end
+				end
+			end
+
+			a = Time.now.to_f
+
+			_stats =
+				@urls.threadify(n) do |url|
+					uri = uri_for(url)
+					path = path_for(uri)
+					upath = uri.path
+					rpath = relative_path(path, :from => @directory)
+
+					_a = Time.now.to_f
+
+					code, body = http_get(uri)
+
+					_b = Time.now.to_f
+					_e = (_b - _a).round(2)
+
+					times.push(_e)
+
+					label = "#{ code } @ (t̄:#{ avg }s)"
+
+					case code
+						when 200
+							write_path(path, body)
+							log(:info, "#{ label }: #{ upath } -> #{ rpath } (t:#{ _e }s)")
+							[:success, url]
+						when 404
+							log(:error, "#{ label }: #{ upath }")
+							[:missing, url]
+						when 500
+							log(:error, "#{ label }: #{ upath }")
+							[:failure, url]
+						else
+							log(:error, "#{ label }: #{ upath }")
+							[:failure, url]
+					end
+				end
+				
+			_stats.each{|stat, url| stats[stat].push(url)}
+
+			b = Time.now.to_f
+
+			borked = false
+
+			if stats[:missing].size > 0
+				borked = true
+				log(:error, "missing on #{ stats[:missing].size } urls")
+			end
+
+			if stats[:failure].size > 0
+				borked = true
+				log(:error, "failure on #{ stats[:failure].size } urls")
+			end
+
+			if borked
+				exit(1)
+			end
+
+			elapsed =  b - a
+			n = @urls.size
+			rps = (n / elapsed).round(2)
+
+			log(:info, "downloaded #{ n } urls at ~#{ rps }/s")
+
+			@urls
+		end
+
+	#
+		def finalize!
+			@finished_at = Time.now
+			elapsed = (@finished_at.to_f - @started_at.to_f)
+			log(:info, "build time - #{ hms(elapsed) }")
+			on_netlify = ENV['DEPLOY_PRIME_URL'].to_s =~ /netlify/
+			strategy = on_netlify ? 'cp_r' : 'ln_s' # netlify refuses to deploy from a symlink ;-/ # FIXME
+			build = File.join(@rails_root, 'build')
+			FileUtils.rm_rf(build)
+			FileUtils.send(strategy, @directory, build)
+			log(:info, "preview with `static ./build/` # brew install node-static")
+		end
+
+	#
+		def http_get(url)
+			response = HTTP.get(url.to_s, :follow => true)
+			body = response.body.to_s rescue ''
+			code = response.status.code rescue 500
+			[code, body]
+		end
+
+		def http_connection
+			@http_connection ||= (
+				PersistentHTTP.new({
+					:url					=> @server,
+					:pool_size		=> (@parallel + 1),
+					:logger				=> (@verbose ? @logger : nil),
+					:pool_timeout => 10,
+					:warn_timeout => 1,
+					:force_retry	=> true,
+				})
+			)
+		end
+
+		def http_get(url)
+			request = Net::HTTP::Get.new(url)
+			response = http_connection.request(request)
+
+			if response.is_a?(Net::HTTPRedirection)
+				location = response['Location']
+				if location.to_s == url.to_s
+					log(:fatal, "circular redirection on #{ url }")
+					exit(1)
+				end
+				return http_get(location)
+			end
+
+			code = response.code.to_i rescue 500
+			body = response.body.to_s rescue ''
+
+			[code, body]
+		end
+
+	#
+		def path_for(url)
+			uri = uri_for(url)
+
+			case
+				when uri.path=='/' || uri.path=='.'
+					path = File.join(@directory, 'index.html')
+				else
+					path = File.join(@directory, uri.path)
+					dirname, basename = File.split(path)
+					base, ext = basename.split('.', 2)
+					if ext.nil?
+						path = File.join(path, 'index.html')
+					end
+			end
+			path
+		end
+
+	#
+		def write_path(path, body)
+			FileUtils.mkdir_p(File.dirname(path))
+			IO.binwrite(path, body)
+		end
+
+	#
+		def ensure_non_digested_assets_also_exist!(assets)
+			re = /(-{1}[a-z0-9]{32}*\.{1}){1}/
+
+			assets.each do |file|
+				next if File.directory?(file) || file !~ re
+				source = file.split('/')
+				source.push(source.pop.gsub(re, '.'))
+				non_digested = File.join(source)
+				#log(:debug, "asset: #{ file } -> #{ non_digested }")
+				FileUtils.ln(file, non_digested)
+			end
+		end
+
+	#
+		def url_for(url)
+			uri = URI.parse(url.to_s)
+
+			if uri.absolute?
+				uri.to_s
+			else
+				relative_uri = URI.parse(@server)
+				relative_uri.path = absolute_path_for(uri.path)
+				relative_uri.query = uri.query
+				relative_uri.fragment = uri.fragment
+				relative_uri.to_s
+			end
+		end
+
+	#
+		def uri_for(url)
+			uri = url.is_a?(URI) ? url : URI.parse(url.to_s)
+		end
+
+	#
+		def to_s
+			@directory.to_s
+		end
+
+	#
+		def log(level, *args, &block)
+			@logger.send(level, *args, &block)
+		end
+
+	#
+		def hms(seconds)
+			return unless seconds
+			"%02d:%02d:%02d" % hours_minutes_seconds(seconds)
+		end
+
+	#
+		def hours_minutes_seconds(seconds)
+			return unless seconds
+			seconds = Float(seconds).to_i
+			hours, seconds = seconds.divmod(3600)
+			minutes, seconds = seconds.divmod(60)
+			[hours.to_i, minutes.to_s, seconds]
+		end
+
+	#
+		def stopwatch(&block)
+			a = Time.now
+			result = block.call
+			b = Time.now
+			[result, b.to_f - a.to_f]
+		end
+
+	#
+		def port_open?(port, options = {})
+			seconds = options[:timeout] || 1
+			ip = options[:ip] || '0.0.0.0'
+
+			Timeout::timeout(seconds) do
+				begin
+					TCPSocket.new(ip, port).close
+					false
+				rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+					true
+				rescue Object
+					false
+				end
+			end
+		rescue Timeout::Error
+			false
+		end
+
+	#
+		def paths_for(*args)
+			path = args.flatten.compact.join('/')
+			path.gsub!(%r|[.]+/|, '/')
+			path.squeeze!('/')
+			path.sub!(%r|^/|, '')
+			path.sub!(%r|/$|, '')
+			paths = path.split('/')
+		end
+
+	#
+		def absolute_path_for(*args)
+			path = ('/' + paths_for(*args).join('/')).squeeze('/')
+			path unless path.strip.empty?
+		end
+
+	#
+		def relative_path_for(*args)
+			path = absolute_path_for(*args).sub(%r{^/+}, '')
+			path unless path.strip.empty?
+		end
+
+	#
+		def relative_path(path, *args)
+			options = args.last.is_a?(Hash) ? args.pop : {}
+			path = path.to_s
+			relative = args.shift || options[:relative] || options[:to] || options[:from]
+			if relative
+				Pathname.new(path).relative_path_from(Pathname.new(relative.to_s)).to_s
+			else
+				relative_path_for(path)
+			end
+		end
+
+	#
+		def spawn(command)
+			oe = `#{ command } 2>&1`
+
+			unless $? == 0
+				msg = "command(#{ command }) failed with (#{ $? })"
+				log(:error, msg)
+				raise(msg)
+			end
+
+			oe
+		end
+	end
+end