middleman 2.0.16.1 → 3.0.0.alpha.2

data/lib/middleman/vendor/padrino-core-0.10.5/test/test_dependencies.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.dirname(__FILE__) + '/helper')
+
+describe "Dependencies" do
+  context 'when we require a dependency that have another dependency' do
+
+    should 'raise an error without reloading it twice' do
+      capture_io do
+        assert_raises(RuntimeError) do
+          Padrino.require_dependencies(
+            Padrino.root("fixtures/dependencies/a.rb"),
+            Padrino.root("fixtures/dependencies/b.rb"),
+            Padrino.root("fixtures/dependencies/c.rb"),
+            Padrino.root("fixtures/dependencies/d.rb")
+          )
+        end
+      end
+      assert_equal 1, D
+    end
+
+    should 'resolve dependency problems' do
+      capture_io do
+        Padrino.require_dependencies(
+          Padrino.root("fixtures/dependencies/a.rb"),
+          Padrino.root("fixtures/dependencies/b.rb"),
+          Padrino.root("fixtures/dependencies/c.rb")
+        )
+      end
+      assert_equal ["B", "C"], A_result
+      assert_equal "C", B_result
+    end
+
+    should 'remove partially loaded constants' do
+      capture_io do
+        Padrino.require_dependencies(
+          Padrino.root("fixtures/dependencies/circular/e.rb"),
+          Padrino.root("fixtures/dependencies/circular/f.rb"),
+          Padrino.root("fixtures/dependencies/circular/g.rb")
+        )
+      end
+
+      assert_equal ["name"], F.fields
+    end
+  end
+end

data/lib/middleman/vendor/padrino-core-0.10.5/test/test_filters.rb

