spar 0.2.7 → 1.0

data/lib/spar/cli.rb

@@ -1,32 +1,85 @@
-require 'rbconfig'
+require 'pathname'
+require 'fileutils'
+require 'listen'
+require 'rack'
+require 'thor'
 
-if RUBY_VERSION < '1.9.2'
-  desc = defined?(RUBY_DESCRIPTION) ? RUBY_DESCRIPTION : "ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE})"
-  abort <<-end_message
+module Spar
+  class CLI < Thor
+    include Thor::Actions
 
-    Spar requires Ruby 1.9.2+.
+    def self.source_root
+      File.expand_path('../../..', __FILE__)
+    end
 
-    You're running
-      #{desc}
+    desc 'server', 'Serve spar application'
 
-    Please upgrade to continue.
+    method_option :port, :aliases => '-p', :desc => 'Port'
 
-  end_message
-end
-Signal.trap("INT") { puts; exit(1) }
+    def server
+      Rack::Server.start(
+        :Port => options[:port] || 8888,
+        :app  => Spar.app
+      )
+    end
 
-require 'spar/version'
+    desc 'deploy', 'Deploy the project.'
 
-if ['--version', '-v'].include?(ARGV.first)
-  puts "Spar #{Spar::VERSION}"
-  exit(0)
-end
+    def deploy(environment='production')
+      say "Deploying: #{Spar.root}"
 
-if ARGV.first.nil?
-  puts "Please specify a name for your new app like so: 'spar APP_NAME'"
-  exit(0)
-end
+      Spar.environment = environment
+      
+      if strategy = Spar.settings['deploy_strategy']
+        require "spar/deployers/#{strategy}_deployer"
+
+        deployer = Kernel.const_get("#{strategy.capitalize()}Deployer").new
 
-require 'spar/generators/application'
+        deployer.run(Spar::Compiler.assets)
+      else
+        raise "You are trying to deploy to the #{environment} environment, but you have not declared a :deploy_strategy in config.yml for this environment. The available options are: 'local', 's3', and 'cloudfront'."
+      end
+    end
 
-Spar::Generators::Application.new.generate(ARGV.first)
+    desc 'version', 'Show the current version of Spar'
+
+    def version
+      puts "Spar Version #{Spar::VERSION}"
+    end
+
+    desc 'new', 'Create a new spar project'
+
+    method_option :css, :desc => 'Use css instead of sass'
+    method_option :html, :desc => 'Use html instead of haml'
+    method_option :js, :desc => 'Use js instead of coffeescript'
+    
+    def new(name)
+      # first, copy in the base directory
+      directory('lib/spar/generators/templates/base', name)
+      
+      if !options[:css]
+        # copy in the sass files
+        directory('lib/spar/generators/templates/styles/sass', name)
+      else
+        # copy in the css files
+        directory('lib/spar/generators/templates/styles/css', name)
+      end
+      
+      if !options[:html]
+        # copy in the haml files
+        directory('lib/spar/generators/templates/pages/haml', name)
+      else
+        # copy in the html files
+        directory('lib/spar/generators/templates/pages/html', name)
+      end
+      
+      if !options[:js]
+        # copy in the coffee files
+        directory('lib/spar/generators/templates/scripts/coffee', name)
+      else
+        # copy in the js files
+        directory('lib/spar/generators/templates/scripts/js', name)
+      end
+    end
+  end
+end

data/lib/spar/compiled_asset.rb

