sinatra 0.9.6 → 1.0.a

data/lib/sinatra/compat.rb

@@ -1,258 +0,0 @@
-# Sinatra 0.3.x compatibility module.
-#
-# The following code makes Sinatra 0.9.x compatible with Sinatra 0.3.x to
-# ease the transition to the final 1.0 release. Everything defined in this
-# file will be removed for the 1.0 release.
-
-require 'ostruct'
-require 'sinatra/base'
-require 'sinatra/main'
-
-# Rack now supports evented and swiftiplied mongrels through separate
-# handler.
-if ENV['SWIFT']
-  sinatra_warn 'the SWIFT environment variable is deprecated;',
-    'use Rack::Handler::SwiftipliedMongrel instead.'
-  require 'swiftcore/swiftiplied_mongrel'
-  puts "Using Swiftiplied Mongrel"
-elsif ENV['EVENT']
-  sinatra_warn 'the EVENT environment variable is deprecated;',
-    'use Rack::Handler::EventedMongrel instead.'
-  require 'swiftcore/evented_mongrel'
-  puts "Using Evented Mongrel"
-end
-
-# Make Rack 0.9.0 backward compatibile with 0.4.0 mime types. This isn't
-# technically a Sinatra issue but many Sinatra apps access the old
-# MIME_TYPES constants due to Sinatra example code.
-require 'rack/file'
-module Rack #:nodoc:
-  class File #:nodoc:
-    def self.const_missing(const_name)
-      if const_name == :MIME_TYPES
-        hash = Hash.new { |hash,key| Rack::Mime::MIME_TYPES[".#{key}"] }
-        const_set :MIME_TYPES, hash
-        sinatra_warn 'Rack::File::MIME_TYPES is deprecated; use Rack::Mime instead.'
-        hash
-      else
-        super
-      end
-    end
-  end
-end
-
-module Sinatra
-  module Compat #:nodoc:
-  end
-
-  # Make Sinatra::EventContext an alias for Sinatra::Application to unbreak plugins.
-  def self.const_missing(const_name) #:nodoc:
-    if const_name == :EventContext
-      const_set :EventContext, Sinatra::Application
-      sinatra_warn 'Sinatra::EventContext is deprecated; use Sinatra::Application instead.'
-      Sinatra::Application
-    else
-      super
-    end
-  end
-
-  # The ServerError exception is deprecated. Any exception is considered an
-  # internal server error.
-  class ServerError < RuntimeError
-    def initialize(*args, &block)
-      sinatra_warn 'Sinatra::ServerError is deprecated;',
-        'use another exception, error, or Kernel#fail instead.'
-    end
-    def code ; 500 ; end
-  end
-
-  class Default < Base
-    def self.const_missing(const_name) #:nodoc:
-      if const_name == :FORWARD_METHODS
-        sinatra_warn 'Sinatra::Application::FORWARD_METHODS is deprecated;',
-          'use Sinatra::Delegator::METHODS instead.'
-        const_set :FORWARD_METHODS, Sinatra::Delegator::METHODS
-        Sinatra::Delegator::METHODS
-      else
-        super
-      end
-    end
-
-    # Deprecated. Use: response['Header-Name']
-    def header(header=nil)
-      sinatra_warn "The 'header' method is deprecated; use 'headers' instead."
-      headers(header)
-    end
-
-    # Deprecated. Use: halt
-    def stop(*args, &block)
-      sinatra_warn "The 'stop' method is deprecated; use 'halt' instead."
-      halt(*args, &block)
-    end
-
-    # Deprecated. Use: etag
-    def entity_tag(*args, &block)
-      sinatra_warn "The 'entity_tag' method is deprecated; use 'etag' instead."
-      etag(*args, &block)
-    end
-
-    # Deprecated. Use the #attachment helper and return the data as a String or
-    # Array.
-    def send_data(data, options={})
-      sinatra_warn "The 'send_data' method is deprecated. use attachment, status, content_type, etc. helpers instead."
-
-      status       options[:status]   if options[:status]
-      attachment   options[:filename] if options[:disposition] == 'attachment'
-      content_type options[:type]     if options[:type]
-      halt data
-    end
-
-    # The :views_directory, :options, :haml, and :sass options are deprecated.
-    def render(engine, template, options={}, locals={}, &bk)
-      if options.key?(:views_directory)
-        sinatra_warn "The :views_directory option is deprecated; use :views instead."
-        options[:views] = options.delete(:views_directory)
-      end
-      [:options, engine.to_sym].each do |key|
-        if options.key?(key)
-          sinatra_warn "Passing :#{key} => {} to #{engine} is deprecated; " +
-                       "merge options directly into hash instead."
-          options.merge! options.delete(key)
-        end
-      end
-      super(engine, template, options, locals, &bk)
-    end
-
-    # Throwing halt with a Symbol and the to_result convention are
-    # deprecated. Override the invoke method to detect those types of return
-    # values.
-    def invoke(&block) #:nodoc:
-      res = super
-      case
-      when res.kind_of?(Symbol)
-        sinatra_warn "Invoking the :#{res} helper by returning a Symbol is deprecated;",
-          "call the helper directly instead."
-        @response.body = __send__(res)
-      when res.respond_to?(:to_result)
-        sinatra_warn "The to_result convention is deprecated."
-        @response.body = res.to_result(self)
-      end
-      res
-    end
-
-    def options #:nodoc:
-      Options.new(self.class)
-    end
-
-    class Options < Struct.new(:target) #:nodoc:
-      def method_missing(name, *args, &block)
-        if target.respond_to?(name)
-          target.__send__(name, *args, &block)
-        elsif args.empty? && name.to_s !~ /=$/
-          sinatra_warn 'accessing undefined options will raise a NameError in Sinatra 1.0'
-          nil
-        else
-          super
-        end
-      end
-    end
-
-    class << self
-      # Deprecated. Options are stored directly on the class object.
-      def options
-        sinatra_warn "The 'options' class method is deprecated; use 'self' instead."
-        Options.new(self)
-      end
-
-      # Deprecated. Use: configure
-      def configures(*args, &block)
-        sinatra_warn "The 'configures' method is deprecated; use 'configure' instead."
-        configure(*args, &block)
-      end
-
-      # Deprecated. Use: set
-      def default_options
-        sinatra_warn "Sinatra::Application.default_options is deprecated; use 'set' instead."
-        fake = lambda { |options| set(options) }
-        def fake.merge!(options) ; call(options) ; end
-        fake
-      end
-
-      # Deprecated. Use: set
-      def set_option(*args, &block)
-        sinatra_warn "The 'set_option' method is deprecated; use 'set' instead."
-        set(*args, &block)
-      end
-
-      def set_options(*args, &block)
-        sinatra_warn "The 'set_options' method is deprecated; use 'set' instead."
-        set(*args, &block)
-      end
-
-      # Deprecated. Use: set :environment, ENV
-      def env=(value)
-        sinatra_warn "The :env option is deprecated; use :environment instead."
-        set :environment, value
-      end
-
-      # Deprecated. Use: options.environment
-      def env
-        sinatra_warn "The :env option is deprecated; use :environment instead."
-        environment
-      end
-    end
-
-    # Deprecated. Missing messages are no longer delegated to @response.
-    def method_missing(name, *args, &b) #:nodoc:
-      if @response.respond_to?(name)
-        sinatra_warn "The '#{name}' method is deprecated; use 'response.#{name}' instead."
-        @response.send(name, *args, &b)
-      else
-        super
-      end
-    end
-  end
-
-  class << self
-    # Deprecated. Use: Sinatra::Application
-    def application
-      sinatra_warn "Sinatra.application is deprecated; use Sinatra::Application instead."
-      Sinatra::Application
-    end
-
-    # Deprecated. Use: Sinatra::Application.reset!
-    def application=(value)
-      raise ArgumentError unless value.nil?
-      sinatra_warn "Setting Sinatra.application to nil is deprecated; create a new instance instead."
-      Sinatra.class_eval do
-        remove_const :Application
-        const_set :Application, Class.new(Sinatra::Default)
-      end
-    end
-
-    def build_application
-      sinatra_warn "Sinatra.build_application is deprecated; use Sinatra::Application instead."
-      Sinatra::Application
-    end
-
-    def options
-      sinatra_warn "Sinatra.options is deprecated; use Sinatra::Application.option_name instead."
-      Sinatra::Application.options
-    end
-
-    def port
-      sinatra_warn "Sinatra.port is deprecated; use Sinatra::Application.port instead."
-      options.port
-    end
-
-    def host
-      sinatra_warn "Sinatra.host is deprecated; use Sinatra::Application.host instead."
-      options.host
-    end
-
-    def env
-      sinatra_warn "Sinatra.env is deprecated; use Sinatra::Application.environment instead."
-      options.environment
-    end
-  end
-end

