massimo 0.3.9

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,25 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+.eprj
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+doc
+.yardoc
+.sass-cache
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 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,108 @@
+# Massimo
+
+Massimo is a full static website generator. While making [Rails](http://rubyonrails.org/) websites I became dependent on [Haml](http://haml-lang.com/), [Sass](http://sass-lang.com/), and other useful gems. I wanted to use that workflow to rapidly make simple, static websites. Massimo's code is inspired by other website generators like [Jekyll](http://github.com/mojombo/jekyll) and [Webby](http://webby.rubyforge.org/). It's features include:
+
+* It renders templates and views using [Tilt](http://github.com/rtomayko/tilt)
+* It uses familiar helper methods from [Sinatra::More](http://github.com/nesquena/sinatra_more)
+* It supports custom helper methods like [Rails](http://rubyonrails.org/) and [Sinatra](http://www.sinatrarb.com/)
+* It concats javascripts using [Sprockets](http://getsprockets.org/)
+  and then minifies them using [JSMin](http://github.com/rgrove/jsmin)
+* It renders stylesheets using either [Sass](http://sass-lang.com/) or [Less](http://lesscss.org/)
+ 
+ 
+## Basic Usage
+
+1. Setup the structure of the Site
+2. Create some pages
+3. Run you Site locally to see how it looks
+4. Deploy your Site
+
+### Structure
+
+A basic Massimo Site looks something like this, though each directory's path can be customized:
+
+    .
+    |-- config.yml
+    |
+    |-- helpers
+    |   `-- my_helpers.rb
+    |
+    |-- javascripts
+    |   |-- _plugin.js
+    |   `-- application.js
+    |
+    |-- lib
+    |   `-- post.rb
+    |
+    |-- pages
+    |   |-- index.haml
+    |   |-- contact.haml
+    |   `-- about-us.haml
+    |
+    |-- stylesheets
+    |   |-- _base.sass
+    |   `-- application.sass
+    |
+    |-- views
+    |   |-- partial.haml
+    |   `-- layouts
+    |       `-- applcation.haml
+    |
+    `-- public
+  
+#### config.yml
+
+This where you setup the options for the Site.
+
+#### helpers
+
+This is where you put helper modules (like Rails). This modules will automatically be available in your pages and views.
+
+#### javascripts
+
+This is where you put the working copies of your javascripts. They will be concatenated, minified, and moved to your output directory when the site is processed.
+
+#### lib
+
+This is where you put additional libraries. You can customize the default Massimo classes or add your own here. This is where you would add additional Tilt Templates.
+
+#### pages
+
+These are the actual pages (content) of your site. Anything here that is registered by a Tilt Template will be transformed into HTML and moved to the appropriate place in the output directory.
+
+#### stylesheets
+
+This is where you put the working copies of your stylesheets. If they are Sass or Less documents, they will be transformed into CSS documents then moved to your output directory.
+
+#### views
+
+This is where you put partials and layouts (like Rails). You can render partials from your pages by calling `render("partial_name")`.
+
+### Running Massimo
+  
+Usually this is done through the massimo executable, which is installed with the gem. In order to get a server up and running with your Massimo site, run `massimo --server` and then browse to http://localhost:1984/. Or you could simply run `massimo --watch` to watch for changes and regenerate the site.
+
+
+## YAML Front Matter
+
+Pages can contain YAML front matter blocks for either predefined configuration options or custom variables. The front matter must be the first thing in the file and takes the form of:
+
+    ---
+    title: Using YAML Front Matter
+    layout: false
+    ---
+
+## Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with Rakefile, VERSION, or history.
+  (if you want to have your own version, that is fine but
+  bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+## Copyright
+
+Copyright (c) 2009 [Peter Browne](http://peterbrowne.net). See LICENSE for details.

data/Rakefile

@@ -0,0 +1,62 @@
+require "rubygems"
+require "rake"
+
+begin
+  require "jeweler"
+  Jeweler::Tasks.new do |gem|
+    gem.name        = "massimo"
+    gem.summary     = %{Massimo is a static website builder.}
+    gem.description = %{Massimo builds HTML, Javascript, and CSS Files from your source.}
+    gem.email       = "peter@peterbrowne.net"
+    gem.homepage    = "http://github.com/peterbrowne/massimo"
+    gem.authors     = [ "Peter Browne" ]
+    gem.add_development_dependency "shoulda",           ">= 2.10.2"
+    gem.add_development_dependency "yard",              ">= 0.5.2"
+    gem.add_dependency             "activesupport",     ">= 2.3.5"
+    gem.add_dependency             "sinatra_more",      ">= 0.3.26"
+    gem.add_dependency             "directory_watcher", ">= 1.3.1"
+    gem.add_dependency             "sprockets",         ">= 1.0.2"
+    gem.add_dependency             "jsmin",             ">= 1.0.1"
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require "rake/testtask"
+Rake::TestTask.new(:test) do |test|
+  test.libs << "lib" << "test"
+  test.pattern = "test/**/test_*.rb"
+  test.verbose = true
+end
+
+begin
+  require "rcov/rcovtask"
+  Rcov::RcovTask.new do |test|
+    test.libs << "test"
+    test.pattern = "test/**/test_*.rb"
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+desc "Open an irb session preloaded with this library"
+task :console do
+  sh "irb -rubygems -I lib -r massimo.rb"
+end
+
+begin
+  require "yard"
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end

data/VERSION

@@ -0,0 +1 @@
+0.3.9

data/bin/massimo

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), *%w{.. lib massimo}))
+require File.expand_path(File.join(File.dirname(__FILE__), *%w{.. lib massimo command}))
+
+exit Massimo::Command.new(ARGV).run!

data/lib/massimo/command.rb

@@ -0,0 +1,242 @@
+require "optparse"
+require "active_support"
+require "yaml"
+begin require "growl"; rescue ::LoadError; end
+
+module Massimo
+  class Command
+    attr_accessor :args, :options, :site, :source, :output
+    
+    # Default options. Overriden by values in config.yml or command-line opts.
+    DEFAULT_OPTIONS = {
+      :config_path => ::File.join(".", "config.yml")
+    }.freeze
+    
+    #
+    def initialize(args)
+      # Parse the command line arguments
+      self.args    = args
+      self.options = DEFAULT_OPTIONS.dup
+      self.parse!
+      
+      # Load the options from the config file
+      config = ::YAML.load_file(self.options[:config_path]) if ::File.exist?(self.options[:config_path])
+      self.options.merge!(config.symbolize_keys) if config.is_a?(::Hash)
+      
+      # Initialize the Site
+      self.site    = ::Massimo::Site(self.options)
+      self.options = self.site.options
+      self.source  = self.options[:source]
+      self.output  = self.options[:output]
+      
+      # Setup Backtrace Cleaner
+      @cleaner = ::ActiveSupport::BacktraceCleaner.new
+      @cleaner.add_silencer { |line| line =~ /^(\/|\\)/ } # Remove full File path traces
+    end
+    
+    # Run the script, based on the command line options.
+    def run!
+      if generate?
+        generate_layout!
+      elsif watch?
+        watch_source!
+      else
+        process_site!
+      end
+      run_server! if server?
+      return 0
+    rescue ::Interrupt
+      message "Massimo is done watching you.", :newline => true
+      return 0
+    rescue ::Exception => e
+      report_error(e)
+      return 1
+    end
+    
+    protected
+      
+      # Generate the default layout of the site.
+      def generate_layout!
+        require "fileutils"
+        message "Massimo is generating the default site layout"
+        [ site.source_dir, site.all_source_dirs, site.output_dir ].flatten.each do |dir|
+          full_dir = ::File.expand_path(dir)
+          if ::File.exists?(full_dir)
+            puts indent_body("exists: #{full_dir}")
+          else
+            ::FileUtils.mkdir_p(full_dir)
+            puts indent_body("created: #{full_dir}")
+          end
+        end
+      end
+    
+      # Watch the source for changes.
+      def watch_source!
+        require "directory_watcher"
+      
+        message %{Massimo is watching "#{source}" for changes. Press Ctrl-C to Stop.}
+      
+        watcher = ::DirectoryWatcher.new(
+          ".",
+          :interval => 1,
+          :glob     => site.all_source_dirs.collect { |dir| ::File.join(dir, *%w{** *}) }
+        )
+      
+        watcher.add_observer do |*args|
+          begin
+            site.process!
+            time   = ::Time.now.strftime("%H:%M")
+            change = args.size == 1 ? "1 file" : "#{args.size} files"
+            message "Massimo has rebuilt your site. #{change} changed. (#{time})"
+          rescue ::Exception => e
+            report_error(e)
+          end
+        end
+        
+        watcher.start
+        
+        unless server?
+          loop { sleep 1000 }
+        end
+      end
+    
+      # Process the site.
+      def process_site!
+        site.process!
+        message %{Massimo has built your site in "#{site.options[:output]}"}
+      end
+    
+      #
+      def run_server!
+        require "webrick"
+        
+        # Make sure the output dir exists
+        ::FileUtils.mkdir_p(output)
+        
+        server = ::WEBrick::HTTPServer.new(
+          :Port         => options[:server_port],
+          :DocumentRoot => output
+        )
+        
+        trap(:INT) do
+          server.shutdown
+          message "Massimo is shutting down the server.", :newline => true
+          return 0
+        end
+        
+        server.start
+        message "Massimo is serving up your site at http://localhost:#{options[:server_port]}/"
+      end
+    
+      # Determine if we should watch the source directory for changes.
+      def watch?
+        options[:watch] == true
+      end
+      
+      # Determine if we should generate the default layout of the site.
+      def generate?
+        options[:generate] == true
+      end
+      
+      # Determine if the server should be started.
+      def server?
+        options[:server] == true
+      end
+      
+      #
+      def message(string, options = {})
+        options.reverse_merge!(:growl => true)
+        puts "\n" if options[:newline]
+        puts "== #{string}"
+        ::Growl.notify(string, :title => "Massimo") if options[:growl] && defined?(::Growl)
+      end
+      
+      # Report the given error. This could eventually log the backtrace.
+      def report_error(error = nil)
+        error ||= $!
+        
+        # Show full backtrace if verbose
+        backtrace = if options[:verbose]
+          error.backtrace
+        else
+          @cleaner.clean(error.backtrace)
+        end
+        
+        # show the message
+        message "Massimo Error:", :newline => true, :growl => false
+        puts indent_body(error.message)
+        puts indent_body(backtrace)
+        puts "\n"
+        
+        # Format the message differently for growl
+        ::Growl.notify(error.message, :title => "Massimo Error") if defined?(::Growl)
+      end
+      
+      # Returns the string with each line indented.
+      def indent_body(string)
+        string.collect { |line| "  #{line}" }
+      end
+    
+      # Parse the options
+      def parse!
+        opts = ::OptionParser.new do |opts|
+          opts.banner = <<-HELP
+Massimo is a static website builder.
+
+Basic Command Line Usage:
+  massimo                                                   # . -> ./public
+  massimo <path to write generated site>                    # . -> <path>
+  massimo <path to source> <path to write generated site>   # <path> -> <path>
+
+  Configuration is read from "<source>/config.yml" but can be overriden
+  using the following options:
+
+HELP
+        
+          opts.on("--config [PATH]", "The path to the config file.") do |path|
+            options[:config_path] = path
+          end
+        
+          opts.on("--generate", "Generate the default layout of the site.") do
+            options[:generate] = true
+          end
+        
+          opts.on("--watch", "Auto-regenerate the site as files are changed.") do
+            options[:watch] = true
+          end
+        
+          opts.on("--server", "Start web server with default port.") do |port|
+            options[:server] = true
+          end
+          
+          opts.on("--port [PORT]", "Select the port to start the web server on. Defaults to 1984") do |port|
+            options[:server_port] = port
+          end
+        
+          opts.on("--verbose", "-v", "Show full backtrace on errors. Defaults to false.") do
+            options[:verbose] = true
+          end
+        
+          opts.on("--version", "-V", "Display current version") do
+            puts "Massimo #{::Massimo::VERSION}"
+            exit 0
+          end
+        end
+        opts.parse!
+
+        # Get source and destintation from command line
+        case args.size
+        when 0
+        when 1
+          options[:source] = args[0]
+        when 2
+          options[:source] = args[0]
+          options[:output] = args[1]
+        else
+          puts %{Invalid options. Run "massimo --help" for assistance.}
+          exit 1
+        end
+      end
+    
+  end
+end

data/lib/massimo/helpers.rb

@@ -0,0 +1,26 @@
+module Massimo
+  class Helpers
+    if defined? ::SinatraMore
+      include ::SinatraMore::OutputHelpers
+      include ::SinatraMore::TagHelpers
+      include ::SinatraMore::AssetTagHelpers
+      include ::SinatraMore::FormHelpers
+      include ::SinatraMore::FormatHelpers
+    end
+    
+    #
+    def initialize(modules = nil)
+      self.extend(*modules) unless modules.nil? || modules.empty?
+    end
+    
+    # Gets the site instance
+    def site
+      ::Massimo::Site()
+    end
+    
+    #
+    def render(name, locals = {}, &block)
+      self.site.render_view(name, locals, &block)
+    end
+  end
+end

data/lib/massimo/javascript.rb

@@ -0,0 +1,38 @@
+module Massimo
+  class Javascript < Resource
+    # Concat the Javascript using Sprockets, then minify using JSmin
+    def render
+      secretary = ::Sprockets::Secretary.new(
+        :assert_root  => self.site.output_dir,
+        :source_files => [ @source_path.to_s ]
+      )
+      # install assets if necessary
+      secretary.install_assets
+      
+      if self.site.production? or self.site.options[:minify]
+        # minify the concatenated javascript
+        ::JSMin.minify(secretary.concatenation.to_s)
+      else
+        secretary.concatenation.to_s
+      end
+    end
+    
+    # Writes the rendered js to the output file.
+    def process!
+      # Make the full path to the directory of the output file
+      ::FileUtils.mkdir_p(self.output_path.dirname)
+      # write the filtered data to the output file
+      self.output_path.open("w") do |file|
+        file.write self.render
+      end
+    end
+    
+    protected
+      
+      # Determine the output file path
+      def output_path
+        @output_path ||= ::Pathname.new(@source_path.to_s.
+          sub(self.site.source_dir, self.site.output_dir)) # move to output dir
+      end
+  end
+end

data/lib/massimo/page.rb

@@ -0,0 +1,113 @@
+module Massimo
+  class Page < View
+    META_SEP = %r/\A---\s*(?:\r\n|\n)?\z/ # :nodoc:
+    
+    # Creates a new page associated with the given file path.
+    def initialize(source_path)
+      @source_path = ::Pathname.new(source_path)
+      @meta_data   = {
+        :title     => @source_path.basename.to_s.gsub(@source_path.extname, "").titleize, 
+        :extension => ".html",
+        :url       => @source_path.to_s.gsub(self.site.pages_dir, "").gsub(@source_path.extname, "").dasherize,
+        :layout    => "application"
+      }
+      # read and parse the source file
+      self.read_source!
+    end
+    
+    # Override render to wrap the result in the layout
+    def render(with_layout = true)
+      if with_layout && layout = self.find_layout
+        layout.render(:page => self) { self.render(false) }
+      else
+        super()
+      end
+    end
+    
+    # Writes the filtered data to the output file.
+    def process!
+      refresh_layout
+      path = self.output_path
+      # Make the full path to the directory of the output file
+      ::FileUtils.mkdir_p(path.dirname)
+      # write the filtered data to the output file
+      path.open("w") do |file|
+        file.write self.render(self.layout?)
+      end
+    end
+    
+    # Override to_s so that the layout can include the page with <%= page %>
+    def to_s
+      self.render(false)
+    end
+    
+    protected
+    
+      # Reads the source page file, and populates the meta_data and
+      # body attributes.
+      def read_source!
+        # read the source file and setup some values for the loop
+        source       = super()
+        @line        = nil
+        front_matter = false
+        meta_data    = ""
+        body         = ""
+        
+        # Loop through source to get meta data
+        # and the correct line number for the body
+        source.each_with_index do |line, line_num|
+          if line =~ META_SEP
+            front_matter = !front_matter
+          else
+            if front_matter
+              meta_data << line
+            else
+              @line ||= line_num
+              body   << line
+            end
+          end
+        end
+        
+        # finally get the meta_data as a hash and set the body
+        meta_data = ::YAML.load(meta_data)
+        @meta_data.merge!(meta_data.symbolize_keys) if meta_data
+        @body = body
+      end
+      
+      # Determine the output file path
+      def output_path
+        path  = self.site.output_dir(self.url)
+        path << if index? or not html?
+            self.extension unless path.match(/#{self.extension}$/)
+          else
+            "/index.html" unless path.match(/\/index\.html$/)
+          end
+        ::Pathname.new(path)
+      end
+      
+      # Determines if this is an index page
+      def index?
+        @source_path.basename.to_s =~ /^index/
+      end
+      
+      # Determines if this an HTML page.
+      def html?
+        self.extension =~ /(html|php)$/
+      end
+      
+      # The next time `find_layout` is called, the layout will be reloaded.
+      def refresh_layout
+        @layout_view = nil
+      end
+      
+      # Determines if there's a layout associated with this page.
+      def layout?
+        self.layout != false && !self.find_layout.nil?
+      end
+      
+      # Finds the Layout View if it exists
+      def find_layout
+        @layout_view ||= self.site.find_view("layouts/#{self.layout}") unless self.layout == false
+      end
+  end
+end