amiel-sprockets 1.0.4 → 1.0.5

data/Rakefile

@@ -0,0 +1,26 @@
+require "rubygems"
+require "rake/testtask"
+require "rake/gempackagetask"
+
+task :default => :test
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/test_*.rb"]
+  t.verbose = true
+end
+
+Rake::GemPackageTask.new(eval(IO.read(File.join(File.dirname(__FILE__), "sprockets.gemspec")))) do |pkg|
+  require File.join(File.dirname(__FILE__), "lib", "sprockets", "version")
+  raise "Error: Sprockets::Version doesn't match gemspec" if Sprockets::Version::STRING != pkg.version.to_s
+  
+  pkg.need_zip = true
+  pkg.need_tar = true
+end
+
+namespace :manifest do
+	task :generate do
+		files = Dir["Rakefile", "bin/**/*", "lib/**/*", "test/**/*", "ext/**/*"]
+		File.open("MANIFEST.txt", "w"){|f| f.puts *files }
+	end
+end

data/ext/nph-sprockets.cgi

@@ -0,0 +1,127 @@
+#!/usr/bin/env ruby
+
+# This is a simple CGI wrapper around Sprockets. 
+#
+# Copy it into a directory on your site with CGI enabled. When invoked, the 
+# script will search its directory and parent directories for a YAML file named
+# "config/sprockets.yml" in order to load configuration information.
+#
+# If you set the environment variable "sprockets_generate_output_file" to 
+# "true" the concatenation will be cached to disk. Use it in conjunction with 
+# URL rewriting to cache your Sprockets output on the first request.
+#
+# Assuming a site layout like this:
+#
+#     mysite/
+#       config/
+#         sprockets.yml
+#       javascripts/
+#         mysite.js
+#         ...
+#       public/
+#         index.html
+#         nph-sprockets.cgi (this file)
+#       vendor/
+#         sprockets/
+#           prototype/ -> ...
+#           scriptaculous/ -> ...
+#
+# mysite/config/sprockets.yml might look like this:
+#
+#     :load_path:
+#       - javascripts
+#       - vendor/sprockets/*/src
+#     :source_files:
+#       - javascripts/mysite.js
+#       - javascripts/*.js
+#     :output_file: public/sprockets.js
+#
+# The <script> tag in mysite/public/index.html could look like this:
+#
+#     <script type="text/javascript" src="/sprockets.js"></script>
+#
+# And you might have the following Apache configuration:
+#
+#     <VirtualHost ...>
+#       ServerName mysite.example.org
+#       DocumentRoot "/path/to/mysite/public"
+#
+#       <Directory "/path/to/mysite/public">
+#         Options +ExecCGI +FollowSymLinks
+#         AddHandler cgi-script .cgi
+#         
+#         RewriteEngine on
+#         RewriteCond /sprockets.js !-f
+#         RewriteRule ^sprockets\.js /nph-sprockets.cgi [P,L]
+#       </Directory>
+#     </VirtualHost>
+#
+# All requests to /sprockets.js will transparently proxy /nph-sprockets.cgi if
+# mysite/public/sprockets.js does not exist. In production, you can add
+#
+#     SetEnv sprockets_generate_output_file true
+#
+# to your Apache configuration and mysites/public/sprockets.js will be cached
+# on the first request to /sprockets.js.
+
+require "yaml"
+require "fileutils"
+
+def respond_with(options = {})
+  options = { :code => 200, :content => "", :type => "text/plain" }.merge(options)
+  print "HTTP/1.0 #{options[:code]}\r\n"
+  print "Content-Type: #{options[:type]}\r\n"
+  print "Content-Length: #{options[:content].length}\r\n"
+  print "\r\n#{options[:content]}"
+  $stdout.flush
+  exit!
+end
+
+def search_upwards_for(filename)
+  pwd = original_pwd = Dir.pwd
+  loop do
+    return File.expand_path(filename) if File.file?(filename)
+    Dir.chdir("..")
+    respond_with(:code => 500, :content => "couldn't find config/sprockets.yml") if Dir.pwd == pwd
+    pwd = Dir.pwd
+  end
+ensure
+  Dir.chdir(original_pwd)
+end
+
+def generate_output_file?
+  (ENV["REDIRECT_sprockets_generate_output_file"] || ENV["sprockets_generate_output_file"]) =~ /true/i
+end
+
+configuration_file = search_upwards_for("config/sprockets.yml")
+sprockets_root     = File.dirname(File.dirname(configuration_file))
+configuration      = YAML.load(IO.read(configuration_file))
+
+begin
+  if File.directory?(sprockets_dir = File.join(sprockets_root, "vendor/gems/sprockets/lib"))
+    $:.unshift sprockets_dir
+  elsif File.directory?(sprockets_dir = File.join(sprockets_root, "vendor/sprockets/lib"))
+    $:.unshift sprockets_dir
+  else
+    require "rubygems"
+  end
+  
+  require "sprockets"
+  
+rescue Exception => e
+  respond_with(:code => 500, :content => "couldn't find sprockets: #{e}")
+end
+
+begin
+  secretary = Sprockets::Secretary.new(
+    :root         => sprockets_root,
+    :load_path    => configuration[:load_path],
+    :source_files => configuration[:source_files]
+  )
+  
+  secretary.concatenation.save_to(File.join(sprockets_root, configuration[:output_file])) if generate_output_file?
+  respond_with(:content => secretary.concatenation.to_s, :type => "text/javascript")
+  
+rescue Exception => e
+  respond_with(:code => 500, :content => "couldn't generate concatenated javascript: #{e}")
+end

