bunch 0.2.2 → 1.0.0pre1

data/lib/bunch/file.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+module Bunch
+  class File
+    attr_reader :path, :content, :filename, :extension
+
+    def initialize(path, content)
+      @path      = path
+      @content   = content
+      @filename  = ::File.basename(@path)
+      @extension = ::File.extname(@filename)
+    end
+
+    def accept(visitor)
+      visitor.visit_file(self)
+    end
+  end
+end

data/lib/bunch/file_cache.rb

@@ -0,0 +1,159 @@
+# encoding: UTF-8
+
+require "digest/md5"
+require "fileutils"
+require "yaml"
+
+module Bunch
+  def self.FileCache(*args)
+    FileCache.new(*args)
+  end
+
+  class FileCache
+    Result = Struct.new(:result)
+
+    def initialize(processor_class, input_dir, *args)
+      @processor_class, @args = processor_class, args
+      @cache_name = "#{processor_class}-#{input_dir}"
+    end
+
+    def new(tree)
+      cache     = load_cache
+      partition = Partition.new(tree, cache)
+
+      partition.process!
+
+      processor = @processor_class.new(partition.pending, *@args)
+      result    = TreeMerge.new(partition.cached, processor.result).result
+
+      save_cache tree, result
+      Result.new(result)
+    end
+
+    private
+
+    def load_cache
+      FileUtils.mkdir_p cache_directory
+      Cache.read_from_file cache_path
+    end
+
+    def save_cache(input, output)
+      FileUtils.mkdir_p cache_directory
+      Cache.from_trees(input, output).write_to_file cache_path
+    end
+
+    # TODO: Make configurable
+    def cache_directory
+      ".bunch-cache"
+    end
+
+    def cache_filename
+      @cache_name.gsub(/[:\/]/, "-")
+    end
+
+    def cache_path
+      ::File.join(cache_directory, cache_filename)
+    end
+
+    class Partition
+      attr_reader :pending, :cached
+
+      def initialize(input, cache)
+        @input = input
+        @cache = cache
+      end
+
+      def process!
+        @path    = []
+        @pending = FileTree.new
+        @cached  = FileTree.new
+        @input.accept(self)
+        self
+      end
+
+      def enter_tree(tree)
+        @path << tree.name if tree.name
+      end
+
+      def leave_tree(tree)
+        @path.pop if tree.name
+      end
+
+      def visit_file(file)
+        file_path = [*@path, file.path].join("/")
+        cached_content = @cache.read(file_path, file.content)
+        if cached_content
+          @cached.write file_path, cached_content
+        else
+          @pending.write file_path, file.content
+        end
+      end
+    end
+
+    class Cache
+      def self.from_trees(input, output)
+        new(HashHasher.new(input).result, output)
+      end
+
+      def self.read_from_file(path)
+        version, hashes, output = YAML.load_file(path)
+        if version == VERSION
+          new(hashes, FileTree.from_hash(output))
+        else
+          empty
+        end
+      rescue Errno::ENOENT
+        empty
+      end
+
+      def self.empty
+        new({}, FileTree.new)
+      end
+
+      def self.digest(contents)
+        Digest::MD5.hexdigest(contents)
+      end
+
+      def initialize(hashes, output)
+        @hashes, @output = hashes, output
+      end
+
+      def read(path, input_contents)
+        if Cache.digest(input_contents) == @hashes[path]
+          @output.get(path).content
+        end
+      end
+
+      def write_to_file(path)
+        yaml = YAML.dump([Bunch::VERSION, @hashes, @output.to_hash])
+        ::File.open(path, "w") { |f| f.write yaml }
+      end
+
+      class HashHasher
+        def initialize(tree)
+          @input  = tree
+        end
+
+        def result
+          @path = []
+          @hashes = {}
+          @input.accept(self)
+          @hashes
+        end
+
+        def enter_tree(tree)
+          @path << tree.name if tree.name
+        end
+
+        def leave_tree(tree)
+          @path.pop if tree.name
+        end
+
+        def visit_file(file)
+          file_path = [*@path, file.path].join("/")
+          @hashes[file_path] = Digest::MD5.hexdigest(file.content)
+        end
+      end
+    end
+  end
+end

data/lib/bunch/file_tree.rb

