middleman-core 3.2.2 → 3.3.0

data/lib/vendored-middleman-deps/padrino-core-0.11.4/test/test_reloader_complex.rb

@@ -1,75 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-require File.expand_path(File.dirname(__FILE__) + '/fixtures/apps/complex')
-
-describe "ComplexReloader" do
-
-  context 'for complex reload functionality' do
-    setup do
-      Padrino.clear!
-      Padrino.mount("complex_1_demo").to("/complex_1_demo")
-      Padrino.mount("complex_2_demo").to("/complex_2_demo")
-    end
-
-    should 'correctly instantiate Complex(1-2)Demo fixture' do
-      assert_equal ["/complex_1_demo", "/complex_2_demo"], Padrino.mounted_apps.map(&:uri_root)
-      assert_equal ["complex_1_demo", "complex_2_demo"], Padrino.mounted_apps.map(&:name)
-      assert Complex1Demo.reload?
-      assert Complex2Demo.reload?
-      assert_match %r{fixtures/apps/complex.rb}, Complex1Demo.app_file
-      assert_match %r{fixtures/apps/complex.rb}, Complex2Demo.app_file
-    end
-
-    should 'correctly reload Complex(1-2)Demo fixture' do
-      assert_match %r{fixtures/apps/complex.rb}, Complex1Demo.app_file
-      @app = Padrino.application
-
-      get "/"
-      assert_equal 404, status
-
-      get "/complex_1_demo"
-      assert_equal "Given random #{LibDemo.give_me_a_random}", body
-
-      get "/complex_2_demo"
-      assert_equal 200, status
-
-      get "/complex_1_demo/old"
-      assert_equal 200, status
-
-      get "/complex_2_demo/old"
-      assert_equal 200, status
-
-      get "/complex_2_demo/var/destroy"
-      assert_equal '{}', body
-
-      new_phrase = "The magick number is: #{rand(2**255)}!"
-      buffer     = File.read(Complex1Demo.app_file)
-      new_buffer = buffer.gsub(/The magick number is: \d+!/, new_phrase)
-      new_buffer.gsub!(/get\(:destroy\)/, 'get(:destroy, :with => :id)')
-      begin
-        File.open(Complex1Demo.app_file, "w") { |f| f.write(new_buffer) }
-        sleep 1.2 # We need at least a cooldown of 1 sec.
-        get "/complex_2_demo"
-        assert_equal new_phrase, body
-
-        # Re-Check that we didn't forget any route
-        get "/complex_1_demo"
-        assert_equal "Given random #{LibDemo.give_me_a_random}", body
-
-        get "/complex_2_demo"
-        assert_equal 200, status
-
-        get "/complex_1_demo/old"
-        assert_equal 200, status
-
-        get "/complex_2_demo/old"
-        assert_equal 200, status
-
-        get "/complex_2_demo/var/destroy/variable"
-        assert_equal '{:id=>"variable"}', body
-      ensure
-        # Now we need to prevent to commit a new changed file so we revert it
-        File.open(Complex1Demo.app_file, "w") { |f| f.write(buffer) }
-      end
-    end
-  end
-end

data/lib/vendored-middleman-deps/padrino-core-0.11.4/test/test_reloader_simple.rb

