middleman-core 3.0.0.beta.2 → 3.0.0.beta.3

data/lib/middleman-core/vendor/padrino-core-0.10.6/test/mini_shoulda.rb

@@ -1,45 +0,0 @@
-gem 'minitest'
-require 'minitest/spec'
-require 'minitest/autorun'
-require 'mocha' # Load mocha after minitest
-
-begin
-  require 'ruby-debug'
-rescue LoadError; end
-
-class MiniTest::Spec
-  class << self
-    alias :setup :before unless defined?(Rails)
-    alias :teardown :after unless defined?(Rails)
-    alias :should :it
-    alias :context :describe
-    def should_eventually(desc)
-      it("should eventually #{desc}") { skip("Should eventually #{desc}") }
-    end
-  end
-  alias :assert_no_match  :refute_match
-  alias :assert_not_nil   :refute_nil
-  alias :assert_not_equal :refute_equal
-end
-
-class ColoredIO
-  def initialize(io)
-    @io = io
-  end
-
-  def print(o)
-    case o
-    when "." then @io.send(:print, o.green)
-    when "E" then @io.send(:print, o.red)
-    when "F" then @io.send(:print, o.yellow)
-    when "S" then @io.send(:print, o.magenta)
-    else @io.send(:print, o)
-    end
-  end
-
-  def puts(*o)
-    super
-  end
-end
-
-MiniTest::Unit.output = ColoredIO.new(MiniTest::Unit.output)

data/lib/middleman-core/vendor/padrino-core-0.10.6/test/test_application.rb

@@ -1,108 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-
-class PadrinoPristine < Padrino::Application; end
-class PadrinoTestApp < Padrino::Application; end
-class PadrinoTestApp2 < Padrino::Application; end
-
-describe "Application" do
-  def setup
-    Padrino.clear!
-  end
-
-  def teardown
-    remove_views
-  end
-
-  context 'for application functionality' do
-
-    should 'check default options' do
-      assert File.identical?(__FILE__, PadrinoPristine.app_file)
-      assert_equal :padrino_pristine, PadrinoPristine.app_name
-      assert_equal :test, PadrinoPristine.environment
-      assert_equal Padrino.root("views"), PadrinoPristine.views
-      assert PadrinoPristine.raise_errors
-      assert !PadrinoPristine.logging
-      assert !PadrinoPristine.sessions
-      assert !PadrinoPristine.dump_errors
-      assert !PadrinoPristine.show_exceptions
-      assert PadrinoPristine.raise_errors
-      assert !Padrino.configure_apps
-    end
-
-    should 'check padrino specific options' do
-      assert !PadrinoPristine.instance_variable_get(:@_configured)
-      PadrinoPristine.send(:setup_application!)
-      assert_equal :padrino_pristine, PadrinoPristine.app_name
-      assert_equal 'StandardFormBuilder', PadrinoPristine.default_builder
-      assert PadrinoPristine.instance_variable_get(:@_configured)
-      assert !PadrinoPristine.reload?
-      assert !PadrinoPristine.flash
-    end
-
-    should 'set global project settings' do
-      Padrino.configure_apps { enable :sessions; set :foo, "bar" }
-      PadrinoTestApp.send(:default_configuration!)
-      PadrinoTestApp2.send(:default_configuration!)
-      assert PadrinoTestApp.sessions, "should have sessions enabled"
-      assert_equal "bar", PadrinoTestApp.settings.foo, "should have foo assigned"
-      assert_equal PadrinoTestApp.session_secret, PadrinoTestApp2.session_secret
-    end
-
-    should "have shared sessions accessible in project" do
-      Padrino.configure_apps { enable :sessions; set :session_secret, 'secret' }
-      Padrino.mount("PadrinoTestApp").to("/write")
-      Padrino.mount("PadrinoTestApp2").to("/read")
-      PadrinoTestApp.tap { |app| app.send(:default_configuration!)
-        app.get("/") { session[:foo] = "shared" } }
-      PadrinoTestApp2.tap { |app| app.send(:default_configuration!)
-        app.get("/") { session[:foo] } }
-      browser = Rack::Test::Session.new(Rack::MockSession.new(Padrino.application))
-      browser.get '/write'
-      browser.get '/read'
-      assert_equal 'shared', browser.last_response.body
-    end
-
-    # compare to: test_routing: allow global provides
-    should "set content_type to :html if none can be determined" do
-      mock_app do
-        provides :xml
-
-        get("/foo"){ "Foo in #{content_type}" }
-        get("/bar"){ "Foo in #{content_type}" }
-      end
-
-      get '/foo', {}, { 'HTTP_ACCEPT' => 'application/xml' }
-      assert_equal 'Foo in xml', body
-      get '/foo'
-      assert_equal 'Foo in xml', body
-
-      get '/bar', {}, { 'HTTP_ACCEPT' => 'application/xml' }
-      assert_equal "Foo in html", body
-    end # content_type to :html
-
-    context "errors" do
-      should "haven't mapped errors on development" do
-        mock_app { get('/'){ 'HI' } }
-        get "/"
-        assert @app.errors.empty?
-      end
-
-      should "have mapped errors on production" do
-        mock_app { set :environment, :production; get('/'){ 'HI' } }
-        get "/"
-        assert_equal 1, @app.errors.size
-      end
-
-      should "overide errors" do
-        mock_app do
-          set :environment, :production
-          get('/'){ raise }
-          error(::Exception){ 'custom error' }
-        end
-        get "/"
-        assert_equal 1, @app.errors.size
-        assert_equal 'custom error', body
-      end
-    end
-  end # application functionality
-end