data/lib/sinatra/test.rb

@@ -1,129 +0,0 @@
-require 'sinatra/base'
-
-warn 'Sinatra::Test is deprecated; use Rack::Test instead.'
-
-module Sinatra
-  module Test
-    include Rack::Utils
-
-    def self.included(base)
-      Sinatra::Application.set(:environment, :test)
-    end
-
-    attr_reader :app, :request, :response
-
-    def self.deprecate(framework)
-      warn <<-EOF
-Warning: support for the #{framework} testing framework is deprecated and
-will be dropped in Sinatra 1.0. See <http://sinatra.github.com/testing.html>
-for more information.
-      EOF
-    end
-
-    def make_request(verb, path, body=nil, options={})
-      @app = Sinatra::Application if @app.nil? && defined?(Sinatra::Application)
-      fail "@app not set - cannot make request" if @app.nil?
-
-      @request = Rack::MockRequest.new(@app)
-      options = { :lint => true }.merge(options || {})
-
-      case
-      when body.respond_to?(:to_hash)
-        options.merge! body.delete(:env) if body.key?(:env)
-        options[:content_type] ||= 'application/x-www-form-urlencoded'
-        options[:input] = param_string(body)
-      when body.respond_to?(:to_str)
-        options[:input] = body
-      when body.nil?
-        options[:input] = ''
-      else
-        raise ArgumentError, "body must be a Hash, String, or nil"
-      end
-
-      yield @request if block_given?
-      @response = @request.request(verb, path, rack_options(options))
-    end
-
-    def get(path, *args, &b)  ; make_request('GET', path, *args, &b) ; end
-    def head(path, *args, &b) ; make_request('HEAD', path, *args, &b) ; end
-    def post(path, *args, &b) ; make_request('POST', path, *args, &b) ; end
-    def put(path, *args, &b)  ; make_request('PUT', path, *args, &b) ; end
-    def delete(path, *args, &b) ; make_request('DELETE', path, *args, &b) ; end
-
-    def follow!
-      make_request 'GET', @response.location
-    end
-
-    def body ; @response.body ; end
-    def status ; @response.status ; 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
-      end
-    end
-
-    # Also check @response since we delegate there.
-    def respond_to?(symbol, include_private=false)
-      super || (@response && @response.respond_to?(symbol, include_private))
-    end
-
-  private
-
-    RACK_OPTIONS = {
-      :accept       => 'HTTP_ACCEPT',
-      :agent        => 'HTTP_USER_AGENT',
-      :host         => 'HTTP_HOST',
-      :session      => 'rack.session',
-      :cookies      => 'HTTP_COOKIE',
-      :content_type => 'CONTENT_TYPE'
-    }
-
-    def rack_options(opts)
-      opts.merge(:lint => true).inject({}) do |hash,(key,val)|
-        key = RACK_OPTIONS[key] || key
-        hash[key] = val
-        hash
-      end
-    end
-
-    def param_string(value, prefix = nil)
-      case value
-      when Array
-        value.map { |v|
-          param_string(v, "#{prefix}[]")
-        } * "&"
-      when Hash
-        value.map { |k, v|
-          param_string(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k))
-        } * "&"
-      else
-        "#{prefix}=#{escape(value)}"
-      end
-    end
-
-    if defined? Sinatra::Compat
-      # Deprecated. Use: "get" instead of "get_it".
-      %w(get head post put delete).each do |verb|
-        eval <<-RUBY, binding, __FILE__, __LINE__
-        def #{verb}_it(*args, &block)
-          sinatra_warn "The #{verb}_it method is deprecated; use #{verb} instead."
-          make_request('#{verb.upcase}', *args, &block)
-        end
-        RUBY
-      end
-    end
-  end
-
-  class TestHarness
-    include Test
-
-    def initialize(app=nil)
-      @app = app || Sinatra::Application
-      @app.set(:environment, :test)
-    end
-  end
-end

