sitefuel 0.0.0a

data/README

@@ -0,0 +1,86 @@
+~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-
+ 
+ 
+                                   SiteFuel
+                             http://sitefuel.org
+                           v0.1.0 (initial release)
+ 
+
+~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-
+
+A program and API for minifying websites and web applications and 
+deploying them from version control.
+
+   * Get started: http://sitefuel.org/getstarted
+   * Lists: http://sitefuel.org/mailinglists
+   * Report a bug: http://sitefuel.org/bug
+   
+   * Contribute! http://sitefuel.org/contribute
+
+
+== Table of Contents
+
+  1. Introduction
+   . System Requirements
+   . Supported Formats
+   . Installation
+   . Getting Started
+   . Reporting a Bug
+   . A Note about the API
+   . Further Reading
+
+
+== Introduction 
+SiteFuel is a Ruby program 
+
+Use SiteFuel to:
+  * deploy your website out of SVN or GIT
+  * minify your 
+
+
+== System Requirements
+
+  * Ruby 1.8.6 or greater.
+  * pngcrush (for PNG compression)
+  * jpegtran (for JPEG compression)
+  * git (for deploying sites from Git repositories)
+  * svn (for deploying sites from SVN repositories)
+
+SiteFuel hasn't been tested on Windows machines.
+
+
+== Installation
+
+SiteFuel is deployed as a RubyGem through http://gemcutter.org. You 
+should be able to install it directly using RubyGems:
+
+     $ gem install -t sitefuel
+
+You can also download a ZIP-file containing SiteFuel and all of the gems 
+it depends on from http://sitefuel.org/download/sitefuel-complete.zip
+
+Note that for PNG and JPEG compression to be enabled you must install 
+the 'pngcrush' and 'jpegtran' programs.
+
+
+
+== Getting Started
+
+SiteFuel 
+
+
+
+
+== Reporting a Bug
+
+
+== A Note About the API
+
+The general API in SiteFuel should be considered unstable while SiteFuel 
+is <1.0. For practical reasons we can't increment the major version 
+number each time there is a non-backwards compatible API change....
+
+
+== Further Reading
+   * http://sitefuel.org       - main sitefuel website
+   * http://sitefuel.org/help  - pointers to various resources

data/RELEASE_NOTES

@@ -0,0 +1,7 @@
+== 0.1.0
+* initial public release of the SiteFuel alpha
+* support for trivial minification of HTML, RHTML, and PHP.
+* uses CSSMin and JSMin to minify CSS and JavaScript; both in individual
+  files and embedded in HTML.
+* uses pngcrush and jpegtran to minify PNG and JPEG images.
+* support for the Git and SVN version control systems.

data/bin/sitefuel

