middleman 2.0.16.1 → 3.0.0.alpha.2

data/lib/middleman/vendor/padrino-core-0.10.5/test/fixtures/apps/.components

@@ -0,0 +1,6 @@
+--- 
+:test: bacon
+:mock: mocha
+:orm: datamapper
+:renderer: erb
+:script: jquery

data/lib/middleman/vendor/padrino-core-0.10.5/test/fixtures/apps/.gitignore

@@ -0,0 +1,7 @@
+.DS_Store
+log/**/*
+tmp/**/*
+vendor/gems/gems
+vendor/gems/specifications
+vendor/gems/doc
+vendor/gems/environment.rb

data/lib/middleman/vendor/padrino-core-0.10.5/test/fixtures/apps/complex.rb

@@ -0,0 +1,32 @@
+PADRINO_ROOT = File.dirname(__FILE__) unless defined? PADRINO_ROOT
+
+module LibDemo
+  def self.give_me_a_random
+    @rand ||= rand(100)
+  end
+end
+
+class Complex1Demo < Padrino::Application
+  set :reload, true
+  get("/old"){ "Old Sinatra Way" }
+end
+
+class Complex2Demo < Padrino::Application
+  set :reload, true
+  get("/old"){ "Old Sinatra Way" }
+
+  controllers :var do
+    get(:destroy){ params.inspect }
+  end
+
+  get("/"){ "The magick number is: 12!" } # Change only the number!!!
+end
+
+Complex1Demo.controllers do
+  get("/"){ "Given random #{LibDemo.give_me_a_random}" }
+end
+
+Complex2Demo.controllers do
+end
+
+Padrino.load!

data/lib/middleman/vendor/padrino-core-0.10.5/test/fixtures/apps/simple.rb

@@ -0,0 +1,33 @@
+PADRINO_ROOT = File.dirname(__FILE__) unless defined? PADRINO_ROOT
+# Remove this comment if you want do some like this: ruby PADRINO_ENV=test app.rb
+#
+# require 'rubygems'
+# require 'padrino-core'
+#
+
+class SimpleDemo < Padrino::Application
+  set :reload, true
+  before { true }
+  after  { true }
+  error(404) { "404" }
+end
+
+SimpleDemo.controllers do
+  get "/" do
+    'The magick number is: 2767356926488785838763860464013972991031534522105386787489885890443740254365!' # Change only the number!!!
+  end
+
+  get "/rand" do
+    rand(2 ** 256).to_s
+  end
+end
+
+## If you want use this as a standalone app uncomment:
+#
+# Padrino.mount("SimpleDemo").to("/")
+# Padrino.run! unless Padrino.loaded? # If you enable reloader prevent to re-run the app
+#
+# Then run it from your console: ruby -I"lib" test/fixtures/apps/simple.rb
+#
+
+Padrino.load!

data/lib/middleman/vendor/padrino-core-0.10.5/test/fixtures/dependencies/a.rb

@@ -0,0 +1,9 @@
+# This file will be safe loaded three times.
+# The first one fail because B and C constant are not defined
+# The second one file because B requires C constant so will not be loaded
+# The third one B and C are defined
+
+# But here we need some of b.rb
+A_result = [B, C]
+
+A = "A"

data/lib/middleman/vendor/padrino-core-0.10.5/test/fixtures/dependencies/b.rb

@@ -0,0 +1,4 @@
+# But here we need some of c.rb and a.rb
+B_result = C
+
+B = "B"

data/lib/middleman/vendor/padrino-core-0.10.5/test/fixtures/dependencies/c.rb

@@ -0,0 +1 @@
+C = "C"

data/lib/middleman/vendor/padrino-core-0.10.5/test/fixtures/dependencies/circular/e.rb

@@ -0,0 +1,13 @@
+class E
+  def self.fields
+    @fields ||= []
+  end
+
+  def self.inherited(subclass)
+    subclass.fields.replace fields.dup
+  end
+
+  G
+
+  fields << "name"
+end