@@ -0,0 +1,153 @@
+# encoding: utf-8
+
+require "fileutils"
+
+module Bunch
+  class FileTree
+    include Enumerable
+
+    attr_reader :path, :name
+
+    class << self
+      def from_hash(hash)
+        new nil, hash
+      end
+
+      def from_path(path)
+        new nil, hash_from_path(path)
+      end
+
+      private
+
+      def hash_from_path(path)
+        hash = {}
+        Dir.foreach(path) do |entry|
+          next if entry == "." || entry == ".."
+          this_path = "#{path}/#{entry}"
+          if ::File.directory? this_path
+            hash[entry] = hash_from_path this_path
+          else
+            hash[entry] = ::File.read this_path
+          end
+        end
+        hash
+      end
+    end
+
+    def initialize(path = nil, hash = {})
+      @path = path
+      @hash = hash
+      @name = ::File.basename(@path) if @path
+    end
+
+    def directory?(path)
+      look_up_path(path).is_a?(Hash)
+    end
+
+    def exist?(filename)
+      !!look_up_path(filename)
+    end
+
+    def get(path)
+      case (content = look_up_path(path))
+      when Hash
+        FileTree.new(path, content)
+      when String
+        File.new(path, content)
+      end
+    end
+
+    # Like get, but takes a path with no extension and returns the first match
+    # regardless of its extension.
+    def get_fuzzy(fuzzy_path)
+      path = fuzzy_find_path(fuzzy_path)
+      get(path) if path
+    end
+
+    def write(path, contents)
+      dirname, _, filename = path.rpartition("/")
+
+      if dirname == ""
+        @hash[filename] = contents
+      else
+        unless exist?(dirname)
+          write(dirname, {})
+        end
+
+        unless directory?(dirname)
+          raise "#{dirname.inspect} is a file, not a directory!"
+        end
+
+        get(dirname).write(filename, contents)
+      end
+    end
+
+    def each
+      @hash.keys.each do |filename|
+        yield [filename, get(filename)]
+      end
+    end
+
+    def to_hash
+      @hash
+    end
+
+    def accept(visitor)
+      unless visitor.enter_tree(self) == false
+        each { |_, node| break if node.accept(visitor) == false }
+      end
+      visitor.leave_tree(self)
+    end
+
+    def write_to_path(path)
+      write_hash_to_path path, @hash
+    end
+
+    def ==(other)
+      to_hash == other.to_hash
+    end
+
+    def dup
+      FileTree.new(@path, Marshal.load(Marshal.dump(@hash)))
+    end
+
+    private
+
+    def look_up_path(filename)
+      filename.split("/").inject(@hash) do |hash, path_component|
+        break if hash.nil? || hash.is_a?(String)
+        hash[path_component]
+      end
+    end
+
+    def fuzzy_find_path(path)
+      name = ::File.basename(path)
+      tree = get ::File.dirname(path)
+      if tree && tree.is_a?(FileTree)
+        tree.each do |filename, contents|
+          next unless contents.is_a?(File)
+          extension = ::File.extname(filename)
+
+          if name == ::File.basename(filename, extension)
+            return "#{path}#{extension}"
+          end
+        end
+        nil
+      end
+    end
+
+    def write_hash_to_path(path, hash)
+      FileUtils.mkdir_p path
+
+      hash.each do |name, content|
+        this_path = ::File.join path, name
+
+        if content.is_a? Hash
+          write_hash_to_path this_path, content
+        else
+          ::File.open(this_path, "w") { |f| f.write content }
+        end
+      end
+    end
+  end
+end

data/lib/bunch/ignorer.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+
+module Bunch
+  class Ignorer
+    PATTERNS = [
+      /^\.DS_Store$/,
+      /^.*~$/,
+      /^#.*\#$/ #/(comment fixes broken vim highlighting)
+    ]
+
+    def initialize(tree)
+      @input  = tree
+      @output = FileTree.new
+    end
+
+    def result
+      @path = []
+      @input.accept(self)
+      @output
+    end
+
+    def enter_tree(tree)
+      @path << tree.name if tree.name
+    end
+
+    def leave_tree(tree)
+      @path.pop if tree.name
+    end
+
+    def visit_file(file)
+      file_path = [*@path, file.path].join("/")
+
+      unless PATTERNS.any? { |p| p.match(file.path) }
+        @output.write file_path, file.content
+      end
+    end
+  end
+end

