sphere 0.1.0

data/.gitignore

@@ -0,0 +1 @@
+pkg

data/README.markdown

@@ -0,0 +1,84 @@
+# Sphere
+
+Sphere is a asset packer and compressor, for Rails, built (primarily) to be used with Heroku + AWS/S3.
+Inspired by [Jammit](http://documentcloud.github.com/jammit) and [Compass](http://wiki.github.com/chriseppstein/compass)
+
+## Quick Start
+
+### Create a `config/shere.yml` file and define your packages. Here an example file:
+
+    # Use packaged assets in views [production: true, other: false].
+    # Hint: Don't hard-code option this in the configuration file,
+    #       instead use your config/environments/* files.
+    # Example:
+    #     # config/environments/staging.rb
+    #     # ...
+    #     Sphere.config.package = true
+    # package: true
+
+    # Where (within Rails.public_path) to store packaged assets [assets -> public/assets]
+    asset_path: assets
+
+    # Compression backend [closure]
+    backend: closure
+
+    # Use compression when packaging assets [production: true, other: false]
+    compress: true
+
+    # Define your javascript packages here:
+    javascripts:
+      # Example assuming default settings (Rails.public_path: public, asset_path: assets):
+      #   Fetch content from http://ajax.googleapis.com and merge/compress it with all files
+      #   matching public/javascripts/vendor/*.js + public/javascripts/custom/*.js into public/assets/application.js
+      application:
+        - http://ajax.googleapis.com/ajax/libs/jquery/1.4.1/jquery.js
+        - javascripts/vendor/*.js
+        - javascripts/custom/*.js
+
+    # Define your stylesheet packages here:
+    stylesheets:
+      # Example assuming default settings (Rails.public_path: public, asset_path: assets):
+      #   Merge/compress public/stylesheets/compiled/screen.css into public/assets/screen.css
+      #   Merge/compress public/stylesheets/compiled/print.css into public/assets/print.css
+      screen:
+        - stylesheets/compiled/screen.css
+      print:
+        - stylesheets/compiled/print.css
+
+### In your layout/application.html.erb
+
+    <%= include_stylesheets :screen, :media => 'screen, projection' %>
+    <%= include_stylesheets :print, :media => 'print' %>
+    <%= include_javascripts :application %>
+
+If the package_assets option is enabled (production), this will produce (given that config.action_controller.asset_host = "http://my-asset-host-bucket.s3.amazonaws.com"):
+
+    <link href="http://my-asset-host-bucket.s3.amazonaws.com/assets/screen.css" media="screen, projection" rel="stylesheet" type="text/css" />
+    <link href="http://my-asset-host-bucket.s3.amazonaws.com/assets/print.css" media="print" rel="stylesheet" type="text/css" />
+    <script src="http://my-asset-host-bucket.s3.amazonaws.com/assets/application.js" type="text/javascript"></script>
+
+If the package_assets option is disabled (development), this will produce:
+
+    <link href="/stylesheets/compiled/screen.css" media="screen, projection" rel="stylesheet" type="text/css" />
+    <link href="/stylesheets/compiled/print.css" media="print" rel="stylesheet" type="text/css" />
+
+    <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.4.1/jquery.js" type="text/javascript"></script>
+    <script src="/javascripts/vendor/jquery.enumerable.js" type="text/javascript"></script>
+    <script src="/javascripts/custom/rails.js" type="text/javascript"></script>
+
+## Include Rake Tasks
+
+Create a new `lib/tasks/sphere.rake` file in your Rails application. Include the following lines:
+
+    # Adds the sphere:compile task
+    load 'sphere/tasks/sphere.rake'
+
+    # [Optional] Extends the sphere:compile:css task; pre-compiles Compass/SASS files to CSS before packaging
+    load 'sphere/tasks/compass.rake'
+
+    # [Optional] Adds sphere:upload & sphere:deploy tasks for automated S3 upload
+    load 'sphere/tasks/upload.rake'
+
+    # [Optional] Adds sphere:commit:hook task you can run to ensure all assets are up-to-date.
+    # Just e.g. add "rake sphere:commit:hook -s" to your .git/hooks/pre-commit hook.
+    load 'sphere/tasks/commit.rake'

data/Rakefile

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'spec/rake/spectask'
+require 'spec/version'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = ['--colour', '--format', 'profile', '--timeout', '20']
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "sphere"
+    gemspec.summary = "Asset packer and compressor, for Rails"
+    gemspec.description = "Built (primarily) to be used with Heroku + AWS/S3"
+    gemspec.email = "dimitrij@blacksquaremedia.com"
+    gemspec.homepage = "http://github.com/dim/sphere"
+    gemspec.authors = ["Dimitrij Denissenko"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/sphere.rb

@@ -0,0 +1,32 @@
+require 'open-uri'
+
+module Sphere
+  autoload :Config, 'sphere/config'
+  autoload :Packager, 'sphere/packager'
+  autoload :Helper, 'sphere/helper'
+  autoload :CSSMinifier, 'sphere/css_minifier'
+
+  module Package
+    autoload :Base, 'sphere/package/base'
+    autoload :Javascript, 'sphere/package/javascript'
+    autoload :Stylesheet, 'sphere/package/stylesheet'
+  end
+
+  module Backends
+    autoload :Base, 'sphere/backends/base'
+    autoload :Closure, 'sphere/backends/closure'
+  end
+
+  def self.config
+    @config ||= Config.new
+  end
+
+  def self.reset!
+    @config = nil
+    self
+  end
+
+  def self.packager
+    Sphere::Packager.instance
+  end
+end

data/lib/sphere/backends/base.rb

@@ -0,0 +1,44 @@
+require 'net/http'
+
+module Sphere
+  module Backends
+    class Base
+
+      class << self
+
+        def default_options
+          {}
+        end
+
+        def uri
+          raise "Abstract Method"
+        end
+
+      end
+
+      attr_reader :content
+
+      def initialize(content)
+        @content = content
+      end
+
+      def compressed(options = {})
+        params   = create_params!(self.class.default_options.merge(options))
+        response = Net::HTTP.post_form self.class.uri, params
+        unless response.code == '200'
+          STDERR.puts "ERROR during compilation. Response:"
+          STDERR.puts response.body
+          raise "Aborting!"
+        end
+        response.body
+      end
+
+      protected
+
+        def create_params!(options)
+          options.to_a
+        end
+
+    end
+  end
+end

data/lib/sphere/backends/closure.rb

@@ -0,0 +1,29 @@
+require 'net/http'
+
+module Sphere
+  module Backends
+    class Closure < Base
+
+      class << self
+
+        def default_options
+          { :compilation_level  => 'SIMPLE_OPTIMIZATIONS',
+            :output_format      => 'text',
+            :output_info        => 'compiled_code' }
+        end
+
+        def uri
+          @uri ||= URI.parse('http://closure-compiler.appspot.com/compile')
+        end
+
+      end
+
+      protected
+
+        def create_params!(options)
+          options.merge(:js_code => content).to_a
+        end
+
+    end
+  end
+end

data/lib/sphere/backends/yui.rb

@@ -0,0 +1,28 @@
+require 'net/http'
+
+module Sphere
+  module Backends
+    class YUI < Base
+
+      class << self
+
+        def default_options
+          { :type  => 'JS' }
+        end
+
+        def uri
+          @uri ||= URI.parse('http://refresh-sf.com/yui/')
+        end
+
+      end
+
+      protected
+
+        def create_params!(options)
+          options.merge(:compresstext => content).to_a
+        end
+
+    end
+  end
+end
+

data/lib/sphere/config.rb

@@ -0,0 +1,55 @@
+module Sphere
+  class Config
+    attr_accessor :env, :root
+    attr_writer   :config_file, :asset_path, :backend, :compress, :package
+
+    def initialize
+      self.env  = defined?(Rails) ? Rails.env.to_s : 'development'
+      self.root = defined?(Rails) ? Rails.root : Pathname.new('.')
+    end
+
+    def update!(&block)
+      block.call(self)
+      self
+    end
+
+    def config_file
+      @config_file || root.join('config', 'sphere.yml')
+    end
+
+    def asset_path
+      @asset_path || public_path.join(definitions['asset_path'] || 'assets')
+    end
+
+    def backend
+      @backend || "Sphere::Backends::#{(definitions['backend'] || 'closure').classify}".constantize
+    end
+
+    def javascripts
+      definitions['javascripts'] || {}
+    end
+
+    def stylesheets
+      definitions['stylesheets'] || {}
+    end
+
+    def compress?
+      defined?(@compress) ? !!@compress : (definitions.key?('compress') ? !!definitions['compress'] : (self.env == 'production'))
+    end
+
+    def package?
+      defined?(@package) ? !!@package : (definitions.key?('package') ? !!definitions['package'] : (self.env == 'production'))
+    end
+
+    def public_path
+      @public_path ||= defined?(Rails) ? Pathname.new(Rails.public_path.to_s) : root.join('public')
+    end
+
+    private
+
+      def definitions
+        @definitions ||= YAML.load_file(config_file)
+      end
+
+  end
+end

data/lib/sphere/css_minifier.rb

@@ -0,0 +1,29 @@
+module Sphere
+  class CSSMinifier < String
+
+
+    def initialize(css)
+      super(css.dup)
+    end
+
+    def minify!
+      gsub!(/\/\*.+?\*\//m, '')
+      strip!
+      gsub!(/(\A|\})(.+?)(\z|\{)/m) do |m|
+        prefix, tags, suffix = $1, $2, $3
+        "#{prefix}#{tags.split(',').map(&:strip).reject(&:blank?).join(',')}#{suffix}"
+      end
+      gsub!(/\{(.+?)\}/m) do |m|
+        styles = $1.split(';').map do |style|
+          key, values = style.split(':')
+          next nil unless key && values
+          "#{key.strip}:#{values.split(',').map(&:strip).reject(&:blank?).join(',')}"
+        end.compact.join(';')
+        "{#{styles};}"
+      end
+      gsub!(/[\r\n]/m, '')
+      self
+    end
+
+  end
+end

data/lib/sphere/helper.rb

@@ -0,0 +1,38 @@
+module Sphere
+  module Helper
+
+    def include_javascripts(*package_names)
+      options = package_names.extract_options!
+      tags = package_names.map do |name|
+        if Sphere.config.package?
+          compute_public_path(name.to_s, Sphere.config.asset_path, Sphere::Package::Javascript.extension)
+        else
+          individual_includable_urls(name, :js, options)
+        end
+      end
+      javascript_include_tag(*(tags.flatten << options))
+    end
+
+    def include_stylesheets(*package_names)
+      options = package_names.extract_options!
+      tags = package_names.map do |name|
+        if Sphere.config.package?
+          compute_public_path(name.to_s, Sphere.config.asset_path, Sphere::Package::Stylesheet.extension)
+        else
+          individual_includable_urls(name, :css, options)
+        end
+      end
+      stylesheet_link_tag(*(tags.flatten << options))
+    end
+
+    private
+
+      def individual_includable_urls(package_name, extension, options = {})
+        package = Sphere.packager.packages(extension.to_sym)[package_name.to_s]
+        (package ? package.sources : []).map do |source|
+          compute_public_path(source.to_s, '', extension.to_s).sub(/^\/\//, '/')
+        end
+      end
+
+  end
+end

data/lib/sphere/package/base.rb

@@ -0,0 +1,87 @@
+module Sphere
+  module Package
+    class Base
+
+      def self.extension
+        raise "Abstract Method"
+      end
+
+      attr_reader :name
+
+      def initialize(name, sources)
+        @name    = name
+        @sources = sources
+      end
+
+      def file
+        @file ||= Sphere.config.asset_path.join("#{name}.#{self.class.extension}")
+      end
+
+      def public_file_name
+        file.to_s.sub "#{Sphere.config.public_path}/", ''
+      end
+
+      def out_of_date?
+        !file.exist? || mtime > file.mtime
+      end
+
+      def compile(options = {})
+        unless out_of_date?
+          STDOUT.puts "unchanged #{public_file_name}" if options[:verbose] == true
+          return unless options[:force] == true
+        end
+
+        STDOUT.puts "\e[32m  compile #{public_file_name}\e[0m" if options[:verbose] == true
+        content = ""
+        expanded_sources.each do |source|
+          content << open(source).read
+        end
+        content = compress(content) if Sphere.config.compress?
+
+        FileUtils.mkdir_p(File.dirname(file))
+        file.open('w') {|f| f.write(content) }
+      end
+
+      def sources
+        @sources.map do |source|
+          url?(source) ? source : relative_paths(source)
+        end.flatten
+      end
+
+      def source_files
+        expanded_sources - source_urls
+      end
+
+      def source_urls
+        expanded_sources.select {|s| url?(s) }
+      end
+
+      protected
+
+        def expanded_sources
+          sources.map do |source|
+            url?(source) ? source : Sphere.config.public_path.join(source)
+          end
+        end
+
+        def relative_paths(glob)
+          Dir[Sphere.config.public_path.join(glob)].sort.map do |path|
+            path.sub "#{Sphere.config.public_path}/", ''
+          end
+        end
+
+        def mtime
+          (source_files.map(&:mtime) + [Sphere.config.config_file.mtime]).max
+        end
+
+        def compress(content)
+          content
+        end
+
+        def url?(source)
+          source =~ /^https?\:/
+        end
+
+    end
+  end
+end