@@ -0,0 +1,162 @@
+#!/usr/bin/ruby -wrubygems
+
+# == Synopsis
+#
+# A lightweight ruby framework for processing and deploying websites, either
+# from
+#
+# == Usage
+#
+#  sitefuel deploy|process SOURCE [OPTIONS]
+#
+# == Introduction
+# sitefuel is a lightweight ruby framework for deploying websites directly from
+# version control. sitefuel includes support for compressing HTML and CSS as
+# well as optimizing PNG graphics. Support is planned for SASS; compressing
+# JavaScript; automatically creating sprites; and supporting more image formats.
+# (and more!)
+# 
+# TODO: add more details
+#
+# * More information: http://sitefuel.org
+# * Getting started: http://sitefuel.org/getstarted
+# * Documentation: http://sitefuel.org/documentation
+#
+# == Commands
+#
+# deploy::      Deploy a site using sitefuel.
+# process::     Modify an existing website inplace.
+# stage::       Simulates a deployment without actually changing anything.
+# help::        Show this message.
+#
+# == Examples
+# Process an already deployed site:
+#  sitefuel process /var/www/
+#
+# Deploy a site from SVN:
+#  sitefuel deploy svn+ssh://sitefuel.org/svn/tags/21 /var/www/
+#
+# Specify a non-default deployment file:
+#  sitefuel process /var/www/ -c customdeployment.yml
+#
+#
+# == Author
+# Zanoccio, LLC.
+#
+# == Copyright
+# Copyright (c) 2009 Zanoccio.
+#
+# == License
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+#
+
+# add source/ to the load path
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
+begin
+  require 'rubygems'
+rescue LoadError
+  # attempt to continue running the program
+end
+
+
+require 'rdoc/usage'
+require 'term/ansicolor'
+
+require 'sitefuel/SiteFuelRuntime'
+
+include Term::ANSIColor
+
+def puts_and_exit(*args)
+  puts(*args)
+  exit
+end
+
+$HELP_HINT_LINE = "type \'#{$0} help\' for usage"
+
+# parse command line arguments and configure a SiteFuelRuntime
+def parse_command_line(runtime)
+
+  #### BUILD THE OPTIONS PARSER
+  opts = OptionParser.new
+
+  # the banner text comes from the header comment for this file
+
+  opts.on('-oARG', '-o=ARG', '-o PLACE', '--output=ARG', '--output PLACE', String,
+          'Where to put a deployed site') do |out|
+    runtime.deploy_to = out
+  end
+  opts.on('-v', '--version', 'Gives the version of sitefuel') do
+    puts 'SiteFuel ' + VERSION_TEXT
+  end
+
+  opts.on('--[no-]verbose', 'List actions as they are preformed') do
+     puts 'cause SiteFuel to be verbose listing actions as they are preformed'
+  end
+  
+  opts.on('--only-list-recognized-files', 'Only list summaries for files which were changed') do
+    runtime.only_list_recognized_files = true
+  end
+
+  opts.on('-h', '--help', '-?', '--about', 'Gives help for a specific command.') do
+    RDoc::usage_no_exit('Synopsis', 'Usage', 'Introduction')
+    puts opts
+    RDoc::usage_no_exit('Examples', 'Author', 'Copyright', 'License')
+    exit
+  end
+
+  opts.separator ''
+  opts.separator 'Specific options for a command can be seen with: '
+  opts.separator '    COMMAND --help'
+
+
+  #### ATTEMPT TO PARSE THE COMMAND LINE
+  begin
+    commands = opts.parse(*ARGV)
+  rescue OptionParser::InvalidOption => iopt
+    puts iopt
+    puts_and_exit $HELP_HINT_LINE
+  rescue => exception
+    # TODO: add better handling for the various exceptions (unnecessary
+    #       argument, missing argument, etc.)
+    puts_and_exit "couldn't parse command line: #{exception}", $HELP_HINT_LINE
+  end
+
+
+  # note that --help will have already been intercepted but 'help' still needs
+  # special treatment
+  puts_and_exit 'no command given', $HELP_HINT_LINE if commands.length < 1
+  puts_and_exit opts if commands[0].downcase == 'help'
+
+  case commands[0].downcase
+  when 'deploy'
+    runtime.deploy_from = commands[1]
+    runtime.deploy
+
+  when 'stage'
+    runtime.deploy_from = commands[1]
+    runtime.stage
+    
+  else
+    puts_and_exit "unknown command: '#{commands[0]}'", $HELP_HINT_LINE
+  end
+end
+
+def main
+  runtime = SiteFuel::SiteFuelRuntime.new
+  parse_command_line(runtime)
+end
+
+main()

data/lib/sitefuel/Configuration.rb

@@ -0,0 +1,35 @@
+#
+# File::      configuration.rb
+# Author::    wkm
+# Copyright:: 2009
+# License::   GPL
+#
+# Load and process SiteFuel YAML configuration files
+#
+
+module SiteFuel
+  require 'yaml'
+
+  class Configuration
+
+    # exception which represents that a configuration could not be found
+    class NotFound < StandardError
+    end
+
+    # given a directory path will attempt to location a configuration file
+    # and load it, returning a SiteFuel::Configuration class
+    def self.load(path)
+      unless File.exist?(path)
+        throw NotFound, path
+      end
+
+      yamlconfig = YAML::load_file(configfile)
+      
+      Configuration.new(yamlconfig)
+    end
+
+    # builds a sitefuel configuration from a parsed YAML file
+    def initialize(yamlconfig)
+    end
+  end
+end