data/lib/sprockets.rb

@@ -0,0 +1,42 @@
+$:.unshift File.dirname(__FILE__)
+
+require "yaml"
+require "fileutils"
+
+module Sprockets
+  class << self
+    def running_on_windows?
+      RUBY_PLATFORM =~ /(win|w)32$/
+    end
+  
+    def absolute?(location)
+      same_when_expanded?(location) || platform_absolute_path?(location)
+    end
+
+    protected
+      def same_when_expanded?(location)
+        location[0, 1] == File.expand_path(location)[0, 1]
+      end
+
+      def platform_absolute_path?(location)
+        false
+      end
+
+      if Sprockets.running_on_windows?
+        def platform_absolute_path?(location)
+          location[0, 1] == File::SEPARATOR && File.expand_path(location) =~ /[A-Za-z]:[\/\\]/
+        end
+      end
+  end
+end
+
+require "sprockets/version"
+require "sprockets/error"
+require "sprockets/environment"
+require "sprockets/pathname"
+require "sprockets/source_line"
+require "sprockets/source_file"
+require "sprockets/concatenation"
+require "sprockets/preprocessor"
+require "sprockets/secretary"
+

data/lib/sprockets/concatenation.rb

@@ -0,0 +1,36 @@
+module Sprockets
+  class Concatenation
+    attr_reader :source_lines
+    
+    def initialize
+      @source_lines = []
+      @source_file_mtimes = {}
+    end
+    
+    def record(source_line)
+      source_lines << source_line
+      record_mtime_for(source_line.source_file)
+      source_line
+    end
+    
+    def to_s
+      source_lines.join
+    end
+
+    def mtime
+      @source_file_mtimes.values.max
+    end
+    
+    def save_to(filename)
+      timestamp = mtime
+      File.open(filename, "w") { |file| file.write(to_s) }
+      File.utime(timestamp, timestamp, filename)
+      true
+    end
+
+    protected
+      def record_mtime_for(source_file)
+        @source_file_mtimes[source_file] ||= source_file.mtime
+      end
+  end
+end

data/lib/sprockets/environment.rb

