gin 1.1.2 → 1.2.0

data/lib/gin/asset_manifest.rb

@@ -0,0 +1,178 @@
+require 'yaml'
+require 'digest/md5'
+
+class Gin::AssetManifest
+
+  class Asset
+
+    attr_reader :path, :mtime, :digest, :dependencies
+    attr_accessor :target_file
+
+    def initialize path, opts={}
+      @path   = path
+      @rtime  = opts[:rtime]  || Time.now
+      @mtime  = opts[:mtime]  || File.mtime(path)
+      @digest = opts[:digest] || Digest::MD5.file(path).hexdigest
+      @target_file = opts[:target_file]
+      @dependencies = opts[:dependencies] || []
+    end
+
+
+    def update!
+      return unless File.file?(@path)
+      @rtime  = Time.now
+      @mtime  = File.mtime(@path)
+      @digest = Digest::MD5.file(@path).hexdigest
+    end
+
+
+    def outdated?
+      return true if !File.file?(@path)
+      return true if @target_file && !File.file?(@target_file)
+      return @mtime != File.mtime(@path) if @rtime - @mtime > 0
+      @digest != Digest::MD5.file(@path).hexdigest
+    end
+
+
+    def to_hash
+      hash = {
+        :target_file => @target_file,
+        :rtime  => @rtime,
+        :mtime  => @mtime,
+        :digest => @digest }
+
+      hash[:dependencies] = @dependencies.dup unless @dependencies.empty?
+
+      hash
+    end
+  end
+
+
+  attr_reader :assets, :filepath
+  attr_accessor :render_dir, :asset_globs
+
+
+  def initialize filepath, render_dir, asset_globs
+    @staged = []
+    @assets = {}
+    @filepath = filepath
+    @render_dir = render_dir
+    @asset_globs = asset_globs
+
+    load_file! if File.file?(@filepath)
+  end
+
+
+  def set asset_file, target_file, dependencies=[]
+    squash_similar_targets(target_file)
+
+    asset = @assets[asset_file] =
+      Asset.new(asset_file, :target_file => target_file)
+
+    Array(dependencies).each do |path|
+      @assets[path] ||= Asset.new(path)
+      asset.dependencies << path
+    end
+  end
+
+
+  def squash_similar_targets target_file
+    matcher = Regexp.escape( target_file.sub(/-\w+\.(\w+)$/, '') )
+    matcher = Regexp.new "#{matcher}-\\w+\\.#{$1}"
+
+    @assets.each do |name, asset|
+      if asset.target_file && matcher =~ asset.target_file
+        asset.target_file = nil
+      end
+    end
+  end
+
+
+  def stage asset_file, target_file, dependencies=[]
+    @staged << [asset_file, target_file, dependencies]
+  end
+
+
+  def delete asset_file
+    @assets.delete asset_file.to_s
+  end
+
+
+  def commit!
+    until @staged.empty?
+      set(*@staged.shift)
+    end
+  end
+
+
+  def outdated?
+    source_changed? || @assets.keys.any?{|f| asset_outdated?(f) }
+  end
+
+
+  def asset_outdated? asset_file, checked=[]
+    # Check for circular dependencies
+    return false if checked.include?(asset_file)
+    checked << asset_file
+
+    asset = @assets[asset_file]
+    return true if !asset ||
+      asset.target_file && !asset.target_file.start_with?(@render_dir) ||
+      asset.outdated?
+
+    asset.dependencies.any? do |path|
+      return true if asset_outdated?(path, checked)
+    end
+  end
+
+
+  def source_changed?
+    source_files.sort != @assets.keys.sort
+  end
+
+
+  def source_files
+    globs = @asset_globs.map{|gl|
+              (gl =~ /\.(\*|\w+)$/) ? gl : File.join(gl, '**', '*') }
+
+    Dir.glob(globs).reject{|path| !File.file?(path) }.uniq
+  end
+
+
+  def source_dirs
+    Dir.glob(@asset_globs).map{|pa| pa[-1] == ?/ ? pa[0..-2] : pa }.uniq
+  end
+
+
+  def to_hash
+    assets_hash = {}
+
+    @assets.each do |path, asset|
+      assets_hash[path] = asset.to_hash
+    end
+
+    assets_hash
+  end
+
+
+  def filepath= new_file
+    FileUtils.mv(@filepath, new_file) if
+      @filepath && new_file != @filepath && File.file?(@filepath)
+    @filepath = new_file
+  end
+
+
+  def save_file!
+    File.open(@filepath, 'w'){|f| f.write self.to_hash.to_yaml }
+  end
+
+
+  def load_file!
+    yaml = YAML.load_file(@filepath)
+    @assets.clear
+
+    yaml.each do |path, info|
+      @assets[path] = Asset.new path, info
+    end
+  end
+end