data/lib/sinatra/test/bacon.rb

@@ -1,19 +0,0 @@
-require 'bacon'
-require 'sinatra/test'
-
-Sinatra::Test.deprecate('Bacon')
-
-Sinatra::Application.set(
-  :environment => :test,
-  :run => false,
-  :raise_errors => true,
-  :logging => false
-)
-
-module Sinatra::Test
-  def should
-    @response.should
-  end
-end
-
-Bacon::Context.send(:include, Sinatra::Test)

data/lib/sinatra/test/rspec.rb

@@ -1,13 +0,0 @@
-require 'sinatra/test'
-require 'sinatra/test/unit'
-require 'spec'
-require 'spec/interop/test'
-
-Sinatra::Test.deprecate('RSpec')
-
-Sinatra::Application.set(
-  :environment => :test,
-  :run => false,
-  :raise_errors => true,
-  :logging => false
-)

data/lib/sinatra/test/spec.rb

@@ -1,11 +0,0 @@
-require 'test/spec'
-require 'sinatra/test'
-require 'sinatra/test/unit'
-
-Sinatra::Test.deprecate('test/spec')
-
-module Sinatra::Test
-  def should
-    @response.should
-  end
-end

data/lib/sinatra/test/unit.rb

@@ -1,13 +0,0 @@
-require 'sinatra/test'
-require 'test/unit'
-
-Sinatra::Test.deprecate('test/unit')
-
-Test::Unit::TestCase.send :include, Sinatra::Test
-
-Sinatra::Application.set(
-  :environment => :test,
-  :run => false,
-  :raise_errors => true,
-  :logging => false
-)