bpm 0.1.0 → 0.1.2

data/vendor/sprockets/test/test_asset_attributes.rb

@@ -0,0 +1,86 @@
+require 'sprockets_test'
+
+class TestAssetAttributes < Sprockets::TestCase
+  test "basename with extensions" do
+    assert_equal "empty",
+      pathname("empty").basename_without_extensions.to_s
+    assert_equal "gallery",
+      pathname("gallery.js").basename_without_extensions.to_s
+    assert_equal "application",
+      pathname("application.js.coffee").basename_without_extensions.to_s
+    assert_equal "project",
+      pathname("project.js.coffee.erb").basename_without_extensions.to_s
+    assert_equal "gallery",
+      pathname("gallery.css.erb").basename_without_extensions.to_s
+  end
+
+  test "extensions" do
+    assert_equal [],
+      pathname("empty").extensions
+    assert_equal [".js"],
+      pathname("gallery.js").extensions
+    assert_equal [".js", ".coffee"],
+      pathname("application.js.coffee").extensions
+    assert_equal [".js", ".coffee", ".erb"],
+      pathname("project.js.coffee.erb").extensions
+    assert_equal [".css", ".erb"],
+      pathname("gallery.css.erb").extensions
+  end
+
+  test "format_extension" do
+    assert_equal nil, pathname("empty").format_extension
+    assert_equal ".js", pathname("gallery.js").format_extension
+    assert_equal ".js", pathname("application.js.coffee").format_extension
+    assert_equal ".js", pathname("project.js.coffee.erb").format_extension
+    assert_equal ".css", pathname("gallery.css.erb").format_extension
+    assert_equal nil, pathname("gallery.erb").format_extension
+    assert_equal nil, pathname("gallery.foo").format_extension
+    assert_equal ".js", pathname("jquery.js").format_extension
+    assert_equal ".js", pathname("jquery.min.js").format_extension
+    assert_equal ".js", pathname("jquery.tmpl.js").format_extension
+    assert_equal ".js", pathname("jquery.tmpl.min.js").format_extension
+  end
+
+  test "engine_extensions" do
+    assert_equal [], pathname("empty").engine_extensions
+    assert_equal [], pathname("gallery.js").engine_extensions
+    assert_equal [".coffee"],
+      pathname("application.js.coffee").engine_extensions
+    assert_equal [".coffee", ".erb"],
+      pathname("project.js.coffee.erb").engine_extensions
+    assert_equal [".erb"], pathname("gallery.css.erb").engine_extensions
+    assert_equal [".erb"], pathname("gallery.erb").engine_extensions
+    assert_equal [], pathname("jquery.js").engine_extensions
+    assert_equal [], pathname("jquery.min.js").engine_extensions
+    assert_equal [], pathname("jquery.tmpl.min.js").engine_extensions
+    assert_equal [".erb"], pathname("jquery.js.erb").engine_extensions
+    assert_equal [".erb"], pathname("jquery.min.js.erb").engine_extensions
+    assert_equal [".coffee"],
+      pathname("jquery.min.coffee").engine_extensions
+  end
+
+  test "content_type" do
+    assert_equal "application/octet-stream",
+      pathname("empty").content_type
+    assert_equal "application/javascript",
+      pathname("gallery.js").content_type
+    assert_equal "application/javascript",
+      pathname("application.js.coffee").content_type
+    assert_equal "application/javascript",
+      pathname("project.js.coffee.erb").content_type
+    assert_equal "text/css",
+      pathname("gallery.css.erb").content_type
+    assert_equal "application/javascript",
+      pathname("jquery.tmpl.min.js").content_type
+
+    if Tilt::CoffeeScriptTemplate.respond_to?(:default_mime_type)
+      assert_equal "application/javascript",
+        pathname("application.coffee").content_type
+    end
+  end
+
+  private
+    def pathname(path)
+      Sprockets::Environment.new.attributes_for(path)
+    end
+end

