bpm 1.0.0.beta.8 → 1.0.0.beta.9

data/vendor/sprockets/test/test_asset_attributes.rb

@@ -1,150 +0,0 @@
-require 'sprockets_test'
-
-class TestAssetAttributes < Sprockets::TestCase
-  test "expand and relativize root" do
-    assert_equal __FILE__,
-      pathname(pathname(__FILE__).relativize_root).expand_root
-  end
-
-  test "search paths" do
-    assert_equal ["index"],
-      pathname("index").search_paths
-    assert_equal ["index.html"],
-      pathname("index.html").search_paths
-    assert_equal ["index.css", "index.less", "index.sass", "index.scss"],
-      pathname("index.css").search_paths
-    assert_equal ["index.js", "index.coffee", "index.jst"],
-      pathname("index.js").search_paths
-    assert_equal ["index.coffee"], pathname("index.coffee").search_paths
-    assert_equal ["index.js.coffee"], pathname("index.js.coffee").search_paths
-
-    assert_equal ["foo", "foo/index"],
-      pathname("foo").search_paths
-    assert_equal ["foo.html", "foo/index.html"],
-      pathname("foo.html").search_paths
-    assert_equal ["foo.js", "foo.coffee", "foo.jst", "foo/index.js", "foo/index.coffee", "foo/index.jst"],
-      pathname("foo.js").search_paths
-    assert_equal ["foo.coffee", "foo/index.coffee"],
-      pathname("foo.coffee").search_paths
-    assert_equal ["foo.js.coffee", "foo/index.js.coffee"],
-      pathname("foo.js.coffee").search_paths
-
-    assert_equal ["foo/bar", "foo/bar/index"], pathname("foo/bar").search_paths
-    assert_equal ["foo/bar.js", "foo/bar.coffee", "foo/bar.jst", "foo/bar/index.js", "foo/bar/index.coffee", "foo/bar/index.jst"],
-      pathname("foo/bar.js").search_paths
-    assert_equal ["foo/bar.coffee", "foo/bar/index.coffee"], pathname("foo/bar.coffee").search_paths
-    assert_equal ["foo/bar.js.coffee", "foo/bar/index.js.coffee"], pathname("foo/bar.js.coffee").search_paths
-
-    assert_equal ["jquery.foo.coffee", "jquery/index.foo.coffee"],
-      pathname("jquery.foo.coffee").search_paths
-    assert_equal ["jquery.foo.js.coffee", "jquery/index.foo.js.coffee"],
-      pathname("jquery.foo.js.coffee").search_paths
-    assert_equal ["jquery.foo.js", "jquery.foo.coffee", "jquery.foo.jst",
-                  "jquery/index.foo.js", "jquery/index.foo.coffee", "jquery/index.foo.jst"],
-      pathname("jquery.foo.js").search_paths
-  end
-
-  test "logical path" do
-    assert_equal nil, pathname(fixture_path("missing/application.js")).logical_path
-
-    assert_equal "application.js", pathname(fixture_path("default/application.js")).logical_path
-    assert_equal "application.css", pathname(fixture_path("default/application.css")).logical_path
-    assert_equal "jquery.foo.min.js", pathname(fixture_path("default/jquery.foo.min.js")).logical_path
-
-    assert_equal "application.js", pathname(fixture_path("default/application.js.erb")).logical_path
-    assert_equal "application.js", pathname(fixture_path("default/application.js.coffee")).logical_path
-    assert_equal "application.css", pathname(fixture_path("default/application.css.scss")).logical_path
-
-    assert_equal "application.js", pathname(fixture_path("default/application.coffee")).logical_path
-    assert_equal "application.css", pathname(fixture_path("default/application.scss")).logical_path
-    assert_equal "hello.js", pathname(fixture_path("default/hello.jst.ejs")).logical_path
-  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
-
-    env = Sprockets::Environment.new
-    env.register_engine '.ms', Class.new
-    assert_equal nil, env.attributes_for("foo.jst.ms").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
-
-    env = Sprockets::Environment.new
-    env.register_engine '.ms', Class.new
-    assert_equal [".jst", ".ms"], env.attributes_for("foo.jst.ms").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
-
-  test "get path fingerprint" do
-    assert_equal nil, pathname("foo.js").path_fingerprint
-    assert_equal "0aa2105d29558f3eb790d411d7d8fb66",
-      pathname("foo-0aa2105d29558f3eb790d411d7d8fb66.js").path_fingerprint
-  end
-
-  test "inject path fingerprint" do
-    assert_equal "foo-0aa2105d29558f3eb790d411d7d8fb66.js",
-      pathname("foo.js").path_with_fingerprint("0aa2105d29558f3eb790d411d7d8fb66")
-  end
-
-  private
-    def pathname(path)
-      env = Sprockets::Environment.new
-      env.append_path fixture_path("default")
-      env.attributes_for(path)
-    end
-end

data/vendor/sprockets/test/test_caching.rb

@@ -1,62 +0,0 @@
-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

@@ -1,115 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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

@@ -1,65 +0,0 @@
-# -*- 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

@@ -1,73 +0,0 @@
-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