data/lib/middleman/vendor/padrino-core-0.10.5/test/fixtures/dependencies/circular/f.rb

@@ -0,0 +1,2 @@
+class F < E
+end

data/lib/middleman/vendor/padrino-core-0.10.5/test/fixtures/dependencies/circular/g.rb

@@ -0,0 +1,2 @@
+class G
+end

data/lib/middleman/vendor/padrino-core-0.10.5/test/fixtures/dependencies/d.rb

@@ -0,0 +1,4 @@
+D  = 0 unless defined?(D)
+D += 1
+
+raise "SomeThing"

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

@@ -0,0 +1,81 @@
+ENV['PADRINO_ENV'] = 'test'
+PADRINO_ROOT = File.dirname(__FILE__) unless defined?(PADRINO_ROOT)
+
+require File.expand_path('../../../load_paths', __FILE__)
+require File.expand_path('../mini_shoulda', __FILE__)
+require 'padrino-core'
+require 'json'
+require 'rack/test'
+require 'rack'
+
+# Rubies < 1.9 don't handle hashes in the properly order so to prevent
+# this issue for now we remove extra values from mimetypes.
+Rack::Mime::MIME_TYPES.delete(".xsl") # In this way application/xml respond only to .xml
+
+class Sinatra::Base
+  # Allow assertions in request context
+  include MiniTest::Assertions
+end
+
+class MiniTest::Spec
+  include Rack::Test::Methods
+
+  # Sets up a Sinatra::Base subclass defined with the block
+  # given. Used in setup or individual spec methods to establish
+  # the application.
+  def mock_app(base=Padrino::Application, &block)
+    @app = Sinatra.new(base, &block)
+  end
+
+  def app
+    Rack::Lint.new(@app)
+  end
+
+  # Asserts that a file matches the pattern
+  def assert_match_in_file(pattern, file)
+    assert File.exist?(file), "File '#{file}' does not exist!"
+    assert_match pattern, File.read(file)
+  end
+
+  # Delegate other missing methods to response.
+  def method_missing(name, *args, &block)
+    if response && response.respond_to?(name)
+      response.send(name, *args, &block)
+    else
+      super(name, *args, &block)
+    end
+  end
+
+  alias :response :last_response
+
+  def create_template(name, content, options={})
+    FileUtils.mkdir_p(File.dirname(__FILE__) + "/views")
+    FileUtils.mkdir_p(File.dirname(__FILE__) + "/views/layouts")
+    path  = "/views/#{name}"
+    path += ".#{options.delete(:locale)}" if options[:locale].present?
+    path += ".#{options[:format]}" if options[:format].present?
+    path += ".erb" unless options[:format].to_s =~ /haml|rss|atom/
+    path += ".builder" if options[:format].to_s =~ /rss|atom/
+    file  = File.dirname(__FILE__) + path
+    File.open(file, 'w') { |io| io.write content }
+    file
+  end
+  alias :create_view   :create_template
+  alias :create_layout :create_template
+
+  def remove_views
+    FileUtils.rm_rf(File.dirname(__FILE__) + "/views")
+  end
+
+  def with_template(name, content, options={})
+    # Build a temp layout
+    template = create_template(name, content, options)
+    yield
+  ensure
+    # Remove temp layout
+    File.unlink(template) rescue nil
+    remove_views
+  end
+  alias :with_view   :with_template
+  alias :with_layout :with_template
+end

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

@@ -0,0 +1,45 @@
+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/vendor/padrino-core-0.10.5/test/test_application.rb

@@ -0,0 +1,108 @@
+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/vendor/padrino-core-0.10.5/test/test_core.rb

@@ -0,0 +1,79 @@
+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, :bundle
+      assert_respond_to Padrino, :configure_apps
+    end
+
+
+    should 'validate global helpers' do
+      assert_equal :test, Padrino.env
+      assert_match /\/test/, Padrino.root
+      assert_equal nil, Padrino.bundle
+      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