@@ -0,0 +1,52 @@
+module Sprockets
+  class Environment
+    attr_reader :root, :load_path
+    
+    def initialize(root, load_path = [])
+      @load_path = [@root = Pathname.new(self, root)]
+
+      load_path.reverse_each do |location|
+        register_load_location(location)
+      end
+    end
+    
+    def pathname_from(location)
+      Pathname.new(self, absolute_location_from(location))
+    end
+
+    def register_load_location(location)
+      pathname = pathname_from(location)
+      load_path.delete(pathname)
+      load_path.unshift(pathname)
+      location
+    end
+    
+    def find(location)
+      if Sprockets.absolute?(location) && File.exists?(location)
+        pathname_from(location)
+      else
+        find_all(location).first
+      end
+    end
+    
+    def constants(reload = false)
+      @constants = nil if reload
+      @constants ||= find_all("constants.yml").inject({}) do |constants, pathname|
+        contents = YAML.load(pathname.contents) rescue nil
+        contents = {} unless contents.is_a?(Hash)
+        constants.merge(contents)
+      end
+    end
+    
+    protected
+      def absolute_location_from(location)
+        location = location.to_s
+        location = File.join(root.absolute_location, location) unless Sprockets.absolute?(location)
+        File.expand_path(location)
+      end
+      
+      def find_all(location)
+        load_path.map { |pathname| pathname.find(location) }.compact
+      end
+  end
+end

data/lib/sprockets/error.rb

@@ -0,0 +1,5 @@
+module Sprockets
+  class Error < ::StandardError;        end
+  class LoadError < Error;              end
+  class UndefinedConstantError < Error; end
+end

data/lib/sprockets/pathname.rb

@@ -0,0 +1,37 @@
+module Sprockets
+  class Pathname
+    attr_reader :environment, :absolute_location
+    
+    def initialize(environment, absolute_location)
+      @environment = environment
+      @absolute_location = File.expand_path(absolute_location)
+    end
+
+    # Returns a Pathname for the location relative to this pathname's absolute location.
+    def find(location, kind = :file)
+      location = File.join(absolute_location, location)
+      File.send("#{kind}?", location) ? Pathname.new(environment, location) : nil
+    end
+
+    def parent_pathname
+      Pathname.new(environment, File.dirname(absolute_location))
+    end
+
+    def source_file
+      SourceFile.new(environment, self)
+    end
+    
+    def contents
+      IO.read(absolute_location)
+    end
+    
+    def ==(pathname)
+      environment == pathname.environment &&
+        absolute_location == pathname.absolute_location
+    end
+    
+    def to_s
+      absolute_location
+    end
+  end
+end

data/lib/sprockets/preprocessor.rb

@@ -0,0 +1,92 @@
+module Sprockets
+  class Preprocessor
+    attr_reader :environment, :concatenation, :source_files, :asset_paths
+    
+    def initialize(environment, options = {})
+      @environment = environment
+      @concatenation = Concatenation.new
+      @source_files = []
+      @asset_paths = []
+      @options = options
+    end
+    
+    def require(source_file)
+      return if source_files.include?(source_file)
+      source_files << source_file
+      
+      source_file.each_source_line do |source_line|
+        if source_line.require?
+          require_from_source_line(source_line)
+        elsif source_line.provide?
+          provide_from_source_line(source_line)
+        else
+          record_source_line(source_line)
+        end
+      end
+    end
+    
+    def provide(asset_path)
+      return if !asset_path || asset_paths.include?(asset_path)
+      asset_paths << asset_path
+    end
+    
+    protected
+      attr_reader :options
+    
+      def require_from_source_line(source_line)
+        require pathname_from(source_line).source_file
+      end
+      
+      def provide_from_source_line(source_line)
+        provide asset_path_from(source_line)
+      end
+      
+      def record_source_line(source_line)
+        unless source_line.comment? && strip_comments?
+          concatenation.record(source_line)
+        end
+      end
+
+      def strip_comments?
+        options[:strip_comments] != false
+      end
+      
+      def pathname_from(source_line)
+        pathname = send(pathname_finder_from(source_line), source_line)
+        raise_load_error_for(source_line) unless pathname
+        pathname
+      end
+
+      def pathname_for_require_from(source_line)
+        environment.find(location_from(source_line))
+      end
+      
+      def pathname_for_relative_require_from(source_line)
+        source_line.source_file.find(location_from(source_line))
+      end
+
+      def pathname_finder_from(source_line)
+        "pathname_for_#{kind_of_require_from(source_line)}_from"
+      end
+
+      def kind_of_require_from(source_line)
+        source_line.require[/^(.)/, 1] == '"' ? :relative_require : :require
+      end
+
+      def location_from(source_line)
+        location = source_line.require[/^.(.*).$/, 1]
+        ext = File.extname source_line.source_file.pathname.to_s
+        File.join(File.dirname(location), File.basename(location, ext) + ext)
+      end
+      
+      def asset_path_from(source_line)
+        source_line.source_file.find(source_line.provide, :exists)
+      end
+
+      def raise_load_error_for(source_line)
+        kind = kind_of_require_from(source_line).to_s.tr("_", " ")
+        file = File.split(location_from(source_line)).last
+        raise LoadError, "can't find file for #{kind} `#{file}' (#{source_line.inspect})"
+      end
+  end
+end