@@ -1,98 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-require File.expand_path(File.dirname(__FILE__) + '/fixtures/apps/simple')
-
-describe "SimpleReloader" do
-
-  context 'for simple reset functionality' do
-
-    should 'reset routes' do
-      mock_app do
-        (1..10).each do |i|
-          get("/#{i}") { "Foo #{i}" }
-        end
-      end
-      (1..10).each do |i|
-        get "/#{i}"
-        assert_equal "Foo #{i}", body
-      end
-      @app.reset_routes!
-      (1..10).each do |i|
-        get "/#{i}"
-        assert_equal 404, status
-      end
-    end
-
-    should 'keep sinatra routes on development' do
-      mock_app do
-        set :environment, :development
-        get("/"){ "ok" }
-      end
-      assert_equal :development, @app.environment
-      get "/"
-      assert_equal 200, status
-      get "/__sinatra__/404.png"
-      assert_equal 200, status
-      assert_match /image\/png/, response["Content-Type"]
-      @app.reset_routes!
-      get "/"
-      assert_equal 404, status
-      get "/__sinatra__/404.png"
-      assert_equal 200, status
-      assert_match /image\/png/, response["Content-Type"]
-    end
-  end
-
-  context 'for simple reload functionality' do
-
-    should 'correctly instantiate SimpleDemo fixture' do
-      Padrino.clear!
-      Padrino.mount("simple_demo").to("/")
-      assert_equal ["simple_demo"], Padrino.mounted_apps.map(&:name)
-      assert SimpleDemo.reload?
-      assert_match %r{fixtures/apps/simple.rb}, SimpleDemo.app_file
-    end
-
-    should_eventually 'correctly reload SimpleDemo fixture' do
-      # TODO fix this test
-      @app = SimpleDemo
-      get "/"
-      assert ok?
-      new_phrase = "The magick number is: #{rand(2**255)}!"
-      buffer     = File.read(SimpleDemo.app_file)
-      new_buffer = buffer.gsub(/The magick number is: \d+!/, new_phrase)
-      File.open(SimpleDemo.app_file, "w") { |f| f.write(new_buffer) }
-      sleep 2 # We need at least a cooldown of 1 sec.
-      get "/"
-      assert_equal new_phrase, body
-
-      # Now we need to prevent to commit a new changed file so we revert it
-      File.open(SimpleDemo.app_file, "w") { |f| f.write(buffer) }
-      Padrino.reload!
-    end
-
-    should 'correctly reset SimpleDemo fixture' do
-      @app = SimpleDemo
-      @app.reload!
-      get "/rand"
-      assert ok?
-      last_body = body
-      assert_equal 2, @app.filters[:before].size # one is ours the other is default_filter for content type
-      assert_equal 1, @app.errors.size
-      assert_equal 2, @app.filters[:after].size # app + content-type + padrino-flash
-      assert_equal 0, @app.middleware.size
-      assert_equal 4, @app.routes.size # GET+HEAD of "/" + GET+HEAD of "/rand" = 4
-      assert_equal 3, @app.extensions.size # [Padrino::Routing, Padrino::Rendering, Padrino::Flash]
-      assert_equal 0, @app.templates.size
-      @app.reload!
-      get "/rand"
-      assert_not_equal last_body, body
-      assert_equal 2, @app.filters[:before].size # one is ours the other is default_filter for content type
-      assert_equal 1, @app.errors.size
-      assert_equal 2, @app.filters[:after].size
-      assert_equal 0, @app.middleware.size
-      assert_equal 4, @app.routes.size # GET+HEAD of "/" = 2
-      assert_equal 3, @app.extensions.size # [Padrino::Routing, Padrino::Rendering, Padrino::Flash]
-      assert_equal 0, @app.templates.size
-    end
-  end
-end

data/lib/vendored-middleman-deps/padrino-core-0.11.4/test/test_rendering.rb