data/lib/bunch/js_minifier.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+
+module Bunch
+  class JsMinifier
+    def initialize(tree)
+      require "uglifier"
+      @input  = tree
+      @output = FileTree.new
+      @uglifier = Uglifier.new
+    rescue LoadError => e
+      raise "'gem install uglifier' to minify JavaScript files."
+    end
+
+    def result
+      @path = []
+      @input.accept(self)
+      @output
+    end
+
+    def enter_tree(tree)
+      @path << tree.name if tree.name
+    end
+
+    def leave_tree(tree)
+      @path.pop if tree.name
+    end
+
+    def visit_file(file)
+      file_path = [*@path, file.path].join("/")
+      content = if file.extension == ".js"
+                  @uglifier.compile(file.content)
+                else
+                  file.content
+                end
+      @output.write file_path, content
+    end
+  end
+end

data/lib/bunch/middleware.rb

@@ -1,83 +1,32 @@
-# heavily inspired by Rack::URLMap
+# encoding: UTF-8
+
+require "rack"
 
 module Bunch
   class Middleware
-    attr_accessor :app, :endpoint
-
-    def initialize(app, options={})
-      unless options[:root_url] && options[:path]
-        raise "Must provide :root_url and :path"
-      end
-
+    def initialize(app, paths_and_options)
       @app = app
-      @root_url = options.delete(:root_url)
-      @endpoint = Bunch::Rack.new(options.delete(:path), options)
-
-      if options[:gzip]
-        @endpoint = ::Rack::Deflater.new(@endpoint)
-      end
+      @url_map = Rack::Deflater.new(build_url_map(paths_and_options))
     end
 
     def call(env)
-      path = env['PATH_INFO'].to_s
-      script_name = env['SCRIPT_NAME'].to_s
-
-      if path =~ root_regexp &&
-          (rest = $1) &&
-          (rest.empty? || rest[0] == ?/)
+      response = @url_map.call(env)
 
-        @endpoint.call(
-          env.merge(
-            'SCRIPT_NAME' => (script_name + @root_url),
-            'PATH_INFO'   => rest
-          )
-        )
-      else
+      if response[1]["X-Cascade"] == "pass"
         @app.call(env)
+      else
+        response
       end
     end
 
-    protected
-      def root_regexp
-         Regexp.new("^#{Regexp.quote(@root_url).gsub('/', '/+')}(.*)")
-      end
-  end
-
-  class << Middleware
-    # Binds an instance of `Bunch::Middleware` in front of any instance
-    # of the given middleware class. Whenever `klass` is instantiated,
-    # any calls to `klass#call` will first pass through the single
-    # instance of `Middleware` created by this method.
-    #
-    # You can compose any number of `Middleware` instances in front
-    # of the same class.
-    #
-    # In practice, the purpose of this is to allow Bunch to take
-    # precedence over `Rails::Rack::Static` in a Rails 2 context.
-    # Since the server's instance of `Rails::Rack::Static` isn't part of
-    # the `ActionController` stack, it isn't possible to use
-    # Rails' normal middleware tools to insert Bunch in front of it,
-    # which means any files in `public` would be served preferentially.
-    #
-    # @param [Class] klass Any Rack middleware class.
-    # @param [Hash] options The options that would normally be passed to
-    #   `Bunch::Middleware#initialize`.
-    #
-    # @example
-    #   if Rails.env.development?
-    #     Bunch::Middleware.insert_before Rails::Rack::Static,
-    #       root_url: '/javascripts', path: 'app/scripts', no_cache: true
-    #   end
-    def insert_before(klass, options={})
-      instance = new(nil, options)
+    private
 
-      klass.class_eval do
-        unbound_call = instance_method(:call)
-        define_method(:call) do |env|
-          instance.app = unbound_call.bind(self)
-          instance.call(env)
-        end
-      end
+    def build_url_map(paths_and_options)
+      paths, options = paths_and_options.partition { |k, _| String === k }
+      mapping = Hash[paths.map do |url, directory|
+        [url, Server.new(Hash[options].merge(root: directory))]
+      end]
+      Rack::URLMap.new(mapping)
     end
   end
 end