data/lib/sprockets/secretary.rb

@@ -0,0 +1,110 @@
+module Sprockets
+  class Secretary
+    DEFAULT_OPTIONS = {
+      :root         => ".",
+      :load_path    => [],
+      :source_files => [],
+      :expand_paths => true
+    }
+
+    attr_reader :environment, :preprocessor
+    
+    def initialize(options = {})
+      reset!(options)
+    end
+
+    def reset!(options = @options)
+      @options = DEFAULT_OPTIONS.merge(options)
+      @environment  = Sprockets::Environment.new(@options[:root])
+      @preprocessor = Sprockets::Preprocessor.new(@environment)
+
+      add_load_locations(@options[:load_path])
+      add_source_files(@options[:source_files])
+    end
+
+    def add_load_location(load_location, options = {})
+      add_load_locations([load_location], options)
+    end
+
+    def add_load_locations(load_locations, options = {})
+      expand_paths(load_locations, options).each do |load_location|
+        environment.register_load_location(load_location)
+      end
+    end
+    
+    def add_source_file(source_file, options = {})
+      add_source_files([source_file], options)
+    end
+    
+    def add_source_files(source_files, options = {})
+      expand_paths(source_files, options).each do |source_file|
+        if pathname = environment.find(source_file)
+          preprocessor.require(pathname.source_file)
+        else
+          raise Sprockets::LoadError, "no such file `#{source_file}'"
+        end
+      end
+    end
+    
+    def concatenation
+      preprocessor.concatenation
+    end
+    
+    def install_assets
+      if @options[:asset_root]
+        preprocessor.asset_paths.each do |asset_path|
+          copy_assets_from(asset_path.absolute_location)
+        end
+      end
+    end
+    
+    def source_last_modified
+      preprocessor.source_files.map { |s| s.mtime }.max
+    end
+    
+    protected
+      def expand_paths(paths, options = {})
+        if options.has_key?(:expand_paths) ? options[:expand_paths] : @options[:expand_paths]
+          paths.map { |path| Dir[from_root(path)].sort }.flatten.compact
+        else
+          paths.map { |path| from_root(path) }
+        end
+      end
+      
+      def from_root(path)
+        if Sprockets.absolute?(path)
+          path
+        else
+          File.join(@options[:root], path)
+        end
+      end
+      
+      def copy_assets_from(asset_path)
+        if File.directory?(asset_path)
+          relative_file_paths_beneath(asset_path).each do |filename|
+            source, destination = File.join(asset_path, filename), File.join(asset_root, File.dirname(filename))
+            if !File.directory?(source)
+              FileUtils.mkdir_p(destination)
+              FileUtils.cp(source, destination)
+            end
+          end
+        else
+          FileUtils.cp(asset_path, asset_root)
+        end
+      end
+      
+      def relative_file_paths_beneath(path)
+        Dir[File.join(path, "**", "*")].map do |filename|
+          File.join(*path_pieces(filename)[path_pieces(path).length..-1])
+        end
+      end
+      
+      def asset_root
+        from_root(@options[:asset_root])
+      end
+      
+      def path_pieces(path)
+        path.split(File::SEPARATOR)
+      end
+  end
+end