@@ -0,0 +1,278 @@
+require File.expand_path(File.dirname(__FILE__) + '/helper')
+
+describe "Filters" do
+  should "filters by accept header" do
+    mock_app do
+      get '/foo', :provides => [:xml, :js] do
+        request.env['HTTP_ACCEPT']
+      end
+    end
+
+    get '/foo', {}, { 'HTTP_ACCEPT' => 'application/xml' }
+    assert ok?
+    assert_equal 'application/xml', body
+    assert_equal 'application/xml;charset=utf-8', response.headers['Content-Type']
+
+    get '/foo.xml'
+    assert ok?
+    assert_equal 'application/xml;charset=utf-8', response.headers['Content-Type']
+
+    get '/foo', {}, { 'HTTP_ACCEPT' => 'application/javascript' }
+    assert ok?
+    assert_equal 'application/javascript', body
+    assert_equal 'application/javascript;charset=utf-8', response.headers['Content-Type']
+
+    get '/foo.js'
+    assert ok?
+    assert_equal 'application/javascript;charset=utf-8', response.headers['Content-Type']
+
+    get '/foo', {}, { "HTTP_ACCEPT" => 'text/html' }
+    assert_equal 406, status
+  end
+
+  should "allow passing & halting in before filters" do
+    mock_app do
+      controller do
+        before { env['QUERY_STRING'] == 'secret' or pass }
+        get :index do
+          "secret index"
+        end
+      end
+
+      controller do
+        before { env['QUERY_STRING'] == 'halt' and halt 401, 'go away!' }
+        get :index do
+          "index"
+        end
+      end
+    end
+
+    get "/?secret"
+    assert_equal "secret index", body
+
+    get "/?halt"
+    assert_equal "go away!", body
+    assert_equal 401, status
+
+    get "/"
+    assert_equal "index", body
+  end
+
+  should 'scope filters in the given controller' do
+    mock_app do
+      before { @global = 'global' }
+      after { @global = nil }
+
+      controller :foo do
+        before { @foo = :foo }
+        after { @foo = nil }
+        get("/") { [@foo, @bar, @global].compact.join(" ") }
+      end
+
+      get("/") { [@foo, @bar, @global].compact.join(" ") }
+
+      controller :bar do
+        before { @bar = :bar }
+        after { @bar = nil }
+        get("/") { [@foo, @bar, @global].compact.join(" ") }
+      end
+    end
+
+    get "/bar"
+    assert_equal "bar global", body
+
+    get "/foo"
+    assert_equal "foo global", body
+
+    get "/"
+    assert_equal "global", body
+  end
+
+  should 'be able to access params in a before filter' do
+    username_from_before_filter = nil
+
+    mock_app do
+      before do
+        username_from_before_filter = params[:username]
+      end
+
+      get :users, :with => :username do
+      end
+    end
+    get '/users/josh'
+    assert_equal 'josh', username_from_before_filter
+  end
+
+  should "be able to access params normally when a before filter is specified" do
+    mock_app do
+      before { }
+      get :index do
+        params.inspect
+      end
+    end
+    get '/?test=what'
+    assert_equal '{"test"=>"what"}', body
+  end
+
+  should "be able to filter based on a path" do
+    mock_app do
+      before('/') { @test = "#{@test}before"}
+      get :index do
+        @test
+      end
+      get :main do
+        @test
+      end
+    end
+    get '/'
+    assert_equal 'before', body
+    get '/main'
+    assert_equal '', body
+  end
+
+  should "be able to filter based on a symbol" do
+    mock_app do
+      before(:index) { @test = 'before'}
+      get :index do
+        @test
+      end
+      get :main do
+        @test
+      end
+    end
+    get '/'
+    assert_equal 'before', body
+    get '/main'
+    assert_equal '', body
+  end
+
+  should "be able to filter based on a symbol for a controller" do
+    mock_app do
+      controller :foo do
+        before(:test) { @test = 'foo'}
+        get :test do
+          @test.to_s + " response"
+        end
+      end
+      controller :bar do
+        before(:test) { @test = 'bar'}
+        get :test do
+          @test.to_s + " response"
+        end
+      end
+    end
+    get '/foo/test'
+    assert_equal 'foo response', body
+    get '/bar/test'
+    assert_equal 'bar response', body
+  end
+
+  should "be able to filter based on a symbol or path" do
+    mock_app do
+      before(:index, '/main') { @test = 'before'}
+      get :index do
+        @test
+      end
+      get :main do
+        @test
+      end
+    end
+    get '/'
+    assert_equal 'before', body
+    get '/main'
+    assert_equal 'before', body
+  end
+
+  should "be able to filter based on a symbol or regexp" do
+    mock_app do
+      before(:index, /main/) { @test = 'before'}
+      get :index do
+        @test
+      end
+      get :main do
+        @test
+      end
+      get :profile do
+        @test
+      end
+    end
+    get '/'
+    assert_equal 'before', body
+    get '/main'
+    assert_equal 'before', body
+    get '/profile'
+    assert_equal '', body
+  end
+
+  should "be able to filter excluding based on a symbol" do
+    mock_app do
+      before(:except => :index) { @test = 'before'}
+      get :index do
+        @test
+      end
+      get :main do
+        @test
+      end
+    end
+    get '/'
+    assert_equal '', body
+    get '/main'
+    assert_equal 'before', body
+  end
+
+  should "be able to filter based on a request param" do
+    mock_app do
+      before(:agent => /IE/) { @test = 'before'}
+      get :index do
+        @test
+      end
+    end
+    get '/'
+    assert_equal '', body
+    get "/", {}, {'HTTP_USER_AGENT' => 'This is IE'}
+    assert_equal 'before', body
+  end
+
+  should "be able to filter based on a symbol or path in multiple controller" do
+    mock_app do
+      controllers :foo do
+        before(:index, '/foo/main') { @test = 'before' }
+        get :index do
+          @test
+        end
+        get :main do
+          @test
+        end
+      end
+      controllers :bar do
+        before(:index, '/bar/main') { @test = 'also before' }
+        get :index do
+          @test
+        end
+        get :main do
+          @test
+        end
+      end
+    end
+    get '/foo'
+    assert_equal 'before', body
+    get '/bar'
+    assert_equal 'also before', body
+    get '/foo/main'
+    assert_equal 'before', body
+    get '/bar/main'
+    assert_equal 'also before', body
+  end
+
+  should "call before filters even if there was no match" do
+    test = nil
+    mock_app do
+      before(:index, '/foo') { test = 'before' }
+      get :index do
+        ''
+      end
+    end
+    get '/foo'
+    assert_equal 'before', test
+  end
+end