data/vendor/sprockets/test/test_caching.rb

@@ -0,0 +1,62 @@
+require 'sprockets_test'
+
+class TestCaching < Sprockets::TestCase
+  def setup
+    @cache = {}
+
+    @env1 = Sprockets::Environment.new(fixture_path('default')) do |env|
+      env.append_path(".")
+      env.cache = @cache
+    end
+
+    @env2 = Sprockets::Environment.new(fixture_path('symlink')) do |env|
+      env.append_path(".")
+      env.cache = @cache
+    end
+  end
+
+  test "environment digests are the same for different roots" do
+    assert_equal @env1.digest, @env2.digest
+  end
+
+  test "shared cache objects are eql" do
+    asset1 = @env1['gallery.js']
+    asset2 = @env2['gallery.js']
+
+    assert asset1
+    assert asset2
+
+    assert asset1.eql?(asset2)
+    assert asset2.eql?(asset1)
+    assert !asset1.equal?(asset2)
+  end
+
+  test "stale cached asset isn't loaded if file is remove" do
+    filename = fixture_path("default/tmp.js")
+
+    sandbox filename do
+      File.open(filename, 'w') { |f| f.puts "foo;" }
+      assert_equal "foo;\n", @env1["tmp.js"].to_s
+
+      File.unlink(filename)
+      assert_nil @env2["tmp.js"]
+    end
+  end
+
+  test "stale cached asset isn't loaded if depedency is changed and removed" do
+    foo = fixture_path("default/foo-tmp.js")
+    bar = fixture_path("default/bar-tmp.js")
+
+    sandbox foo, bar do
+      File.open(foo, 'w') { |f| f.puts "//= require bar-tmp\nfoo;" }
+      File.open(bar, 'w') { |f| f.puts "bar;" }
+      assert_equal "bar;\nfoo;\n", @env1["foo-tmp.js"].to_s
+      assert_equal "bar;\n", @env1["bar-tmp.js"].to_s
+
+      File.open(foo, 'w') { |f| f.puts "foo;" }
+      File.unlink(bar)
+      assert_equal "foo;\n", @env1["foo-tmp.js"].to_s
+      assert_nil @env2["bar-tmp.js"]
+    end
+  end
+end

data/vendor/sprockets/test/test_context.rb