data/lib/middleman-core/vendor/padrino-core-0.10.6/test/test_core.rb

@@ -1,77 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-
-describe "Core" do
-  def setup
-    Padrino.clear!
-  end
-
-  context 'for core functionality' do
-
-    should 'check some global methods' do
-      assert_respond_to Padrino, :root
-      assert_respond_to Padrino, :env
-      assert_respond_to Padrino, :application
-      assert_respond_to Padrino, :set_encoding
-      assert_respond_to Padrino, :load!
-      assert_respond_to Padrino, :reload!
-      assert_respond_to Padrino, :version
-      assert_respond_to Padrino, :configure_apps
-    end
-
-
-    should 'validate global helpers' do
-      assert_equal :test, Padrino.env
-      assert_match /\/test/, Padrino.root
-      assert_not_nil Padrino.version
-    end
-
-    should 'set correct utf-8 encoding' do
-      Padrino.set_encoding
-      if RUBY_VERSION <'1.9'
-        assert_equal 'UTF8', $KCODE
-      else
-        assert_equal Encoding.default_external, Encoding::UTF_8
-        assert_equal Encoding.default_internal, Encoding::UTF_8
-      end
-    end
-
-    should 'have load paths' do
-      assert_equal [Padrino.root('lib'), Padrino.root('models'), Padrino.root('shared')], Padrino.load_paths
-    end
-
-    should 'raise application error if I instantiate a new padrino application without mounted apps' do
-      assert_raises(Padrino::ApplicationLoadError) { Padrino.application.new }
-    end
-
-    should "check before/after padrino load hooks" do
-      Padrino.before_load { @_foo  = 1 }
-      Padrino.after_load  { @_foo += 1 }
-      Padrino.load!
-      assert_equal 1, Padrino.before_load.size
-      assert_equal 1, Padrino.after_load.size
-      assert_equal 2, @_foo
-    end
-
-    should "add middlewares in front if specified" do
-      test = Class.new {
-        def initialize(app)
-          @app = app
-        end
-
-        def call(env)
-          status, headers, body = @app.call(env)
-          headers["Middleware-Called"] = "yes"
-          return status, headers, body
-        end
-      }
-
-      class Foo < Padrino::Application; end
-
-      Padrino.use(test)
-      Padrino.mount(Foo).to("/")
-
-      res = Rack::MockRequest.new(Padrino.application).get("/")
-      assert_equal "yes", res["Middleware-Called"]
-    end
-  end
-end

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

@@ -1,44 +0,0 @@
-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-core/vendor/padrino-core-0.10.6/test/test_filters.rb

@@ -1,278 +0,0 @@
-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-core/vendor/padrino-core-0.10.6/test/test_locale.rb

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