data/lib/middleman/vendor/padrino-core-0.10.5/test/test_locale.rb

@@ -0,0 +1,21 @@
+require File.expand_path(File.dirname(__FILE__) + '/helper')
+
+describe "Locales" do
+  Dir[File.expand_path("../../lib/padrino-core/locale/*.yml", __FILE__)].each do |file|
+    base_original = YAML.load_file(file)
+    name = File.basename(file, '.yml')
+    should "should have correct locale for #{name}" do
+      base = base_original[name]['date']['formats']
+      assert base['default'].present?
+      assert base['short'].present?
+      assert base['long'].present?
+      assert base['only_day'].present?
+      base = base_original[name]['date']
+      assert base['day_names'].present?
+      assert base['abbr_day_names'].present?
+      assert base['month_names'].present?
+      assert base['abbr_month_names'].present?
+      assert base['order'].present?
+    end
+  end
+end

data/lib/middleman/vendor/padrino-core-0.10.5/test/test_logger.rb

@@ -0,0 +1,100 @@
+require File.expand_path(File.dirname(__FILE__) + '/helper')
+
+describe "PadrinoLogger" do
+
+  def setup
+    Padrino::Logger::Config[:test][:stream] = :null # The default
+    Padrino::Logger.setup!
+  end
+
+  def setup_logger(options={})
+    @log    = StringIO.new
+    @logger = Padrino::Logger.new(options.merge(:stream => @log))
+  end
+
+  context 'for logger functionality' do
+
+    context 'check stream config' do
+
+      should 'use stdout if stream is nil' do
+        Padrino::Logger::Config[:test][:stream] = nil
+        Padrino::Logger.setup!
+        assert_equal $stdout, Padrino.logger.log
+      end
+
+      should 'use StringIO as default for test' do
+        assert_instance_of StringIO, Padrino.logger.log
+      end
+
+      should 'use a custom stream' do
+        my_stream = StringIO.new
+        Padrino::Logger::Config[:test][:stream] = my_stream
+        Padrino::Logger.setup!
+        assert_equal my_stream, Padrino.logger.log
+      end
+    end
+
+    should 'log something' do
+      setup_logger(:log_level => :error)
+      @logger.error "You log this error?"
+      assert_match(/You log this error?/, @log.string)
+      @logger.debug "You don't log this error!"
+      assert_no_match(/You don't log this error!/, @log.string)
+      @logger << "Yep this can be logged"
+      assert_match(/Yep this can be logged/, @log.string)
+    end
+
+    should 'respond to #write for Rack::CommonLogger' do
+      setup_logger(:log_level => :error)
+      @logger.error "Error message"
+      assert_match /Error message/, @log.string
+      @logger << "logged anyways"
+      assert_match /logged anyways/, @log.string
+      @logger.write "log via alias"
+      assert_match /log via alias/, @log.string
+    end
+
+    should 'log an application' do
+      mock_app do
+        enable :logging
+        get("/"){ "Foo" }
+      end
+      get "/"
+      assert_equal "Foo", body
+      assert_match /GET/, Padrino.logger.log.string
+    end
+
+    should 'log an application\'s status code' do
+      mock_app do
+        enable :logging
+        get("/"){ "Foo" }
+      end
+      get "/"
+      assert_match /\e\[1m200\e\[0m OK/, Padrino.logger.log.string
+    end
+
+    context "static asset logging" do
+      should 'not log static assets by default' do
+        mock_app do
+          enable :logging
+          get("/images/something.png"){ env["sinatra.static_file"] = '/public/images/something.png'; "Foo" }
+        end
+        get "/images/something.png"
+        assert_equal "Foo", body
+        assert_match "", Padrino.logger.log.string
+      end
+
+      should 'allow turning on static assets logging' do
+        Padrino.logger.instance_eval{ @log_static = true }
+        mock_app do
+          enable :logging
+          get("/images/something.png"){ env["sinatra.static_file"] = '/public/images/something.png'; "Foo" }
+        end
+        get "/images/something.png"
+        assert_equal "Foo", body
+        assert_match /GET/, Padrino.logger.log.string
+        Padrino.logger.instance_eval{ @log_static = false }
+      end
+    end
+  end
+end

data/lib/middleman/vendor/padrino-core-0.10.5/test/test_mounter.rb

@@ -0,0 +1,177 @@
+require File.expand_path(File.dirname(__FILE__) + '/helper')
+
+describe "Mounter" do
+  class ::TestApp < Padrino::Application; end
+
+  def setup
+    $VERBOSE, @_verbose_was = nil, $VERBOSE
+    Padrino.clear!
+  end
+
+  def teardown
+    $VERBOSE = @_verbose_was
+  end
+
+  context 'for mounter functionality' do
+    should 'check methods' do
+      mounter = Padrino::Mounter.new("test_app", :app_file => "/path/to/test.rb")
+      mounter.to("/test_app")
+      assert_kind_of Padrino::Mounter, mounter
+      assert_respond_to Padrino::Mounter, :new
+      assert_respond_to mounter, :to
+      assert_respond_to mounter, :map_onto
+      assert_equal "test_app", mounter.name
+      assert_equal "TestApp", mounter.app_class
+      assert_equal "/path/to/test.rb", mounter.app_file
+      assert_equal "/test_app", mounter.uri_root
+      assert_equal File.dirname(mounter.app_file), mounter.app_root
+    end
+
+    should 'check locate_app_file with __FILE__' do
+      mounter = Padrino::Mounter.new("test_app", :app_file => __FILE__)
+      mounter.to("/test_app")
+      assert_equal "test_app", mounter.name
+      assert_equal "TestApp", mounter.app_class
+      assert_equal __FILE__, mounter.app_file
+      assert_equal "/test_app", mounter.uri_root
+      assert_equal File.dirname(mounter.app_file), mounter.app_root
+    end
+
+    should 'mount an app' do
+      class ::AnApp < Padrino::Application; end
+      Padrino.mount("an_app").to("/")
+      assert_equal AnApp, Padrino.mounted_apps.first.app_obj
+      assert_equal ["an_app"], Padrino.mounted_apps.map(&:name)
+    end
+
+    should 'correctly mount an app in a namespace' do
+      module ::SomeNamespace
+        class AnApp < Padrino::Application; end
+      end
+      Padrino.mount("some_namespace/an_app").to("/")
+      assert_equal SomeNamespace::AnApp, Padrino.mounted_apps.first.app_obj
+      assert_equal ["some_namespace/an_app"], Padrino.mounted_apps.map(&:name)
+    end
+
+    should 'mount a primary app to root uri' do
+      mounter = Padrino.mount("test_app", :app_file => __FILE__).to("/")
+      assert_equal "test_app", mounter.name
+      assert_equal "TestApp", mounter.app_class
+      assert_equal TestApp, mounter.app_obj
+      assert_equal __FILE__, mounter.app_file
+      assert_equal "/", mounter.uri_root
+      assert_equal File.dirname(mounter.app_file), mounter.app_root
+    end
+
+    should 'mount a primary app to sub_uri' do
+      mounter = Padrino.mount("test_app", :app_file => __FILE__).to('/me')
+      assert_equal "test_app", mounter.name
+      assert_equal "TestApp", mounter.app_class
+      assert_equal TestApp, mounter.app_obj
+      assert_equal __FILE__, mounter.app_file
+      assert_equal "/me", mounter.uri_root
+      assert_equal File.dirname(mounter.app_file), mounter.app_root
+    end
+
+    should "raise error when app has no located file" do
+      # TODO enabling this screws minitest
+      # assert_raises(Padrino::Mounter::MounterException) { Padrino.mount("tester_app").to('/test') }
+      assert_equal 0, Padrino.mounted_apps.size
+    end
+
+    should "raise error when app has no located object" do
+      assert_raises(Padrino::Mounter::MounterException) { Padrino.mount("tester_app", :app_file => "/path/to/file.rb").to('/test') }
+      assert_equal 0, Padrino.mounted_apps.size
+    end
+
+    should 'mount multiple apps' do
+      class ::OneApp < Padrino::Application; end
+      class ::TwoApp < Padrino::Application; end
+
+      Padrino.mount("one_app").to("/one_app")
+      Padrino.mount("two_app").to("/two_app")
+      # And testing no duplicates
+      Padrino.mount("one_app").to("/one_app")
+      Padrino.mount("two_app").to("/two_app")
+
+      assert_equal OneApp, Padrino.mounted_apps[0].app_obj
+      assert_equal TwoApp, Padrino.mounted_apps[1].app_obj
+      assert_equal 2, Padrino.mounted_apps.size, "should not mount duplicate apps"
+      assert_equal ["one_app", "two_app"], Padrino.mounted_apps.map(&:name)
+    end
+
+    should 'change mounted_root' do
+      Padrino.mounted_root = "fixtures"
+      assert_equal Padrino.root("fixtures", "test", "app.rb"), Padrino.mounted_root("test", "app.rb")
+      Padrino.mounted_root = "apps"
+      assert_equal Padrino.root("apps", "test", "app.rb"), Padrino.mounted_root("test", "app.rb")
+      Padrino.mounted_root = nil
+      assert_equal Padrino.root("test", "app.rb"), Padrino.mounted_root("test", "app.rb")
+    end
+
+    should "be able to access routes data for mounted apps" do
+      class ::OneApp < Padrino::Application
+        get("/test") { "test" }
+        get(:index, :provides => [:js, :json]) { "index" }
+        controllers :posts do
+          get(:index) { "index" }
+          get(:new, :provides => :js) { "new" }
+          get(:show, :provides => [:js, :html], :with => :id) { "show" }
+          post(:create, :provides => :js, :with => :id) { "create" }
+        end
+      end
+      class ::TwoApp < Padrino::Application
+        controllers :users do
+          get(:index) { "users" }
+          get(:new) { "users new" }
+          post(:create) { "users create" }
+          put(:update) { "users update" }
+          delete(:destroy) { "users delete" }
+        end
+      end
+
+      Padrino.mount("one_app").to("/")
+      Padrino.mount("two_app").to("/two_app")
+
+      assert_equal 11, Padrino.mounted_apps[0].routes.size
+      assert_equal 7, Padrino.mounted_apps[1].routes.size
+      assert_equal 5, Padrino.mounted_apps[0].named_routes.size
+      assert_equal 5, Padrino.mounted_apps[1].named_routes.size
+
+      first_route = Padrino.mounted_apps[0].named_routes[3]
+      assert_equal "posts_show", first_route.identifier.to_s
+      assert_equal "(:posts, :show)", first_route.name
+      assert_equal "GET", first_route.verb
+      assert_equal "/posts/show/:id(.:format)", first_route.path
+      another_route = Padrino.mounted_apps[1].named_routes[2]
+      assert_equal "users_create", another_route.identifier.to_s
+      assert_equal "(:users, :create)", another_route.name
+      assert_equal "POST", another_route.verb
+      assert_equal "/two_app/users/create", another_route.path
+    end
+
+    should 'correctly instantiate a new padrino application' do
+      mock_app do
+        get("/demo_1"){ "Im Demo 1" }
+        get("/demo_2"){ "Im Demo 2" }
+      end
+
+      get '/demo_1'
+      assert_equal "Im Demo 1", response.body
+      get '/demo_2'
+      assert_equal "Im Demo 2", response.body
+    end
+
+    should "not clobber the public setting when mounting an app" do
+      class ::PublicApp < Padrino::Application
+        set :root, "/root"
+        set :public_folder, File.expand_path(File.dirname(__FILE__))
+      end
+
+      Padrino.mount("public_app").to("/public")
+      res = Rack::MockRequest.new(Padrino.application).get("/public/test_mounter.rb")
+      assert res.ok?
+      assert_equal File.read(__FILE__), res.body
+    end
+  end
+end