machined 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Peter Browne
+
+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,49 @@
+Machined
+========
+
+### Why another [static](https://github.com/mojombo/jekyll) [site](https://github.com/cloudhead/toto) [generator](https://github.com/petebrowne/massimo)?
+
+Machined is for the developers who know and love [the asset pipeline](http://edgeguides.rubyonrails.org/asset_pipeline.html) of Rails 3.1 and want to develop blazingly fast static websites. It's built from the ground up using [Sprockets 2.0](https://github.com/search?q=sprockets).
+
+Installation
+------------
+
+``` bash
+$ gem install machined
+```
+
+Getting Started
+---------------
+    
+``` bash
+$ machined new example.com
+```
+
+This creates a directory with the default Machined project structure. More on that later. Let's start up the Machined server:
+
+``` bash
+$ cd example.com
+$ machined server
+```
+
+Now that the server is running, edit your pages, assets, etc. and view the results. Most static site servers need to recompile the _entire_ site each time a request is made. Machined (well really Sprockets) is smart enough to compile only what you request, so developing is super fast.
+
+Deploying a Static Website
+--------------------------
+
+Once you've created your site, it's time to go live. On your production box, you just need to compile the site and let Apache, Nginx, or whatever handle the serving. It'll be fast - damn fast.
+
+``` bash
+$ cd example.com
+$ machined compile --environment production
+```
+
+Diving In
+---------
+
+TODO...
+
+Copyright
+---------
+
+Copyright (c) 2011 [Peter Browne](http://petebrowne.com). See LICENSE for details.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new
+
+task :default => :spec

data/bin/machined

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require "machined"
+Machined::CLI.start

data/lib/machined.rb

@@ -0,0 +1,23 @@
+require "machined/version"
+
+module Machined
+  autoload :CLI,                    "machined/cli"
+  autoload :Context,                "machined/context"
+  autoload :Environment,            "machined/environment"
+  autoload :Server,                 "machined/server"
+  autoload :Sprocket,               "machined/sprocket"
+  autoload :StaticCompiler,         "machined/static_compiler"
+  autoload :Utils,                  "machined/utils"
+  
+  module Helpers
+    autoload :AssetTagHelpers,      "machined/helpers/asset_tag_helpers"
+    autoload :LocalsHelpers,        "machined/helpers/locals_helpers"
+    autoload :OutputHelpers,        "machined/helpers/output_helpers"
+    autoload :RenderHelpers,        "machined/helpers/render_helpers"
+  end
+  
+  module Processors
+    autoload :FrontMatterProcessor, "machined/processors/front_matter_processor"
+    autoload :LayoutProcessor,      "machined/processors/layout_processor"
+  end
+end

data/lib/machined/cli.rb

@@ -0,0 +1,99 @@
+require "active_support/core_ext/hash/keys"
+require "active_support/core_ext/hash/slice"
+require "thor"
+
+module Machined
+  class CLI < Thor
+    include Thor::Actions
+    
+    default_task :help
+    source_root  File.expand_path("../templates", __FILE__)
+    
+    class_option "root", :aliases => "-r",
+      :desc => "Path to the root directory of the project",
+      :default => "."
+    class_option "config_path", :aliases => "-c",
+      :desc => "Path to the config file",
+      :default => "machined.rb"
+    class_option "output_path", :aliases => "-o",
+      :desc => "Path to the output directory of the project",
+      :default => "public"
+    class_option "environment", :aliases => "-e",
+      :desc => "Sets the environment",
+      :default => "development"
+    
+    desc "compile", "Compiles the site from the source files"
+    def compile
+      machined.compile
+    end
+    map %w(c build b) => :compile
+    
+    desc "new SITE_NAME", "Generates a new site with the give name"
+    def new(site_name)
+      directory "site", site_name
+    end
+    map %w(n generate g) => :new
+    
+    desc "server", "Runs a local Rack based web server"
+    method_option :port, :aliases => "-p",
+      :desc => "Serve at the given port",
+      :type => :numeric, :default => 3000
+    method_option :host, :aliases => "-h",
+      :desc => "Listen on the given given host",
+      :default => "0.0.0.0"
+    method_option :server, :aliases => "-s",
+      :desc => "Serve with the given handler"
+    method_option :daemonize, :aliases => "-D",
+      :desc => "Run daemonized in the background",
+      :type => :boolean
+    method_option :pid, :aliases => "-P",
+      :desc => "File to store PID"
+    def server
+      require "rack"
+      Rack::Server.start rack_options
+    end
+    map %w(s rackup r) => :server
+    
+    desc "version", "Prints out the version"
+    def version
+      say VERSION
+    end
+    map %w(v -v --version) => :version
+    
+    protected
+    
+    def machined
+      @machined ||= Environment.new machined_options
+    end
+    
+    # Returns the current environment, using the "RACK_ENV" variable
+    # if set.
+    def environment # :nodoc
+      ENV["RACK_ENV"] || options["environment"]
+    end
+    
+    # Returns the options needed for setting up
+    # Machined environment.
+    def machined_options # :nodoc:
+      symbolized_options(:root, :config_path, :output_path).tap do |machined_options|
+        machined_options[:environment] = environment
+      end
+    end
+    
+    # Returns the options needed for setting up the Rack server.
+    def rack_options # :nodoc:
+      symbolized_options(:port, :host, :server, :daemonize, :pid).tap do |rack_options|
+        rack_options[:environment] = environment
+        rack_options[:Port]        = rack_options.delete :port
+        rack_options[:Host]        = rack_options.delete :host
+        rack_options[:app]         = machined
+      end
+    end
+    
+    # Returns a mutable options hash with symbolized keys.
+    # Optionally, returns only the keys given.
+    def symbolized_options(*keys) # :nodoc:
+      {}.merge(options).symbolize_keys.slice(*keys)
+    end
+  end
+end

data/lib/machined/context.rb

@@ -0,0 +1,52 @@
+require "padrino-helpers"
+require "rack"
+require "sprockets"
+
+module Machined
+  class Context < Sprockets::Context
+    include Helpers::OutputHelpers
+    include Padrino::Helpers::OutputHelpers
+    include Padrino::Helpers::TagHelpers
+    include Padrino::Helpers::AssetTagHelpers
+    include Padrino::Helpers::FormHelpers
+    include Padrino::Helpers::FormatHelpers
+    include Padrino::Helpers::NumberHelpers
+    include Padrino::Helpers::TranslationHelpers
+    include Helpers::AssetTagHelpers
+    include Helpers::LocalsHelpers
+    include Helpers::RenderHelpers
+    
+    # Override initialize to add helpers
+    # from the Machined environment.
+    def initialize(*args) # :nodoc:
+      super
+      add_machined_helpers
+    end
+    
+    # Returns the main Machined environment instance.
+    def machined
+      environment.machined
+    end
+    
+    # Returns the configuration of the Machined environment.
+    def config
+      machined.config
+    end
+    
+    protected
+    
+    # Loops through the helpers added to the Machined
+    # environment and adds them to the Context. Supports
+    # blocks and Modules.
+    def add_machined_helpers # :nodoc:
+      machined.context_helpers.each do |helper|
+        case helper
+        when Proc
+          instance_eval &helper
+        when Module
+          extend helper
+        end
+      end
+    end
+  end
+end

data/lib/machined/environment.rb

@@ -0,0 +1,297 @@
+require "ostruct"
+require "pathname"
+require "active_support/core_ext/hash/reverse_merge"
+require "crush"
+require "tilt"
+
+module Machined
+  class Environment
+    # Default options for a Machined environment.
+    DEFAULT_OPTIONS = {
+      # Global configuration
+      :root           => ".",
+      :config_path    => "machined.rb",
+      :output_path    => "public",
+      :environment    => "development",
+      :digest_assets  => false,
+      :gzip_assets    => false,
+      :layout         => "main",
+      
+      # Sprocket paths and URLs
+      :assets_path    => "assets",
+      :assets_paths   => %w(lib/assets vendor/assets),
+      :assets_url     => "/assets",
+      :pages_path     => "pages",
+      :pages_url      => "/",
+      :views_path     => "views",
+      
+      # Compression configuration
+      :compress       => false,
+      :compress_css   => false,
+      :compress_js    => false,
+      :css_compressor => nil,
+      :js_compressor  => nil
+    }.freeze
+    
+    # A hash of Javascript compressors. When `config.js_compressor`
+    # is set using a symbol, such as `:uglifier`, this is where
+    # we check which engine to use.
+    JS_COMPRESSORS = {
+      :jsmin    => Crush::JSMin,
+      :packr    => Crush::Packr,
+      :yui      => Crush::YUI::JavaScriptCompressor,
+      :closure  => Crush::Closure::Compiler,
+      :uglifier => Crush::Uglifier
+    }
+    
+    # A hash of CSS compressors. When `config.css_compressor`
+    # is set using a symbol, such as `:sass`, this is where
+    # we check which engine to use.
+    CSS_COMPRESSORS = {
+      :cssmin    => Crush::CSSMin,
+      :rainpress => Crush::Rainpress,
+      :yui       => Crush::YUI::CssCompressor,
+      :sass      => Crush::Sass::Engine
+    }
+    
+    # The global configuration for the Machined
+    # environment.
+    attr_reader :config
+    
+    # An array of the helpers added to the Context
+    # through the `#helpers` method.
+    attr_reader :context_helpers
+    
+    # When the Machined environment is compiling static files,
+    # this will reference the `Machined::StaticCompiler` which handles
+    # looping through the available files and generating them.
+    attr_reader :static_compiler
+    
+    # A reference to the root directory the Machined
+    # environment is run from.
+    attr_reader :root
+    
+    # A reference to the directory the Machined environment
+    # compiles its files to.
+    attr_reader :output_path
+    
+    # An `Array` of the Sprockets environments (actually `Machined::Sprocket`
+    # instances) that are the core of a Machined environment.
+    attr_reader :sprockets
+    
+    # When the Machined environment is used as a Rack server, this
+    # will reference the actual `Machined::Server` instance that handles
+    # the requests.
+    attr_reader :server
+    
+    # Creates a new Machined environment. It sets up three default
+    # sprockets:
+    #
+    #   * An assets sprocket similar to what you would use
+    # in a Rails 3.1 app.
+    #   * A pages sprocket which handles static HTML pages.
+    #   * A views sprocket, which is not compiled, which is where
+    # layouts and partials go.
+    #
+    def initialize(options = {})
+      @config          = OpenStruct.new DEFAULT_OPTIONS.dup.merge(options)
+      @root            = Pathname.new(config.root).expand_path
+      @sprockets       = []
+      @context_helpers = []
+      
+      # Create and append the default `assets` sprocket.
+      # This sprocket mimics the asset pipeline in Rails 3.1.
+      append_sprocket :assets, :assets => true
+      
+      # Create and append the default `pages` sprocket.
+      # This sprocket is responsible for processing HTML pages,
+      # and includes processors for wrapping pages in layouts and
+      # reading YAML front matter.
+      append_sprocket :pages do |pages|
+        pages.register_mime_type     "text/html", ".html"
+        pages.register_preprocessor  "text/html", Processors::FrontMatterProcessor
+        pages.register_postprocessor "text/html", Processors::LayoutProcessor
+      end
+      
+      # Create and append the default `views` sprocket.
+      # The files in this sprocket are not compiled. They are
+      # meant to be resources for the other sprockets. For instance,
+      # the layouts for the `pages` sprocket will be located here.
+      append_sprocket :views, :compile => false do |views|
+        views.register_mime_type "text/html", ".html"
+      end
+      
+      # If there's a config file, execute with the scope of the
+      # newly created Machined environment. The default sprockets are
+      # available at this point, but not fully configured. This is so
+      # you can actually configure the sprockets with this file.
+      config_file = root.join(config.config_path)
+      instance_eval config_file.read if config_file.exist?
+      
+      # Handle anymore configuration related setup.
+      @output_path = root.join(config.output_path)
+      
+      # Append the paths for each sprocket. The default `assets` sprocket
+      # is special, because we actually append the directories within
+      # the given paths (like the Rails 3.1 asset pipeline).
+      append_path  pages, config.pages_path
+      append_paths pages, config.pages_paths
+      append_path  views, config.views_path
+      append_paths views, config.views_paths
+      append_paths assets, Utils.existent_directories(root.join(config.assets_path))
+      config.assets_paths.each do |asset_path|
+        append_paths assets, Utils.existent_directories(root.join(asset_path))
+      end
+      
+      # Set the URLs for the compilable default sprockets.
+      assets.config.url = config.assets_url
+      pages.config.url  = config.pages_url
+      
+      # Now setup assets compression.
+      if config.compress
+        config.compress_js  = true
+        config.compress_css = true
+      else
+        config.compress_js  = true if config.js_compressor
+        config.compress_css = true if config.css_compressor
+      end
+      assets.js_compressor  = js_compressor  if config.compress_js
+      assets.css_compressor = css_compressor if config.compress_css
+    end
+    
+    # Handles Rack requests by passing the +env+ to an instance
+    # of `Machined::Server`.
+    def call(env)
+      @server ||= Server.new self
+      server.call(env)
+    end
+    
+    # Loops through the available static files and generates them in
+    # the output path.
+    def compile
+      @static_compiler ||= StaticCompiler.new self
+      static_compiler.compile
+    end
+    
+    # Creates a Machined sprocket with the given +name+ and +options+
+    # and appends it to the #sprockets list. This will also create
+    # an accessor with the given name that references the created sprocket.
+    #
+    #   machined.append_sprocket :updates, :url => "/news" do |updates|
+    #     updates.append_path "updates"
+    #   end
+    #   
+    #   machined.updates            # => #<Machined::Sprocket...>
+    #   machined.updates.config.url # => "/news"
+    #   machined.updates.paths      # => [ ".../updates" ]
+    #
+    def append_sprocket(name, options = {}, &block)
+      create_sprocket(name, options, &block).tap do |sprocket|
+        sprockets.push(sprocket).uniq!
+        server and server.remap
+      end
+    end
+    
+    # Creates a Machined sprocket with the given +name+ and +options+
+    # and prepends it to the #sprockets list.
+    def prepend_sprocket(name, options = {}, &block)
+      create_sprocket(name, options, &block).tap do |sprocket|
+        sprockets.unshift(sprocket).uniq!
+        server and server.remap
+      end
+    end
+    
+    # Adds helpers that can be used within asset files.
+    # There's two supported ways to add helpers, the first of
+    # which is similar to how the `#helpers` DSL works in Sinatra:
+    #
+    #   helpers do
+    #     def current_time
+    #       Time.now
+    #     end
+    #   end
+    #
+    # The other way is to pass modules directly:
+    #
+    #   module CycleHelper
+    #     def cycle(*args)
+    #       # ...
+    #     end
+    #   end
+    #
+    #   helpers CycleHelper
+    #
+    def helpers(*modules, &block)
+      @context_helpers << block if block_given?
+      @context_helpers.push *modules
+    end
+    
+    unless method_defined?(:define_singleton_method)
+      # Add define_singleton_method for Ruby 1.8.7
+      # This is used to define the sprocket accessor methods.
+      def define_singleton_method(symbol, method = nil, &block) # :nodoc:
+        singleton_class = class << self; self; end
+        singleton_class.__send__ :define_method, symbol, method || block
+      end
+    end
+    
+    protected
+    
+    # Factory method for creating a `Machined::Sprocket` instance.
+    # This is used in both `#append_sprocket` and `#prepend_sprocket`.
+    def create_sprocket(name, options = {}, &block) # :nodoc:
+      options.reverse_merge! :root => root
+      Sprocket.new(self, options).tap do |sprocket|
+        define_singleton_method(name) { sprocket }
+        yield sprocket if block_given?
+      end
+    end
+    
+    # Appends the given +path+ to the given +sprocket+
+    # This makes sure the path is relative to the `root` path
+    # or an absolute path pointing somewhere else. It also
+    # checks if it exists before appending it.
+    def append_path(sprocket, path) # :nodoc:
+      path = root.join(path)
+      sprocket.append_path(path) if path.exist?
+    end
+    
+    # Appends the given `Array` of +paths+ to the given +sprocket+.
+    def append_paths(sprocket, paths) # :nodoc:
+      paths or return
+      paths.each do |path|
+        append_path sprocket, path
+      end
+    end
+    
+    # Returns the Javascript compression engine, based on
+    # what's set in `config.js_compressor`. If `config.js_compressor`
+    # is nil, let Tilt + Crush decide which one to use.
+    def js_compressor # :nodoc:
+      case config.js_compressor
+      when Crush::Engine
+        config.js_compressor
+      when Symbol, String
+        JS_COMPRESSORS[config.js_compressor.to_sym]
+      else
+        Crush.register_js
+        Tilt["js"]
+      end
+    end
+    
+    # Returns the CSS compression engine, based on
+    # what's set in `config.css_compressor`. If `config.css_compressor`
+    # is nil, let Tilt + Crush decide which one to use.
+    def css_compressor # :nodoc:
+      case config.css_compressor
+      when Crush::Engine
+        config.css_compressor
+      when Symbol, String
+        CSS_COMPRESSORS[config.css_compressor.to_sym]
+      else
+        Crush.register_css
+        Tilt["css"]
+      end
+    end
+  end
+end