data/lib/sitefuel/SiteFuelLogger.rb

@@ -0,0 +1,128 @@
+#
+# File::      SiteFuelLogger.rb
+# Author::    wkm
+# Copyright:: 2009
+# License::   GPL
+#
+
+module SiteFuel
+  
+  require 'logger'
+  require 'singleton'
+  require 'term/ansicolor'
+
+  include Term::ANSIColor
+
+  # Singleton abstraction around the Logger:: library, typically every processor
+  # will hook into using this logger while letting us control it's placement
+  # and display globally
+  class SiteFuelLogger < Logger
+    include Singleton
+
+    # the number of fatal messages logged so far (even if lower than #level)
+    attr_reader :fatal_count
+
+    # the number of error messages logged so far (even if lower than #level)
+    attr_reader :error_count
+
+    # the number of warning messages logged so far (even if lower than #level)
+    attr_reader :warn_count
+
+    # the number of info messages logged so far (even if lower than #level)
+    attr_reader :info_count
+
+    # the number of debug messages logged so far (even if lower than #level)
+    attr_reader :debug_count
+
+    # adjust the style of logging:
+    #
+    # default:: use the Logger logging style
+    # clean:: gives a clean logging output intended for human use
+    attr_accessor :log_style
+
+    def initialize(filename = STDOUT)
+      super(filename)
+      
+      @fatal_count = 0
+      @error_count = 0
+      @warn_count = 0
+      @info_count = 0
+      @debug_count = 0
+
+      self.level = WARN
+      @log_style = :default
+      @progname = 'SiteFuel'
+    end
+
+    def fatal(*args)
+      @fatal_count += 1
+      super(*args)
+    end
+
+    def error(*args)
+      @error_count += 1
+      super(*args)
+    end
+
+    def warn(*args)
+      @warn_count += 1
+      super(*args)
+    end
+
+    def info(*args)
+      @info_count += 1
+      super(*args)
+    end
+
+    def debug(*args)
+      @debug_count += 1
+      super(*args)
+    end
+
+    # implement our own #add so we can have cleaner logs
+    def format_message(severity, date_time, program_name, msg)
+      case @log_style
+        when :default
+          super(severity, date_time, program_name, msg)
+
+        when :clean
+          string = "#{severity}: #{msg}\n"
+          case severity
+            when 'ERROR', 'FATAL'
+              string = bold(red(string))
+
+            when 'WARN'
+              string = yellow(string)
+
+            when 'DEBUG'
+              string = string
+          end
+          string
+      end
+    end
+  end
+
+  # mixin for adding logging functionality to any class, typically included
+  # by every SiteFuel class
+  module Logging
+    # sets the logger for a class
+    def logger=(logger)
+      @logger = logger
+    end
+
+    # adds a fatal error to the log
+    def fatal(*args) @logger.fatal(*args); end
+    
+    # adds an error to the log
+    def error(*args) @logger.error(*args); end
+
+    # adds a warning to the log
+    def warn(*args) @logger.warn(*args); end
+
+    # adds an info message to the log
+    def info(*args) @logger.info(*args); end
+
+    # adds a debugging message to the log
+    def debug(*args) @logger.debug(*args); end
+  end
+end

data/lib/sitefuel/SiteFuelRuntime.rb