@@ -1,545 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-require 'i18n'
-require 'slim'
-
-describe "Rendering" do
-  def setup
-    Padrino::Application.send(:register, Padrino::Rendering)
-    Padrino::Rendering::DEFAULT_RENDERING_OPTIONS[:strict_format] = false
-  end
-
-  def teardown
-    remove_views
-  end
-
-  context 'for application layout functionality' do
-
-    should 'get no layout' do
-      mock_app do
-        get("/"){ "no layout" }
-      end
-
-      get "/"
-      assert_equal "no layout", body
-    end
-
-    should 'be compatible with sinatra layout' do
-      mock_app do
-        layout do
-          "this is a <%= yield %>"
-        end
-
-        get("/"){ render :erb, "sinatra layout", :layout => true }
-      end
-
-      get "/"
-      assert_equal "this is a sinatra layout", body
-    end
-
-    should 'use rails way layout' do
-      with_layout :application, "this is a <%= yield %>" do
-        mock_app do
-          get("/"){ render :erb, "rails way layout" }
-        end
-
-        get "/"
-        assert_equal "this is a rails way layout", body
-      end
-    end
-
-    should 'use rails way for a custom layout' do
-      with_layout "layouts/custom", "this is a <%= yield %>" do
-        mock_app do
-          layout :custom
-          get("/"){ render :erb, "rails way custom layout" }
-        end
-
-        get "/"
-        assert_equal "this is a rails way custom layout", body
-      end
-    end
-
-    should 'not use layout' do
-      with_layout :application, "this is an <%= yield %>" do
-        with_view :index, "index" do
-          mock_app do
-            get("/with/layout"){ render :index }
-            get("/without/layout"){ render :index, :layout => false }
-          end
-          get "/with/layout"
-          assert_equal "this is an index", body
-          get "/without/layout"
-          assert_equal "index", body
-        end
-      end
-    end
-
-    should 'not use layout with js format' do
-      create_layout :application, "this is an <%= yield %>"
-      create_view :foo, "erb file"
-      create_view :foo, "js file", :format => :js
-      mock_app do
-        get('/layout_test', :provides => [:html, :js]){ render :foo }
-      end
-      get "/layout_test"
-      assert_equal "this is an erb file", body
-      get "/layout_test.js"
-      assert_equal "js file", body
-    end
-
-    should 'use correct layout for each format' do
-      create_layout :application, "this is an <%= yield %>"
-      create_layout :application, "document start <%= yield %> end", :format => :xml
-      create_view :foo, "erb file"
-      create_view :foo, "xml file", :format => :xml
-      mock_app do
-        get('/layout_test', :provides => [:html, :xml]){ render :foo }
-      end
-      get "/layout_test"
-      assert_equal "this is an erb file", body
-      get "/layout_test.xml"
-      assert_equal "document start xml file end", body
-    end
-
-    should 'by default use html file when no other is given' do
-      create_layout :baz, "html file", :format => :html
-
-      mock_app do
-        get('/content_type_test', :provides => [:html, :xml]) { render :baz }
-      end
-
-      get "/content_type_test"
-      assert_equal "html file", body
-      get "/content_type_test.html"
-      assert_equal "html file", body
-      get "/content_type_test.xml"
-      assert_equal "html file", body
-    end
-
-    should 'not use html file when DEFAULT_RENDERING_OPTIONS[:strict_format] == true' do
-      create_layout :foo, "html file", :format => :html
-
-      mock_app do
-        get('/default_rendering_test', :provides => [:html, :xml]) { render :foo }
-      end
-
-      @save = Padrino::Rendering::DEFAULT_RENDERING_OPTIONS
-      Padrino::Rendering::DEFAULT_RENDERING_OPTIONS[:strict_format] = true
-
-      get "/default_rendering_test"
-      assert_equal "html file", body
-      assert_raises Padrino::Rendering::TemplateNotFound do
-        get "/default_rendering_test.xml"
-      end
-
-      Padrino::Rendering::DEFAULT_RENDERING_OPTIONS.merge!(@save)
-    end
-
-    should 'use correct layout with each controller' do
-      create_layout :foo, "foo layout at <%= yield %>"
-      create_layout :bar, "bar layout at <%= yield %>"
-      create_layout :baz, "baz layout at <%= yield %>"
-      create_layout :application, "default layout at <%= yield %>"
-      mock_app do
-        get("/"){ render :erb, "application" }
-        controller :foo do
-          layout :foo
-          get("/"){ render :erb, "foo" }
-        end
-        controller :bar do
-          layout :bar
-          get("/"){ render :erb, "bar" }
-        end
-        controller :baz do
-          layout :baz
-          get("/"){ render :erb, "baz", :layout => true }
-        end
-        controller :none do
-          get("/") { render :erb, "none" }
-          get("/with_foo_layout")  { render :erb, "none with layout", :layout => :foo }
-        end
-      end
-      get "/foo"
-      assert_equal "foo layout at foo", body
-      get "/bar"
-      assert_equal "bar layout at bar", body
-      get "/baz"
-      assert_equal "baz layout at baz", body
-      get "/none"
-      assert_equal "default layout at none", body
-      get "/none/with_foo_layout"
-      assert_equal "foo layout at none with layout", body
-      get "/"
-      assert_equal "default layout at application", body
-    end
-  end
-
-  should 'solve layout in layouts paths' do
-    create_layout :foo, "foo layout <%= yield %>"
-    create_layout :"layouts/bar", "bar layout <%= yield %>"
-    mock_app do
-      get("/") { render :erb, "none" }
-      get("/foo") { render :erb, "foo", :layout => :foo }
-      get("/bar") { render :erb, "bar", :layout => :bar }
-    end
-    get "/"
-    assert_equal "none", body
-    get "/foo"
-    assert_equal "foo layout foo", body
-    get "/bar"
-    assert_equal "bar layout bar", body
-  end
-
-  should 'render correctly if layout was not found or not exist' do
-    create_layout :application, "application layout for <%= yield %>"
-    create_view :foo, "index", :format => :html
-    create_view :foo, "xml.rss", :format => :rss
-    mock_app do
-      get("/foo", :provides => [:html, :rss]) { render('foo') }
-      get("/baz", :provides => :js) { render(:erb, 'baz') }
-      get("/bar") { render :haml, "haml" }
-    end
-    get "/foo"
-    assert_equal "application layout for index", body
-    get "/foo.rss"
-    assert_equal "<rss/>", body.chomp
-    get "/baz.js"
-    assert_equal "baz", body
-    get "/bar"
-    assert_equal "haml", body.chomp
-  end
-
-  context 'for application render functionality' do
-
-    should "work properly with logging and missing layout" do
-      create_view :index, "<%= foo %>"
-      mock_app do
-        enable :logging
-        get("/") { render "index", { :layout => nil }, { :foo => "bar" } }
-      end
-      get "/"
-      assert_equal "bar", body
-    end
-
-    should "work properly with logging and layout" do
-      create_layout :application, "layout <%= yield %>"
-      create_view :index, "<%= foo %>"
-      mock_app do
-        enable :logging
-        get("/") { render "index", { :layout => true }, { :foo => "bar" } }
-      end
-      get "/"
-      assert_equal "layout bar", body
-    end
-
-    should 'be compatible with sinatra render' do
-      mock_app do
-        get("/"){ render :erb, "<%= 1+2 %>" }
-      end
-      get "/"
-      assert_equal "3", body
-    end
-
-    should "support passing locals into render" do
-      create_layout :application, "layout <%= yield %>"
-      create_view :index, "<%= foo %>"
-      mock_app do
-        get("/") { render "index", { :layout => true }, { :foo => "bar" } }
-      end
-      get "/"
-      assert_equal "layout bar", body
-    end
-
-    should "support passing locals into sinatra render" do
-      create_layout :application, "layout <%= yield %>"
-      create_view :index, "<%= foo %>"
-      mock_app do
-        get("/") { render :erb, :index, { :layout => true }, { :foo => "bar" } }
-      end
-      get "/"
-      assert_equal "layout bar", body
-    end
-
-    should "support passing locals into special nil engine render" do
-      create_layout :application, "layout <%= yield %>"
-      create_view :index, "<%= foo %>"
-      mock_app do
-        get("/") { render nil, :index, { :layout => true }, { :foo => "bar" } }
-      end
-      get "/"
-      assert_equal "layout bar", body
-    end
-
-    should 'be compatible with sinatra views' do
-      with_view :index, "<%= 1+2 %>" do
-        mock_app do
-          get("/foo") { render :erb, :index }
-          get("/bar") { erb :index }
-          get("/dir") { "3" }
-          get("/inj") { erb "<%= 2+1 %>" }
-          get("/rnj") { render :erb, "<%= 2+1 %>" }
-        end
-        get "/foo"
-        assert_equal "3", body
-        get "/bar"
-        assert_equal "3", body
-        get "/dir"
-        assert_equal "3", body
-        get "/inj"
-        assert_equal "3", body
-        get "/rnj"
-        assert_equal "3", body
-      end
-    end
-
-    should 'resolve template engine' do
-      with_view :index, "<%= 1+2 %>" do
-        mock_app do
-          get("/foo") { render :index }
-          get("/bar") { render "/index" }
-        end
-        get "/foo"
-        assert_equal "3", body
-        get "/bar"
-        assert_equal "3", body
-      end
-    end
-
-    should 'resolve template content type' do
-      create_view :foo, "Im Js", :format => :js
-      create_view :foo, "Im Erb"
-      mock_app do
-        get("/foo", :provides => :js) { render :foo }
-        get("/bar.js") { render :foo }
-      end
-      get "/foo.js"
-      assert_equal "Im Js", body
-      # TODO: implement this!
-      # get "/bar.js"
-      # assert_equal "Im Js", body
-    end
-
-    should 'resolve with explicit template format' do
-      create_view :foo, "Im Js", :format => :js
-      create_view :foo, "Im Haml", :format => :haml
-      create_view :foo, "Im Xml", :format => :xml
-      mock_app do
-        get("/foo_normal", :provides => :js) { render 'foo' }
-        get("/foo_haml", :provides => :js) { render 'foo.haml' }
-        get("/foo_xml", :provides => :js) { render 'foo.xml' }
-      end
-      get "/foo_normal.js"
-      assert_equal "Im Js", body
-      get "/foo_haml.js"
-      assert_equal "Im Haml\n", body
-      get "/foo_xml.js"
-      assert_equal "Im Xml", body
-    end
-
-    should 'resolve without explict template format' do
-      create_view :foo, "Im Html"
-      create_view :foo, "xml.rss", :format => :rss
-      mock_app do
-        get(:index, :map => "/", :provides => [:html, :rss]){ render 'foo' }
-      end
-      get "/", {}, { 'HTTP_ACCEPT' => 'text/html;q=0.9' }
-      assert_equal "Im Html", body
-      get ".rss"
-      assert_equal "<rss/>\n", body
-    end
-
-    should "ignore files ending in tilde and not render them" do
-      create_view :foo, "Im Wrong", :format => 'haml~'
-      create_view :foo, "Im Haml",  :format => :haml
-      create_view :bar, "Im Haml backup", :format => 'haml~'
-      mock_app do
-        get('/foo') { render 'foo' }
-        get('/bar') { render 'bar' }
-      end
-      get '/foo'
-      assert_equal "Im Haml\n", body
-      assert_raises(Padrino::Rendering::TemplateNotFound) { get '/bar' }
-    end
-
-    should 'resolve template locale' do
-      create_view :foo, "Im English", :locale => :en
-      create_view :foo, "Im Italian", :locale => :it
-      mock_app do
-        get("/foo") { render :foo }
-      end
-      I18n.locale = :en
-      get "/foo"
-      assert_equal "Im English", body
-      I18n.locale = :it
-      get "/foo"
-      assert_equal "Im Italian", body
-    end
-
-    should 'resolve template content_type and locale' do
-      create_view :foo, "Im Js",          :format => :js
-      create_view :foo, "Im Erb"
-      create_view :foo, "Im English Erb", :locale => :en
-      create_view :foo, "Im Italian Erb", :locale => :it
-      create_view :foo, "Im English Js",  :format => :js, :locale => :en
-      create_view :foo, "Im Italian Js",  :format => :js, :locale => :it
-      mock_app do
-        get("/foo", :provides => [:html, :js]) { render :foo }
-      end
-      I18n.locale = :none
-      get "/foo.js"
-      assert_equal "Im Js", body
-      get "/foo"
-      assert_equal "Im Erb", body
-      I18n.locale = :en
-      get "/foo"
-      assert_equal "Im English Erb", body
-      I18n.locale = :it
-      get "/foo"
-      assert_equal "Im Italian Erb", body
-      I18n.locale = :en
-      get "/foo.js"
-      assert_equal "Im English Js", body
-      I18n.locale = :it
-      get "/foo.js"
-      assert_equal "Im Italian Js", body
-      I18n.locale = :en
-      get "/foo.pk"
-      assert_equal 404, status
-    end
-
-    should 'resolve template content_type and locale with layout' do
-      create_layout :foo, "Hello <%= yield %> in a Js layout",     :format => :js
-      create_layout :foo, "Hello <%= yield %> in a Js-En layout",  :format => :js, :locale => :en
-      create_layout :foo, "Hello <%= yield %> in a Js-It layout",  :format => :js, :locale => :it
-      create_layout :foo, "Hello <%= yield %> in a Erb-En layout", :locale => :en
-      create_layout :foo, "Hello <%= yield %> in a Erb-It layout", :locale => :it
-      create_layout :foo, "Hello <%= yield %> in a Erb layout"
-      create_view   :bar, "Im Js",          :format => :js
-      create_view   :bar, "Im Erb"
-      create_view   :bar, "Im English Erb", :locale => :en
-      create_view   :bar, "Im Italian Erb", :locale => :it
-      create_view   :bar, "Im English Js",  :format => :js, :locale => :en
-      create_view   :bar, "Im Italian Js",  :format => :js, :locale => :it
-      create_view   :bar, "Im a json",      :format => :json
-      mock_app do
-        layout :foo
-        get("/bar", :provides => [:html, :js, :json]) { render :bar }
-      end
-      I18n.locale = :none
-      get "/bar.js"
-      assert_equal "Hello Im Js in a Js layout", body
-      get "/bar"
-      assert_equal "Hello Im Erb in a Erb layout", body
-      I18n.locale = :en
-      get "/bar"
-      assert_equal "Hello Im English Erb in a Erb-En layout", body
-      I18n.locale = :it
-      get "/bar"
-      assert_equal "Hello Im Italian Erb in a Erb-It layout", body
-      I18n.locale = :en
-      get "/bar.js"
-      assert_equal "Hello Im English Js in a Js-En layout", body
-      I18n.locale = :it
-      get "/bar.js"
-      assert_equal "Hello Im Italian Js in a Js-It layout", body
-      I18n.locale = :en
-      get "/bar.json"
-      assert_equal "Im a json", body
-      get "/bar.pk"
-      assert_equal 404, status
-    end
-
-    should 'renders erb with blocks' do
-      mock_app do
-        def container
-          @_out_buf << "THIS."
-          yield
-          @_out_buf << "SPARTA!"
-        end
-        def is; "IS."; end
-        get '/' do
-          render :erb, '<% container do %> <%= is %> <% end %>'
-        end
-      end
-      get '/'
-      assert ok?
-      assert_equal 'THIS. IS. SPARTA!', body
-    end
-
-    should 'render erb to a SafeBuffer' do
-      mock_app do
-        layout do
-          "this is a <%= yield %>"
-        end
-        get '/' do
-          render :erb, '<p><%= %q{<script lang="ronin">alert("https://github.com/ronin-ruby/ronin")</script>} %></p>', :layout => false
-        end
-        get '/with_layout' do
-          render :erb, '<span>span</span>', :layout => true
-        end
-      end
-      get '/'
-      assert ok?
-      assert_equal '<p>&lt;script lang=&quot;ronin&quot;&gt;alert(&quot;https://github.com/ronin-ruby/ronin&quot;)&lt;/script&gt;</p>', body
-
-      get '/with_layout'
-      assert ok?
-      assert_equal 'this is a <span>span</span>', body
-    end
-
-    should 'render haml to a SafeBuffer' do
-      mock_app do
-        layout do
-          "%p= yield"
-        end
-        get '/' do
-          render :haml, '%p= %s{<script lang="ronin">alert("https://github.com/ronin-ruby/ronin")</script>}', :layout => false
-        end
-        get '/with_layout' do
-          render :haml, "%div\n  foo", :layout => true
-        end
-      end
-      get '/'
-      assert ok?
-      assert_equal '<p>&lt;script lang=&quot;ronin&quot;&gt;alert(&quot;https://github.com/ronin-ruby/ronin&quot;)&lt;/script&gt;</p>', body.strip
-
-      get 'with_layout'
-      assert ok?
-      assert_equal '<p><div>foo</div></p>', body.gsub(/\s+/, "")
-    end
-
-    should 'render slim to a SafeBuffer' do
-      mock_app do
-        layout do
-          "p= yield"
-        end
-        get '/' do
-          render :slim, 'p = %q{<script lang="ronin">alert("https://github.com/ronin-ruby/ronin")</script>}', :layout => false
-        end
-        get "/with_layout" do
-          render :slim, 'div foo', :layout => true
-        end
-      end
-      get '/'
-      assert ok?
-      assert_equal '<p>&lt;script lang=&quot;ronin&quot;&gt;alert(&quot;https://github.com/ronin-ruby/ronin&quot;)&lt;/script&gt;</p>', body.strip
-
-      get '/with_layout'
-      assert ok?
-      assert_equal '<p><div>foo</div></p>', body.strip
-    end
-
-    should "render correct erb when use sinatra as middleware" do
-      class Bar < Sinatra::Base
-        get "/" do
-          render :erb, "<&'>"
-        end
-      end
-      mock_app do
-        use Bar
-      end
-      get "/"
-      assert_equal "<&'>", body
-    end
-  end
-end