data/lib/gin/asset_pipeline.rb

@@ -0,0 +1,235 @@
+require 'sprockets'
+require 'fileutils'
+require 'gin/asset_manifest'
+
+
+class Gin::AssetPipeline
+
+  attr_accessor :logger
+
+  def initialize manifest_file, render_dir, asset_paths, sprockets, &block
+    @rendering  = 0
+    @logger     = $stderr
+    @listen     = false
+    @thread     = false
+    @sprockets  = nil
+    @flag_update = false
+
+    @render_lock = Gin::RWLock.new
+    @listen_lock = Gin::RWLock.new
+
+    @manifest = Gin::AssetManifest.new(manifest_file, render_dir, asset_paths)
+
+    setup_listener(asset_paths, sprockets, &block)
+  end
+
+
+  def setup_listener asset_paths=[], spr=nil, &block
+    spr = Sprockets::Environment.new unless Sprockets::Environment === spr
+
+    @manifest.asset_globs = asset_paths
+
+    @manifest.source_dirs.each do |path|
+      spr.append_path path
+    end
+
+    yield spr if block_given?
+
+    @manifest.asset_globs |= spr.paths
+    @sprockets = spr
+  end
+
+
+  def manifest_file
+    @manifest.filepath
+  end
+
+
+  def manifest_file= new_file
+    @manifest.filepath = new_file
+  end
+
+
+  def render_dir
+    @manifest.render_dir
+  end
+
+
+  def render_dir= new_dir
+    new_dir = File.expand_path(new_dir)
+
+    if @manifest.render_dir != new_dir
+      @listen_lock.write_sync do
+        # TODO: instead of re-rendering everything, maybe move rendered assets?
+        @flag_update = true
+        @manifest.render_dir = new_dir
+      end
+    end
+  end
+
+
+  def log str
+    @logger << "#{str}\n"
+  end
+
+
+  ##
+  # Returns true if in the middle of rendering, otherwise false.
+
+  def rendering?
+    @render_lock.read_sync{ @rendering != 0 || @flag_update }
+  end
+
+
+  def listen
+    stop if listen?
+
+    @thread = Thread.new do
+      listen!
+    end
+
+    @thread.abort_on_exception = true
+  end
+
+
+  def listen!
+    @listen_lock.write_sync{ @listen = true }
+
+    while listen? do
+      render_all if outdated?
+      sleep 0.2
+    end
+  end
+
+
+  def listen?
+    @listen_lock.read_sync{ @listen }
+  end
+
+
+  def stop
+    @listen_lock.write_sync{ @listen = false }
+  end
+
+
+  def stop!
+    stop
+    @thread.join if @thread && @thread.alive?
+  end
+
+
+  def outdated?
+    @flag_update || @manifest.outdated?
+  end
+
+
+  def update_sprockets
+    paths = @manifest.source_dirs
+    return if @sprockets.paths == paths
+
+    @sprockets.clear_paths
+    paths.each{|path| @sprockets.append_path(path) }
+  end
+
+
+  def with_render_lock &block
+    @render_lock.write_sync{ @rendering += 1 }
+    start = Time.now
+    block.call
+
+    log "Assets rendered in (#{(Time.now.to_f - start.to_f).round(3)} sec)"
+
+  ensure
+    @render_lock.write_sync do
+      @rendering -= 1
+      @rendering = 0 if @rendering < 0
+      @flag_update = false
+    end
+  end
+
+
+  def remove_path path
+    log "Deleting asset: #{path}"
+    File.delete(path)
+
+    dir = File.dirname(path)
+    while dir != self.render_dir && Dir[File.join(dir,'*')].empty?
+      FileUtils.rm_r(dir)
+      dir = File.dirname(dir)
+    end
+  end
+
+
+  ##
+  # Looks at all rendered, added, and modified assets and compiles those
+  # out of date or missing.
+
+  def render_all
+    update_sprockets
+
+    with_render_lock do
+      sp_files = @sprockets.each_file.map(&:to_s).uniq
+
+      # delete rendered files that aren't in the asset_dirs
+      @manifest.assets.each do |asset_file, asset|
+        valid_asset = sp_files.include?(asset_file)
+        next if valid_asset
+
+        target_file = asset.target_file
+        remove_path target_file if target_file
+        @manifest.delete(asset_file)
+      end
+
+      # render assets and update tree index
+      sp_files.each do |asset_file|
+        next unless @manifest.asset_outdated?(asset_file)
+        sp_asset = @sprockets[asset_file] # First time render
+
+        if target_file = render(asset_file)
+          @manifest.stage asset_file, target_file,
+            sp_asset.dependencies.map{|d| d.pathname.to_s }
+        end
+      end
+
+      @manifest.commit!
+
+      # save cache to disk
+      @manifest.save_file!
+    end
+  end
+
+
+  def render path
+    asset = @sprockets[path]
+    return unless asset
+
+    ext = render_ext(asset)
+    render_path = File.join(self.render_dir, asset.logical_path)
+
+    file_glob = render_path.sub(/(\.\w+)$/, "-*#{ext}")
+    file_name = Dir[file_glob].first
+
+    digest = asset.digest[0..7]
+    return file_name if file_name && file_name.include?(digest)
+
+    log "Rendering asset: #{path}"
+    render_filename = file_glob.sub('*', digest)
+
+    FileUtils.mkdir_p File.dirname(render_filename)
+    File.open(render_filename, 'wb'){|f| f.write asset.source }
+
+    File.delete(file_name) if file_name
+
+    return render_filename
+  end
+
+
+  private
+
+  def render_ext asset
+    path  = asset.pathname.to_s
+    ctype = asset.content_type
+    ctype == 'application/octet-stream' ?
+     File.extname(path) : @sprockets.extension_for_mime_type(ctype)
+  end
+end