@@ -0,0 +1,293 @@
+#
+# File::      SiteFuelRuntime.rb
+# Author::    wkm
+# Copyright:: 2009
+# License::   GPL
+#
+# Defines the primary interface class used by sitefuel to do actual work.
+# Keeping this as a class let's us abstract away the command line interface
+# while automatically having a direct API for programatically accessing
+# sitefuel.
+#
+
+
+module SiteFuel
+
+  require 'optparse'
+  require 'term/ansicolor'
+
+  include Term::ANSIColor
+
+  require 'sitefuel/SiteFuelLogger'
+
+  require 'sitefuel/extensions/StringFormatting'
+  require 'sitefuel/extensions/FileComparison'
+
+  # we need the AbstractProcessor symbol when we go child-class hunting
+  require 'sitefuel/processors/AbstractProcessor'
+
+  # version of SiteFuel
+  VERSION = [0, 0, 1].freeze
+
+  # a human readable version
+  VERSION_TEXT = VERSION.join('.').freeze
+  
+
+  class SiteFuelRuntime
+
+    include SiteFuel::Logging
+
+    # what action is the runtime supposed to preform
+    attr_accessor :action
+
+    # what is the source *from* which we are deploying
+    attr_accessor :deploy_from
+
+    # what is the source *to* which we are deploying
+    attr_accessor :deploy_to
+
+    # configuration loaded from a deployment.yml file
+    attr_accessor :deploymentconfiguration
+
+    # only lists file which have a known processor
+    attr_accessor :only_list_recognized_files
+
+    def initialize
+      @processors = SiteFuelRuntime.find_processors
+      self.logger = SiteFuelLogger.instance
+      SiteFuelLogger.instance.log_style = :clean
+
+      @only_list_recognized_files = false
+    end
+
+    # gives true if the given file (typically a processor) has already been
+    # loaded (by looking into $"). Unfortunately #require is easily tricked,
+    # so this function uses some heuristics to prevent processors from being
+    # loaded twice (by basically comparing the "core" part of the filename)
+    def self.processor_loaded?(file)
+      $".map do |f|
+        if File.equivalent?(file, f)
+          return true
+        end
+      end
+      
+      return false
+    end
+
+    # finds all processors under processors/ and loads them. Any file matching
+    # *Processor.rb will be loaded
+    def self.load_processors
+      dir = File.dirname(__FILE__).split(File::SEPARATOR)
+      dir = File.join(*dir[0..-2]) + File::SEPARATOR
+
+      # build up the search pattern by taking this file's directory and shoving
+      # it onto the search pattern
+      patt = File.join(dir, 'sitefuel/processors/*Processor.rb')
+
+      # find all file matching that pattern
+      files = Dir[patt]
+      
+      # rip off the path prefix eg. 'sitefuel/lib/b/foo.rb' becomes 'b/foo.rb'
+      files = files.map do |filename|
+        filename.gsub(Regexp.new("^"+Regexp.escape(dir)), '')
+      end
+
+      # get rid of anything we've already loaded
+      files = files.delete_if { |file| processor_loaded?(file) }
+
+      # load whatever files we're left with
+      files.each { |f| require f }
+    end
+
+    
+    # returns a list of processors found by looking for all children of
+    # SiteFuel::Processor::AbstractProcessor
+    #
+    # for a processor to be automatically included it has to:
+    # * be loaded (see #load_processors)
+    # * be a child class of AbstractProcessor
+    # * the class name must end with Processor
+    #
+    def self.find_processors
+      Processor::AbstractProcessor.find_processors
+    end
+
+    # lists the actions which are possible with this runtime.
+    def actions
+      [ :deploy, :stage ]
+    end
+
+    # gives the array of processors available to this runtime
+    attr_reader :processors
+
+    # adds a processor or an array of processors to the runtime
+    def add_processor(proc)
+      case proc
+        when Array
+          proc.each { |p|
+            @processors << p
+          }
+        else
+          @processors << proc
+      end
+    end
+
+    # gives the processor to use for a given file
+    def choose_processor(filename)
+      matchingprocs = processors.clone.delete_if {|proc| not proc.processes_file?(filename) }
+
+      case
+        when matchingprocs.length > 1
+          chosen = matchingprocs.first
+          raise Processor::MultipleApplicableProcessors.new(filename, matchingprocs, chosen)
+        when matchingprocs.length == 1
+          return matchingprocs.first
+        else
+          return nil
+      end
+    end
+
+    # like #choose_processor but prints a message if there are clashing
+    # processors and returns the first of the clashing processors.
+    # (effectively alerting the user, but continuing to work)
+    def choose_processor!(filename)
+      begin
+        choose_processor(filename)
+      rescue Processor::MultipleApplicableProcessors => exception
+        # log the exception
+        warn exception
+        exception.chosen_processor
+      end
+    end
+
+
+    # implements the stage command. Staging, by itself, will give statistics on
+    # the deployment; how many bytes were saved by minification; etc.
+    #
+    # However, #stage when part of #deploy will go and create the requisite files
+    # in a temporary directory
+    def stage
+      return nil if @deploy_from == nil
+
+      puts '== %s '.format('Staging').ljust(80, '=')
+
+      # find all files under deploy_from
+      files = find_all_files @deploy_from
+
+      total_original_size = 0
+      total_processed_size = 0
+      @resource_processors = {}
+      @processor_statistics = Hash.new([0, 0, 0])
+      files.each do |filename|
+        processor = choose_processor!(filename)
+        if processor == nil
+          @resource_processors[filename] = nil
+        else
+          @resource_processors[filename] = processor.process_file(filename)
+        end
+        
+        processor = @resource_processors[filename]
+        if processor == nil
+          if only_list_recognized_files == false
+            puts '%s %s' %['--'.ljust(8), filename.cabbrev(65)]
+          end
+        else
+          total_original_size += processor.original_size
+          total_processed_size += processor.processed_size
+
+          stats = @processor_statistics[processor.class.processor_name].clone
+          stats[0] += 1
+          stats[1] += processor.original_size
+          stats[2] += processor.processed_size
+          @processor_statistics[processor.class.processor_name] = stats
+
+          puts '%s %s %4.3f' %
+               [
+                 cyan(processor.class.processor_name.ljust(8)),
+                 filename.cabbrev(65).ljust(65),
+                 processor.processed_size.prec_f/processor.original_size.prec_f
+               ]
+        end
+      end
+
+      puts '='*80
+      puts 'Size delta:         %+5d bytes; %4.3f' %
+              [
+                total_processed_size - total_original_size,
+                total_processed_size.prec_f/total_original_size.prec_f
+              ]
+
+      staging_statistics
+    end
+
+    # outputs a little grid showing the number of files of each processor
+    # and the total savings
+    #
+    # todo: this should be computed in the staging step
+    def staging_statistics
+      puts ''
+      puts '     %s | %s  |    %s    | %s' %
+           ['processor', '# files', 'delta', 'ratio'].map{|v| bold(v)}
+      puts '    -----------+----------+-------------+-------'
+      
+      @processor_statistics.keys.sort.each do |key|
+        puts '     %s|%9d |%+12d | %4.3f' %
+             [
+               key.ljust(10),
+               @processor_statistics[key][0],
+               @processor_statistics[key][2] - @processor_statistics[key][1],
+               @processor_statistics[key][2].prec_f / @processor_statistics[key][1].prec_f
+             ]
+      end
+      puts '    -----------+----------+-------------+-------'
+      puts ''
+    end
+
+    # create a deployment
+    def deploy
+      # first we have to stage the files
+      stage
+
+      files = find_all_files @deploy_from
+
+      return if @deploy_to == nil
+      puts
+      puts bold('Deploying:')
+
+      unless File.exists?(@deploy_to)
+        Dir.mkdir(@deploy_to)
+      end
+      # write out content
+      files.each do |filename|
+        results = @resource_processors[filename]
+        if results == nil
+          putc 'I'
+        else
+          putc '.'
+          results.save(@deploy_to)
+        end
+        STDOUT.flush
+      end
+      puts
+    end
+
+    # gives an array listing of all files on a given path
+    #
+    # This is a very lightweight wrapper around Dir.
+    def find_all_files(path)
+      Dir[File.join(path, "**/*")]
+    end
+
+    # changes the verbosity of the runtime by adjusting the log level
+    def verbosity(level = 1)
+      case level
+      when 1
+
+      end
+    end
+  end
+
+
+  # load the various processors
+  SiteFuelRuntime.load_processors
+end