@@ -0,0 +1,90 @@
+require 'mime/types'
+
+module Spar
+
+  class CompiledAsset
+
+    attr_accessor :asset, :logical_path, :write_path, :headers, :mtime, :digest
+
+    def initialize(asset, options={})
+      if asset.is_a?(String)
+        @file = File.new(asset, 'rb')
+        @logical_path = asset
+      else
+        @asset = asset
+        @logical_path = @asset.logical_path
+      end
+      @write_path = generate_write_path(options)
+      @headers    = generate_headers(options)
+      @mtime      = (@asset || @file).mtime
+      @digest     = @asset ? @asset.digest : Digest::MD5.hexdigest(data)
+    end
+
+    def generate_write_path(options)
+      if options[:digest] && @asset
+        @asset.digest_path
+      else
+        @asset ? @logical_path : @logical_path.gsub(/^static\//,'')
+      end
+    end
+
+    def generate_headers(options)
+      headers = {
+        :cache_control => options[:cache_control] || Spar.settings['cache_control'],
+        :acl => :public_read
+      }
+
+      if @write_path =~ /\/.html$/
+        headers[:content_type] = 'text/html; charset=utf-8'
+      else
+        headers[:content_type] = MIME::Types.of(@write_path).first
+      end
+
+      if @logical_path =~ /static\/downloads\//
+        headers[:content_disposition] = "attachment; filename=#{File.basename(@write_path)}"
+      end
+
+      headers[:content_encoding] = :gzip if %w[svgz gz].index @write_path.split('.').last
+      
+      headers
+    end
+
+    def data
+      @data ||= @asset ? @asset.to_s : @file.read
+    end
+
+    def write_to(base_path, options = {})
+      filename = File.join(base_path, @write_path)
+      # Gzip contents if filename has '.gz'
+      options[:compress] ||= File.extname(filename) == '.gz'
+
+      FileUtils.mkdir_p File.dirname(filename)
+
+      File.open("#{filename}+", 'wb') do |f|
+        if options[:compress]
+          # Run contents through `Zlib`
+          gz = Zlib::GzipWriter.new(f, Zlib::BEST_COMPRESSION)
+          gz.mtime = @mtime.to_i
+          gz.write data
+          gz.close
+        else
+          # Write out as is
+          f.write data
+          f.close
+        end
+      end
+
+      # Atomic write
+      FileUtils.mv("#{filename}+", filename)
+
+      # Set mtime correctly
+      File.utime(@mtime, @mtime, filename)
+
+      nil
+    ensure
+      # Ensure tmp file gets cleaned up
+      FileUtils.rm("#{filename}+") if File.exist?("#{filename}+")
+    end
+
+  end
+end

data/lib/spar/compiler.rb

@@ -0,0 +1,74 @@
+require 'fileutils'
+require 'find'
+
+module Spar
+  module Compiler
+
+    def self.assets
+      assets = []
+      Spar.sprockets.each_logical_path do |logical_path|
+        next unless compile_info = path_compile_info(logical_path)
+        if asset = Spar.sprockets.find_asset(logical_path)
+          assets << Spar::CompiledAsset.new(asset, compile_info)
+        end
+      end
+      Dir.chdir(Spar.root) do
+        if Dir.exists?('static')
+          Find.find('static').each do |path|
+            if FileTest.directory?(path)
+              if File.basename(path)[0] == '..'
+                Find.prune # Don't look any further into this directory.
+              else
+                next
+              end
+            else
+              if File.basename(path) == '.DS_Store'
+                next
+              else
+                assets << Spar::CompiledAsset.new(path)
+              end
+            end
+          end
+        end
+      end
+      assets
+    end
+
+    def self.path_compile_info(logical_path)
+      if logical_path =~ /\.html/
+        return {
+          :digest         => false, 
+          :cache_control  => 'no-cache'
+        }
+      elsif logical_path =~ /\w+\.(?!js|css).+/
+        return {
+          :digest         => Spar.settings['digests'], 
+          :cache_control  => Spar.settings['cache_control']
+        }
+      elsif file_path = Spar.sprockets.resolve(logical_path)
+        file = File.open(file_path, "rb").read
+        if header = file[Sprockets::DirectiveProcessor::HEADER_PATTERN, 0]
+          if directive = header.lines.peek[Sprockets::DirectiveProcessor::DIRECTIVE_PATTERN, 1]
+            name, *args = Shellwords.shellwords(directive)
+            if name == 'deploy'
+              return deploy_directive_info(*args)
+            end
+          end
+        end
+      end
+      nil
+    end
+
+    def self.deploy_directive_info(*args)
+      options = {}
+      args.each do |arg| 
+        options[arg.split(':')[0]] = arg.split(':')[1]
+      end
+      {
+        :digest         => Spar.settings['digests'],
+        :cache_control  => options['cache_control'] || Spar.settings['cache_control']
+      }
+    end
+
+  end
+end

data/lib/spar/compressor.rb

@@ -0,0 +1,18 @@
+module Spar
+  module Compressor
+    class JS
+      def compress(source, options = {})
+        require 'uglifier'
+        Uglifier.compile(source, options.merge(Spar.settings['js_compressor']))
+      end
+    end
+
+    class CSS
+      def compress(source, options = {})
+        require 'yui/compressor'
+        compressor = YUI::CssCompressor.new(options.merge(Spar.settings['css_compressor']))
+        compressor.compress(source)
+      end
+    end
+  end
+end

data/lib/spar/deployers/cloudfront_deployer.rb

@@ -0,0 +1,33 @@
+require 'cloudfront-invalidator'
+
+class CloudfrontDeployer < S3Deployer
+
+  def prepare(assets)
+    super
+    @cloudfront_distribution = Spar.settings['cloudfront_distribution']
+    raise "ERROR: You should set a :cloudfront_distribution in your config.yml file so you can deploy to Cloudfront" unless @cloudfront_distribution
+    @invalidator = CloudfrontInvalidator.new(
+      @aws_key,
+      @aws_secret,
+      @cloudfront_distribution
+    )
+  end
+
+  def finish
+    to_invalidate = @deployed_assets.collect do |asset|
+      if asset.write_path =~ /\.html$/
+        [ asset.write_path, asset.write_path.gsub('index.html',''), asset.write_path.gsub('/index.html','') ]
+      else
+        asset.write_path
+      end
+    end
+    to_invalidate << 'TIMESTAMP.txt'
+
+    @invalidator.invalidate(to_invalidate.flatten) do |status,time|
+      puts "Invalidation #{status} after %.2f seconds" % time.to_f
+    end
+
+    super
+  end
+
+end

data/lib/spar/deployers/deployer.rb

@@ -0,0 +1,26 @@
+module Spar
+  class Deployer
+
+    def run(assets)
+      prepare(assets)
+      @assets_to_deploy.each { |asset| deploy(asset) }
+      finish
+    end
+
+    def prepare(assets)
+      @assets_to_deploy = assets
+      @deployed_assets  = []
+    end
+
+    def deploy(asset)
+      @deployed_assets << asset
+    end
+
+    def finish
+      @deployed_assets.each do |asset|
+        puts "Deployed Asset: #{asset.write_path}"
+      end
+    end
+
+  end
+end

data/lib/spar/deployers/local_deployer.rb

@@ -0,0 +1,15 @@
+class LocalDeployer < Spar::Deployer
+
+  def prepare(assets)
+    super
+
+    @deploy_path = Spar.settings['deploy_path']
+    raise "ERROR: You should set the :deploy_path in your config.yml to a directory you want to do the local deploy to." unless @deploy_path
+  end
+
+  def deploy(asset)
+    asset.write_to(@deploy_path)
+    super
+  end
+
+end

data/lib/spar/deployers/s3_deployer.rb

@@ -0,0 +1,75 @@
+require 'aws-sdk'
+require 'logger'
+
+class S3Deployer < Spar::Deployer
+
+  def prepare(assets)
+    @aws_key       = Spar.settings['aws_key']
+    @aws_secret    = Spar.settings['aws_secret']
+    @deploy_bucket = Spar.settings['deploy_bucket']
+    unless @aws_key and @aws_secret and @deploy_bucket
+      raise "ERROR: You should set :aws_key, :aws_secret, and :deploy_bucket in your config.yml file so you can deploy to S3"
+    end
+    
+    AWS.config(
+      :access_key_id      => @aws_key,
+      :secret_access_key  => @aws_secret,
+      :logger             => Logger.new($stderr),
+      :log_formatter      => AWS::Core::LogFormatter.colored
+    )
+    AWS.config.logger.level = Logger::WARN
+    @s3 = AWS::S3.new
+    @bucket  = @s3.buckets[@deploy_bucket]
+    unless @bucket.exists?
+      @bucket = @s3.buckets.create(@deploy_bucket)
+    end
+    @age_out = 60 * 60 * 24 * 3 # 3 days 
+
+    super
+
+    local_assets = assets.map(&:write_path)
+    remote_assets = @bucket.objects.map{ |object| object.key }.reject{ |key| key =~ /\/$/ }
+
+    age_out (remote_assets - local_assets)
+  end
+
+  def age_out(old_assets)
+    old_assets.flatten.each do |file|
+      if Time.now - @bucket.objects[file].last_modified > @age_out
+        logger "Deleting #{file}"
+        @bucket.objects[file].delete
+      end
+    end
+  end
+
+  def deploy(asset)
+    remote_file = @bucket.objects[asset.write_path]
+    if remote_file.exists?
+      if remote_file.etag.gsub(/\"/,'') != asset.digest
+        upload(asset)
+        super
+      end
+    else
+      upload(asset)
+      super
+    end
+  end
+
+  def upload(asset)
+    if asset.write_path =~ /\.html$/ && !(asset.write_path =~ /\/?index\.html$/)
+      @bucket.objects[asset.write_path.gsub(/\.html/, '/index.html')].write(asset.headers.merge(:data => asset.data))
+    else
+      @bucket.objects[asset.write_path].write(asset.headers.merge(:data => asset.data))
+    end
+  end
+
+  def finish
+    @bucket.objects['TIMESTAMP.txt'].write(
+      :data => Time.now.to_s+"\n",
+      :content_type => "text/plain",
+      :acl => :public_read
+    )
+    super
+  end
+
+end