sinatra-rabbit 0.0.2 → 0.9

data/lib/sinatra/rabbit/respond_to.rb

@@ -1,247 +0,0 @@
-# respond_to (The MIT License)
-
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this software
-# and associated documentation files (the 'Software'), to deal in the Software without restriction,
-# including without limitation the rights to use, copy, modify, merge, publish, distribute,
-# sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is 
-# furnished to do so, subject to the following conditions:
-#
-# THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT 
-# NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-# DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
-
-require 'rack/accept'
-
-module Sinatra
-
-  module RespondTo
-
-    class MissingTemplate < Sinatra::NotFound; end
-
-    # Define all MIME types you want to support here.
-    # This conversion table will be used for auto-negotiation
-    # with browser in sinatra when no 'format' parameter is specified.
-
-    SUPPORTED_ACCEPT_HEADERS = {
-      :xml => [
-        'text/xml',
-        'application/xml'
-      ],
-      :html => [
-        'text/html',
-        'application/xhtml+xml'
-      ],
-      :json => [
-        'application/json'
-      ]
-    }
-
-    # We need to pass array of available response types to
-    # best_media_type method
-    def accept_to_array
-      SUPPORTED_ACCEPT_HEADERS.keys.collect do |key|
-        SUPPORTED_ACCEPT_HEADERS[key]
-      end.flatten
-    end
-
-    # Then, when we get best media type for response, we need
-    # to know which format to choose
-    def lookup_format_from_mime(mime)
-      SUPPORTED_ACCEPT_HEADERS.keys.each do |format|
-        return format if SUPPORTED_ACCEPT_HEADERS[format].include?(mime)
-      end
-    end
-
-    def self.registered(app)
-
-      app.helpers RespondTo::Helpers
-      use Rack::Accept
-
-      app.before do
-
-        # Skip development error image and static content
-        next if self.class.development? && request.path_info =~ %r{/__sinatra__/.*?.png}
-        next if options.static? && options.public? && (request.get? || request.head?) && static_file?(request.path_info)
-
-        # Remove extension from URI
-        # Extension will be available as a 'extension' method (extension=='txt')
-       
-        extension request.path_info.match(/\.([^\.\/]+)$/).to_a.first
-
-        # If ?format= is present, ignore all Accept negotiations because
-        # we are not dealing with browser
-        if request.params.has_key? 'format'
-          format params['format'].to_sym
-        end
-        
-        # Let's make a little exception here to handle
-        # /api/instance_states[.gv/.png] calls
-        if extension.eql?('gv')
-          format :gv
-        elsif extension.eql?('png')
-          format :png
-        end
-
-        # Get Rack::Accept::Response object and find best possible
-        # mime type to output.
-        # This negotiation works fine with latest rest-client gem:
-        #
-        # RestClient.get 'http://localhost:3001/api', {:accept => :json } =>
-        # 'application/json'
-        # RestClient.get 'http://localhost:3001/api', {:accept => :xml } =>
-        # 'application/xml'
-        #
-        # Also browsers like Firefox (3.6.x) and Chromium reporting
-        # 'application/xml+xhtml' which is recognized as :html reponse
-        # In browser you can force output using ?format=[format] parameter.
-
-        rack_accept = env['rack-accept.request']
-
-        if rack_accept.media_type.to_s.strip.eql?('Accept:')
-          format :xml
-        elsif is_chrome?
-          format :html
-        else
-          format lookup_format_from_mime(rack_accept.best_media_type(accept_to_array))
-        end
-
-      end
-
-      app.class_eval do
-
-        # Simple helper to detect Chrome based browsers
-        # which have screwed up they Accept headers.
-        # Set HTML as default output format here
-        def is_chrome?
-          true if env['HTTP_USER_AGENT'] =~ /Chrome/
-        end
-
-        # This code was copied from respond_to plugin
-        # http://github.com/cehoffman/sinatra-respond_to
-        # MIT License
-        alias :render_without_format :render
-        def render(*args, &block)
-          assumed_layout = args[1] == :layout
-          args[1] = "#{args[1]}.#{format}".to_sym if args[1].is_a?(::Symbol)
-          render_without_format *args, &block
-        rescue Errno::ENOENT => e
-          raise MissingTemplate, "#{args[1]}.#{args[0]}" unless assumed_layout
-          raise e
-        end
-        private :render
-      end
-
-      # This code was copied from respond_to plugin
-      # http://github.com/cehoffman/sinatra-respond_to
-      app.configure :development do |dev|
-        dev.error MissingTemplate do
-          content_type :html, :charset => 'utf-8'
-          response.status = request.env['sinatra.error'].code
-
-          engine = request.env['sinatra.error'].message.split('.').last
-          engine = 'haml' unless ['haml', 'builder', 'erb'].include? engine
-
-          path = File.basename(request.path_info)
-          path = "root" if path.nil? || path.empty?
-
-          format = engine == 'builder' ? 'xml' : 'html'
-
-          layout = case engine
-                   when 'haml' then "!!!\n%html\n  %body= yield"
-                   when 'erb' then "<html>\n  <body>\n    <%= yield %>\n  </body>\n</html>"
-                   end
-
-          layout = "<small>app.#{format}.#{engine}</small>\n<pre>#{escape_html(layout)}</pre>"
-
-          (<<-HTML).gsub(/^ {10}/, '')
-          <!DOCTYPE html>
-          <html>
-          <head>
-            <style type="text/css">
-            body { text-align:center;font-family:helvetica,arial;font-size:22px;
-              color:#888;margin:20px}
-            #c {margin:0 auto;width:500px;text-align:left;}
-            small {float:right;clear:both;}
-            pre {clear:both;text-align:left;font-size:70%;width:500px;margin:0 auto;}
-            </style>
-          </head>
-          <body>
-            <h2>Sinatra can't find #{request.env['sinatra.error'].message}</h2>
-            <img src='/__sinatra__/500.png'>
-            <pre>#{request.env['sinatra.error'].backtrace.join("\n")}</pre>
-            <div id="c">
-              <small>application.rb</small>
-              <pre>#{request.request_method.downcase} '#{request.path_info}' do\n  respond_to do |wants|\n    wants.#{format} { #{engine} :#{path} }\n  end\nend</pre>
-            </div>
-          </body>
-          </html>
-          HTML
-        end
-
-      end
-    end
-
-    module Helpers
-
-      # This code was copied from respond_to plugin
-      # http://github.com/cehoffman/sinatra-respond_to
-      def self.included(klass)
-        klass.class_eval do
-          alias :content_type_without_save :content_type
-          def content_type(*args)
-            content_type_without_save *args
-            @_format = args.first.to_sym
-            response['Content-Type']
-          end
-        end
-      end
-
-      def static_file?(path)
-        public_dir = File.expand_path(options.public)
-        path = File.expand_path(File.join(public_dir, unescape(path)))
-
-        path[0, public_dir.length] == public_dir && File.file?(path)
-      end
-
-
-      # Extension holds trimmed extension. This is extra usefull
-      # when you want to build original URI (with extension)
-      # You can simply call "#{request.env['REQUEST_URI']}.#{extension}"
-      def extension(val=nil)
-        @_extension ||= val
-        @_extension
-      end
-      
-      # This helper will holds current format. Helper should be
-      # accesible from all places in Sinatra
-      def format(val=nil)
-        @_format ||= val
-        @_format
-      end
-
-      def respond_to(&block)
-        wants = {}
-        
-        def wants.method_missing(type, *args, &handler)
-          self[type] = handler
-        end
-        
-        # Set proper content-type and encoding for
-        # text based formats
-        if [:xml, :gv, :html, :json].include?(format)
-          content_type format, :charset => 'utf-8'
-        end
-        yield wants
-        # Raise this error if requested format is not defined
-        # in respond_to { } block.
-        raise MissingTemplate if wants[format].nil?
-
-        wants[format].call
-      end
-
-    end
-
-  end
-end

data/lib/sinatra/rabbit/url_for.rb

@@ -1,53 +0,0 @@
-require 'uri'
-
-module Sinatra
-  module UrlForHelper
-    # Construct a link to +url_fragment+, which should be given relative to
-    # the base of this Sinatra app.  The mode should be either
-    # <code>:path_only</code>, which will generate an absolute path within
-    # the current domain (the default), or <code>:full</code>, which will
-    # include the site name and port number.  (The latter is typically
-    # necessary for links in RSS feeds.)  Example usage:
-    #
-    #   url_for "/"            # Returns "/myapp/"
-    #   url_for "/foo"         # Returns "/myapp/foo"
-    #   url_for "/foo", :full  # Returns "http://example.com/myapp/foo"
-    #--
-    # See README.rdoc for a list of some of the people who helped me clean
-    # up earlier versions of this code.
-    def url_for url_fragment, mode=:path_only
-      case mode
-      when :path_only
-        base = request.script_name
-      when :full
-        scheme = request.scheme
-        if (scheme == 'http' && request.port == 80 ||
-            scheme == 'https' && request.port == 443)
-          port = ""
-        else
-          port = ":#{request.port}"
-        end
-        request_host = HOSTNAME ? HOSTNAME : request.host
-        base = "#{scheme}://#{request_host}#{port}#{request.script_name}"
-      else
-        raise TypeError, "Unknown url_for mode #{mode}"
-      end
-      url_escape = URI.escape(url_fragment)
-      # Don't add the base fragment if url_for gets called more than once
-      # per url or the url_fragment passed in is an absolute url
-      if url_escape.match(/^#{base}/) or url_escape.match(/^http/)
-        url_escape
-      else
-        "#{base}#{url_escape}"
-      end
-    end
-
-    def root_url
-      url_for '/'
-    end
-  end
-
-
-
-  helpers UrlForHelper
-end

data/lib/sinatra/rabbit/validation.rb

@@ -1,75 +0,0 @@
-module Sinatra
-
-  module Rabbit
-
-    module Validation
-      class Failure < StandardError
-        attr_reader :param
-        def initialize(param, msg='')
-          super(msg)
-          @param = param
-        end
-
-        def name
-          param.name
-        end
-      end
-
-      class Param
-        attr_reader :name, :klass, :type, :options, :description
-
-        def initialize(args)
-          @name = args[0]
-          @klass = args[1] || :string
-          @type = args[2] || :optional
-          @options = args[3] || []
-          @description = args[4] || ''
-        end
-
-        def required?
-          type.eql?(:required)
-        end
-
-        def optional?
-          type.eql?(:optional)
-        end
-      end
-
-      def param(*args)
-        raise RabbitDuplicateParamException if params[args[0]]
-        p = Param.new(args)
-        params[p.name] = p
-      end
-
-      def params
-        @params ||= {}
-        @params
-      end
-
-      # Add the parameters in hash +new+ to already existing parameters. If
-      # +new+ contains a parameter with an already existing name, the old
-      # definition is clobbered.
-      def add_params(new)
-        # We do not check for duplication on purpose: multiple calls
-        # to add_params should be cumulative
-        new.each { |p|  @params[p.name] = p }
-      end
-
-      def each_param(&block)
-        params.each_value { |p| yield p }
-      end
-
-      def validate(values)
-        each_param do |p|
-          if p.required? and not values[p.name]
-            raise Failure.new(p, "Required parameter #{p.name} not found")
-          end
-          if values[p.name] and not p.options.empty? and
-              not p.options.include?(values[p.name])
-            raise Failure.new(p, "Parameter #{p.name} has value #{values[p.name]} which is not in #{p.options.join(", ")}")
-          end
-        end
-      end
-    end
-  end
-end