data/lib/gin/cache.rb

@@ -11,6 +11,14 @@ class Gin::Cache
   end
 
 
+  ##
+  # Clear all cache entries.
+
+  def clear
+    @lock.write_sync{ @data.clear }
+  end
+
+
   ##
   # Set the write timeout when waiting for reader thread locks.
   # Defaults to 0.05 sec. See Gin::RWLock for more details.
@@ -45,6 +53,34 @@ class Gin::Cache
   end
 
 
+  ##
+  # Increases the value of the given key in a thread-safe manner.
+  # Only Numerics and nil values are supported.
+  # Treats nil or non-existant values as 0.
+
+  def increase key, amount=1
+    @lock.write_sync do
+      return unless @data[key].nil? || Numeric === @data[key]
+      @data[key] ||= 0
+      @data[key] += amount
+    end
+  end
+
+
+  ##
+  # Decreases the value of the given key in a thread-safe manner.
+  # Only Numerics and nil values are supported.
+  # Treats nil or non-existant values as 0.
+
+  def decrease key, amount=1
+    @lock.write_sync do
+      return unless @data[key].nil? || Numeric === @data[key]
+      @data[key] ||= 0
+      @data[key] -= amount
+    end
+  end
+
+
   ##
   # Check if the current key exists in the cache.