@@ -0,0 +1,115 @@
+require 'sprockets_test'
+require 'tilt'
+require 'yaml'
+
+class TestContext < Sprockets::TestCase
+  def setup
+    @env = Sprockets::Environment.new(".")
+    @env.append_path(fixture_path('context'))
+  end
+
+  test "source file properties are exposed in context" do
+    json = @env["properties.js"].to_s.chomp.chop
+    assert_equal({
+      'pathname'     => fixture_path("context/properties.js.erb"),
+      '__FILE__'     => fixture_path("context/properties.js.erb"),
+      'root_path'    => fixture_path("context"),
+      'logical_path' => "properties",
+      'content_type' => "application/javascript"
+    }, YAML.load(json))
+  end
+
+  test "extend context" do
+    @env.context_class.class_eval do
+      def datauri(path)
+        require 'base64'
+        Base64.encode64(File.open(path, "rb") { |f| f.read })
+      end
+    end
+
+    assert_equal ".pow {\n  background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZoAAAEsCAMAAADNS4U5AAAAGXRFWHRTb2Z0\n",
+      @env["helpers.css"].to_s.lines.to_a[0..1].join
+    assert_equal 58240, @env["helpers.css"].length
+  end
+end
+
+class TestCustomProcessor < Sprockets::TestCase
+  def setup
+    @env = Sprockets::Environment.new
+    @env.append_path(fixture_path('context'))
+  end
+
+  class YamlProcessor < Tilt::Template
+    def initialize_engine
+      require 'yaml'
+    end
+
+    def prepare
+      @manifest = YAML.load(data)
+    end
+
+    def evaluate(context, locals)
+      @manifest['require'].each do |logical_path|
+        context.require_asset(logical_path)
+      end
+      ""
+    end
+  end
+
+  test "custom processor using Context#require" do
+    @env.register_engine :yml, YamlProcessor
+
+    assert_equal "var Foo = {};\n\nvar Bar = {};\n", @env['application.js'].to_s
+  end
+
+  class DataUriProcessor < Tilt::Template
+    def initialize_engine
+      require 'base64'
+    end
+
+    def prepare
+    end
+
+    def evaluate(context, locals)
+      data.gsub(/url\(\"(.+?)\"\)/) do
+        path = context.resolve($1)
+        context.depend_on(path)
+        data = Base64.encode64(File.open(path, "rb") { |f| f.read })
+        "url(data:image/png;base64,#{data})"
+      end
+    end
+  end
+
+  test "custom processor using Context#resolve and Context#depend_on" do
+    @env.register_engine :embed, DataUriProcessor
+
+    assert_equal ".pow {\n  background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZoAAAEsCAMAAADNS4U5AAAAGXRFWHRTb2Z0\n",
+      @env["sprite.css"].to_s.lines.to_a[0..1].join
+    assert_equal 58240, @env["sprite.css"].length
+  end
+
+  test "block custom processor" do
+    require 'base64'
+
+    @env.register_preprocessor 'text/css', :data_uris do |context, data|
+      data.gsub(/url\(\"(.+?)\"\)/) do
+        path = context.resolve($1)
+        context.depend_on(path)
+        data = Base64.encode64(File.open(path, "rb") { |f| f.read })
+        "url(data:image/png;base64,#{data})"
+      end
+    end
+
+    assert_equal ".pow {\n  background: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAZoAAAEsCAMAAADNS4U5AAAAGXRFWHRTb2Z0\n",
+      @env["sprite.css.embed"].to_s.lines.to_a[0..1].join
+    assert_equal 58240, @env["sprite.css.embed"].length
+  end
+
+  test "resolve with content type" do
+    assert_equal [fixture_path("context/foo.js"),
+     fixture_path("context/foo.js"),
+     fixture_path("context/foo.js"),
+     "foo.js is 'application/javascript', not 'text/css';"
+    ].join(",\n"), @env["resolve_content_type.js"].to_s.strip
+  end
+end

data/vendor/sprockets/test/test_directive_processor.rb

@@ -0,0 +1,124 @@
+require "sprockets_test"
+
+class DirectiveProcessorTest < Sprockets::TestCase
+  test "parsing double-slash comments" do
+    directive_parser("double_slash").tap do |parser|
+      assert_equal "// Header\n//\n//\n(function() {\n})();\n", parser.processed_source
+      assert_equal directives, parser.directives
+    end
+  end
+
+  test "parsing hash comments" do
+    directive_parser("hash").tap do |parser|
+      assert_equal "# Header\n#\n#\n(->)()\n", parser.processed_source
+      assert_equal directives, parser.directives
+    end
+  end
+
+  test "parsing slash-star comments" do
+    directive_parser("slash_star").tap do |parser|
+      assert_equal "/* Header\n *\n *\n */\n\n(function() {\n})();\n", parser.processed_source
+      assert_equal directives, parser.directives
+    end
+  end
+
+  test "parsing single line slash-star comments" do
+    directive_parser("slash_star_single").tap do |parser|
+      assert_equal "\n\n(function() {\n})();\n", parser.processed_source
+      assert_equal [[1, "require", "a"]], parser.directives
+    end
+  end
+
+  test "parsing triple-hash comments" do
+    directive_parser("triple_hash").tap do |parser|
+      assert_equal "###\nHeader\n\n\n###\n\n(->)()\n", parser.processed_source
+      assert_equal directives(1), parser.directives
+    end
+  end
+
+  test "header comment without directives is unmodified" do
+    directive_parser("comment_without_directives").tap do |parser|
+      assert_equal "/*\n * Comment\n */\n\n(function() {\n})();\n", parser.processed_source
+      assert_equal [], parser.directives
+    end
+  end
+
+  test "directives in comment after header are not parsed" do
+    directive_parser("directives_after_header").tap do |parser|
+      assert_equal "/*\n * Header\n */\n\n\n\n/* Not a directive */\n\n(function() {\n})();\n\n/*= require e */\n", parser.processed_source
+      assert_equal [
+        [3, "require", "a"],
+        [6, "require", "b"],
+        [7, "require", "c"],
+        [9, "require", "d"]
+      ], parser.directives
+    end
+  end
+
+  test "headers must occur at the beginning of the file" do
+    directive_parser("code_before_comment").tap do |parser|
+      assert_equal "", parser.processed_header
+      assert_equal directive_fixture("code_before_comment"), parser.processed_source
+    end
+  end
+
+  test "no header" do
+    directive_parser("no_header").tap do |parser|
+      assert_equal directive_fixture("no_header"), parser.processed_source
+      assert_equal [], parser.directives
+    end
+  end
+
+  test "directive word splitting" do
+    directive_parser("directive_word_splitting").tap do |parser|
+      assert_equal [
+        [1, "one"],
+        [2, "one", "two"],
+        [3, "one", "two", "three"],
+        [4, "one", "two three"],
+        [6, "six", "seven"]
+      ], parser.directives
+    end
+  end
+
+  test "space between = and directive word" do
+    directive_parser("space_between_directive_word").tap do |parser|
+      assert_equal "var foo;\n", parser.processed_source
+      assert_equal [[1, "require", "foo"]], parser.directives
+    end
+  end
+
+  def directive_parser(fixture_name)
+    Sprockets::DirectiveProcessor.new(fixture_path("directives/#{fixture_name}"))
+  end
+
+  def directive_fixture(name)
+    fixture("directives/#{name}")
+  end
+
+  def directives(offset = 0)
+    [[3 + offset, "require", "a"], [4 + offset, "require", "b"], [6 + offset, "require", "c"]]
+  end
+end
+
+class TestCustomDirectiveProcessor < Sprockets::TestCase
+  def setup
+    @env = Sprockets::Environment.new
+    @env.append_path(fixture_path('context'))
+  end
+
+  class TestDirectiveProcessor < Sprockets::DirectiveProcessor
+    def process_require_glob_directive(glob)
+      Dir["#{pathname.dirname}/#{glob}"].sort.each do |filename|
+        context.require_asset(filename)
+      end
+    end
+  end
+
+  test "custom processor using Context#sprockets_resolve and Context#sprockets_depend" do
+    @env.unregister_preprocessor('application/javascript', Sprockets::DirectiveProcessor)
+    @env.register_preprocessor('application/javascript', TestDirectiveProcessor)
+
+    assert_equal "var Foo = {};\n\n", @env["require_glob.js"].to_s
+  end
+end

data/vendor/sprockets/test/test_encoding.rb

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+require "sprockets_test"
+
+class EncodingTest < Sprockets::TestCase
+  def setup
+    @env = Sprockets::Environment.new
+    @env.append_path(fixture_path('encoding'))
+  end
+
+  if "".respond_to?(:encoding)
+    test "read ASCII asset" do
+      data = @env['ascii.js'].to_s
+      assert_equal "var foo = \"bar\";\n", data
+      assert_equal Encoding.find('ASCII'), data.encoding
+    end
+
+    test "read UTF-8 asset" do
+      data = @env['utf8.js'].to_s
+      assert_equal "var snowman = \"☃\";\n", data
+      assert_equal Encoding.find('UTF-8'), data.encoding
+    end
+
+    test "read UTF-8 asset with BOM" do
+      data = @env['utf8_bom.js'].to_s
+      assert_equal "var snowman = \"☃\";\n", data.encode("UTF-8")
+      assert_equal Encoding.find('UTF-8'), data.encoding
+    end
+
+    test "read UTF-16 asset" do
+      assert_raise Sprockets::EncodingError do
+        @env['utf16.js'].to_s
+      end
+    end
+
+    test "read ASCII + UTF-8 concatation asset" do
+      data = @env['ascii_utf8.js'].to_s
+      assert_equal "var foo = \"bar\";\nvar snowman = \"\342\230\203\";\n",
+        data
+      assert_equal Encoding.find('UTF-8'), data.encoding
+    end
+  else
+    test "read ASCII asset" do
+      assert_equal "var foo = \"bar\";\n", @env['ascii.js'].to_s
+    end
+
+    test "read UTF-8 asset" do
+      assert_equal "var snowman = \"\342\230\203\";\n", @env['utf8.js'].to_s
+    end
+
+    test "read UTF-8 asset with BOM" do
+      assert_equal "var snowman = \"\342\230\203\";\n", @env['utf8_bom.js'].to_s
+    end
+
+    test "read UTF-16 asset" do
+      assert_raise Sprockets::EncodingError do
+        @env['utf16.js'].to_s
+      end
+    end
+
+    test "read ASCII + UTF-8 concatation asset" do
+      assert_equal "var foo = \"bar\";\nvar snowman = \"\342\230\203\";\n",
+        @env['ascii_utf8.js'].to_s
+    end
+  end
+end

data/vendor/sprockets/test/test_engines.rb

@@ -0,0 +1,73 @@
+require 'sprockets_test'
+require 'sprockets/engines'
+require 'tilt'
+
+class AlertTemplate < Tilt::Template
+  def self.default_mime_type
+    'application/javascript'
+  end
+
+  def prepare
+  end
+
+  def evaluate(scope, locals, &block)
+    "alert(#{data.inspect});"
+  end
+end
+
+class StringTemplate < Tilt::Template
+  def prepare
+  end
+
+  def evaluate(scope, locals, &block)
+    data.gsub(/#\{.*?\}/, "moo")
+  end
+end
+
+class TestEngines < Sprockets::TestCase
+  ORIGINAL_ENGINES = Sprockets.instance_variable_get(:@engines)
+
+  def setup
+    Sprockets.instance_variable_set(:@engines, ORIGINAL_ENGINES.dup)
+  end
+
+  def teardown
+    Sprockets.instance_variable_set(:@engines, ORIGINAL_ENGINES)
+  end
+
+  test "registering a global engine" do
+    Sprockets.register_engine ".alert", AlertTemplate
+    assert_equal AlertTemplate, Sprockets.engines("alert")
+    assert_equal AlertTemplate, Sprockets.engines(".alert")
+
+    env = new_environment
+    asset = env["hello.alert"]
+    assert_equal 'alert("Hello world!\n");', asset.to_s
+    assert_equal 'application/javascript', asset.content_type
+  end
+
+  test "overriding an engine globally" do
+    env1 = new_environment
+    assert_equal %(console.log("Moo, #{RUBY_VERSION}");\n), env1["moo.js"].to_s
+
+    Sprockets.register_engine ".str", StringTemplate
+    env2 = new_environment
+    assert_equal %(console.log("Moo, moo");\n), env2["moo.js"].to_s
+  end
+
+  test "overriding an engine in an environment" do
+    env1 = new_environment
+    env2 = new_environment
+
+    env1.register_engine ".str", StringTemplate
+    assert_equal %(console.log("Moo, moo");\n), env1["moo.js"].to_s
+
+    assert_equal %(console.log("Moo, #{RUBY_VERSION}");\n), env2["moo.js"].to_s
+  end
+
+  def new_environment
+    Sprockets::Environment.new.tap do |env|
+      env.append_path(fixture_path('engines'))
+    end
+  end
+end