rack_warden 0.0.9 → 0.0.10

data/lib/rack_warden/sinatra/decompile.rb

@@ -0,0 +1,127 @@
+require 'sinatra/base'
+require 'backports'
+require 'uri'
+
+module Sinatra
+
+  # = Sinatra::Decompile
+  #
+  # <tt>Sinatra::Decompile</tt> is an extension that provides a method,
+  # conveniently called +decompile+, that will generate a String pattern for a
+  # given route.
+  #
+  # == Usage
+  #
+  # === Classic Application
+  #
+  # To use the extension in a classic application all you need to do is require
+  # it:
+  #
+  #     require "sinatra"
+  #     require "sinatra/decompile"
+  #
+  #     # Your classic application code goes here...
+  #
+  # This will add the +decompile+ method to the application/class scope, but
+  # you can also call it as <tt>Sinatra::Decompile.decompile</tt>.
+  #
+  # === Modular Application
+  #
+  # To use the extension in a modular application you need to require it, and
+  # then, tell the application you will use it:
+  #
+  #     require "sinatra/base"
+  #     require "sinatra/decompile"
+  #
+  #     class MyApp < Sinatra::Base
+  #       register Sinatra::Decompile
+  #
+  #       # The rest of your modular application code goes here...
+  #     end
+  #
+  # This will add the +decompile+ method to the application/class scope.  You
+  # can choose not to register the extension, but instead of calling
+  # +decompile+, you will need to call <tt>Sinatra::Decompile.decompile</tt>.
+  #
+  module Decompile
+    extend self
+
+    ##
+    # Regenerates a string pattern for a given route
+    #
+    # Example:
+    #
+    #   class Sinatra::Application
+    #     routes.each do |verb, list|
+    #       puts "#{verb}:"
+    #       list.each do |data|
+    #         puts "\t" << decompile(data)
+    #       end
+    #     end
+    #   end
+    #
+    # Will return the internal Regexp if it's unable to reconstruct the pattern,
+    # which likely indicates that a Regexp was used in the first place.
+    #
+    # You can also use this to check whether you could actually use a string
+    # pattern instead of your regexp:
+    #
+    #   decompile /^/foo$/ # => '/foo'
+    def decompile(pattern, keys = nil, *)
+      # Everything in here is basically just the reverse of
+      # Sinatra::Base#compile
+      #
+      # Sinatra 2.0 will come with a mechanism for this, making this obsolete.
+      pattern, keys = pattern if pattern.respond_to? :to_ary
+      keys, str     = keys.try(:dup), pattern.inspect
+      return pattern unless str.start_with? '/' and str.end_with? '/'
+      str.gsub! /^\/(\^|\\A)?|(\$|\\z)?\/$/, ''
+      str.gsub! encoded(' '), ' '
+      return pattern if str =~ /^[\.\+]/
+      str.gsub! '((?:[^\.\/?#%]|(?:%[^2].|%[2][^Ee]))+)', '([^\/?#]+)'
+      str.gsub! '((?:[^\/?#%]|(?:%[^2].|%[2][^Ee]))+)', '([^\/?#]+)'
+      str.gsub! /\([^\(\)]*\)|\([^\(\)]*\([^\(\)]*\)[^\(\)]*\)/ do |part|
+        case part
+        when '(.*?)'
+          return pattern if keys.shift != 'splat'
+          '*'
+        when /^\(\?\:(\\*.)\|%[\w\[\]]+\)$/
+          $1
+        when /^\(\?\:(%\d+)\|([^\)]+|\([^\)]+\))\)$/
+          URI.unescape($1)
+        when '([^\/?#]+)'
+          return pattern if keys.empty?
+          ":" << keys.shift
+        when /^\(\?\:\\?(.)\|/
+          char = $1
+          return pattern unless encoded(char) == part
+          Regexp.escape(char)
+        else
+          return pattern
+        end
+      end
+      str.gsub /(.)([\.\+\(\)\/])/ do
+        return pattern if $1 != "\\"
+        $2
+      end
+    end
+
+    private
+
+    def encoded(char)
+      return super if defined? super
+      enc = uri_parser.escape(char)
+      enc = "(?:#{escaped(char, enc).join('|')})" if enc == char
+      enc = "(?:#{enc}|#{encoded('+')})" if char == " "
+      enc
+    end
+
+    def uri_parser
+      #TODO: Remove check after dropping support for 1.8.7
+      @_uri_parser ||= defined?(URI::Parser) ? URI::Parser.new : URI
+    end
+
+  end
+
+  #register Decompile
+end

data/lib/rack_warden/sinatra/json.rb

@@ -0,0 +1,131 @@
+require 'sinatra/base'
+require 'multi_json'
+module Sinatra
+
+  # = Sinatra::JSON
+  #
+  # <tt>Sinatra::JSON</tt> adds a helper method, called +json+, for (obviously)
+  # json generation.
+  #
+  # == Usage
+  #
+  # === Classic Application
+  #
+  # In a classic application simply require the helper, and start using it:
+  #
+  #     require "sinatra"
+  #     require "sinatra/json"
+  #
+  #     # define a route that uses the helper
+  #     get '/' do
+  #       json :foo => 'bar'
+  #     end
+  #
+  #     # The rest of your classic application code goes here...
+  #
+  # === Modular Application
+  #
+  # In a modular application you need to require the helper, and then tell the
+  # application you will use it:
+  #
+  #     require "sinatra/base"
+  #     require "sinatra/json"
+  #
+  #     class MyApp < Sinatra::Base
+  #
+  #       # define a route that uses the helper
+  #       get '/' do
+  #         json :foo => 'bar'
+  #       end
+  #
+  #       # The rest of your modular application code goes here...
+  #     end
+  #
+  # === Encoders
+  #
+  # By default it will try to call +to_json+ on the object, but if it doesn't
+  # respond to that message, it will use its own rather simple encoder.  You can
+  # easily change that anyways. To use +JSON+, simply require it:
+  #
+  #   require 'json'
+  #
+  # The same goes for <tt>Yajl::Encoder</tt>:
+  #
+  #   require 'yajl'
+  #
+  # For other encoders, besides requiring them, you need to define the
+  # <tt>:json_encoder</tt> setting.  For instance, for the +Whatever+ encoder:
+  #
+  #   require 'whatever'
+  #   set :json_encoder, Whatever
+  #
+  # To force +json+ to simply call +to_json+ on the object:
+  #
+  #   set :json_encoder, :to_json
+  #
+  # Actually, it can call any method:
+  #
+  #   set :json_encoder, :my_fancy_json_method
+  #
+  # === Content-Type
+  #
+  # It will automatically set the content type to "application/json".  As
+  # usual, you can easily change that, with the <tt>:json_content_type</tt>
+  # setting:
+  #
+  #   set :json_content_type, :js
+  #
+  # === Overriding the Encoder and the Content-Type
+  #
+  # The +json+ helper will also take two options <tt>:encoder</tt> and
+  # <tt>:content_type</tt>.  The values of this options are the same as the
+  # <tt>:json_encoder</tt> and <tt>:json_content_type</tt> settings,
+  # respectively.  You can also pass those to the json method:
+  #
+  #   get '/'  do
+  #     json({:foo => 'bar'}, :encoder => :to_json, :content_type => :js)
+  #   end
+  #
+  module JSON
+    class << self
+      def encode(object)
+        ::MultiJson.dump(object)
+      end
+    end
+
+    def json(object, options = {})
+      content_type resolve_content_type(options)
+      resolve_encoder_action  object, resolve_encoder(options)
+    end
+
+    private
+
+    def resolve_content_type(options = {})
+      options[:content_type] || settings.json_content_type
+    end
+
+    def resolve_encoder(options = {})
+      options[:json_encoder] || settings.json_encoder
+    end
+
+    def resolve_encoder_action(object, encoder)
+      [:encode, :generate].each do |method|
+        return encoder.send(method, object) if encoder.respond_to? method
+      end
+      if encoder.is_a? Symbol
+        object.__send__(encoder)
+      else 
+        fail "#{encoder} does not respond to #generate nor #encode"
+      end #if
+    end #resolve_encoder_action  
+  end #JSON
+
+  Base.set :json_encoder do
+    ::MultiJson
+  end
+
+  Base.set :json_content_type, :json
+
+  # Load the JSON helpers in modular style automatically
+  Base.helpers JSON
+end

data/lib/rack_warden/sinatra/namespace.rb

@@ -0,0 +1,285 @@
+require 'backports'
+require 'sinatra/base'
+require 'rack_warden/sinatra/decompile'
+
+module RackWarden
+App.logger.debug "RW loading Namespace"
+
+  # = Sinatra::Namespace
+  #
+  # <tt>Sinatra::Namespace</tt> is an extension that adds namespaces to an
+  # application.  This namespaces will allow you to share a path prefix for the
+  # routes within the namespace, and define filters, conditions and error
+  # handlers exclusively for them.  Besides that, you can also register helpers
+  # and extensions that will be used only within the namespace.
+  #
+  # == Usage
+  #
+  # Once you have loaded the extension (see below), you can use the +namespace+
+  # method to define namespaces in your application.
+  #
+  # You can define a namespace by a path prefix:
+  #
+  #     namespace '/blog' do
+  #       get { haml :blog }
+  #       get '/:entry_permalink' do
+  #         @entry = Entry.find_by_permalink!(params[:entry_permalink])
+  #         haml :entry
+  #       end
+  #
+  #       # More blog routes...
+  #     end
+  #
+  # by a condition:
+  #
+  #     namespace :host_name => 'localhost' do
+  #       get('/admin/dashboard') { haml :dashboard }
+  #       get('/admin/login')     { haml :login }
+  #
+  #       # More admin routes...
+  #     end
+  #
+  # or both:
+  #
+  #     namespace '/admin', :host_name => 'localhost' do
+  #       get('/dashboard')  { haml :dashboard }
+  #       get('/login')      { haml :login }
+  #       post('/login')     { login_user }
+  #
+  #       # More admin routes...
+  #     end
+  #
+  # When you define a filter or an error handler, or register an extension or a
+  # set of helpers within a namespace, they only affect the routes defined in
+  # it.  For instance, lets define a before filter to prevent the access of
+  # unauthorized users to the admin section of the application:
+  #
+  #     namespace '/admin' do
+  #       helpers AdminHelpers
+  #       before  { authenticate unless request.path_info == '/admin/login' }
+  #
+  #       get '/dashboard' do
+  #         # Only authenticated users can access here...
+  #         haml :dashboard
+  #       end
+  #
+  #       # More admin routes...
+  #     end
+  #
+  #     get '/' do
+  #       # Any user can access here...
+  #       haml :index
+  #     end
+  #
+  # Well, they actually also affect the nested namespaces:
+  #
+  #     namespace '/admin' do
+  #       helpers AdminHelpers
+  #       before  { authenticate unless request.path_info == '/admin/login' }
+  #
+  #       namespace '/users' do
+  #         get do
+  #           # Only authenticated users can access here...
+  #           @users = User.all
+  #           haml :users
+  #         end
+  #
+  #         # More user admin routes...
+  #       end
+  #
+  #       # More admin routes...
+  #     end
+  #
+  # === Classic Application Setup
+  #
+  # To be able to use namespaces in a classic application all you need to do is
+  # require the extension:
+  #
+  #     require "sinatra"
+  #     require "sinatra/namespace"
+  #
+  #     # The rest of your classic application code goes here...
+  #
+  # === Modular Application Setup
+  #
+  # To be able to use namespaces in a modular application all you need to do is
+  # require the extension, and then, register it:
+  #
+  #     require "sinatra/base"
+  #     require "sinatra/namespace"
+  #
+  #     class MyApp < Sinatra::Base
+  #       register Sinatra::Namespace
+  #
+  #       # The rest of your modular application code goes here...
+  #     end
+  #
+  module Namespace
+    def self.new(base, pattern, conditions = {}, &block)
+      Module.new do
+        extend NamespacedMethods
+        include InstanceMethods
+        @base, @extensions, @errors = base, [], {}
+        @pattern, @conditions = compile(pattern, conditions)
+        @templates            = Hash.new { |h,k| @base.templates[k] }
+        namespace = self
+        before { extend(@namespace = namespace) }
+        class_eval(&block)
+      end
+    end
+
+    module InstanceMethods
+      def settings
+        @namespace
+      end
+
+      def template_cache
+        super.fetch(:nested, @namespace) { Tilt::Cache.new }
+      end
+    end
+
+    module SharedMethods
+      def namespace(pattern, conditions = {}, &block)
+        Namespace.new(self, pattern, conditions, &block)
+      end
+    end
+
+    module NamespacedMethods
+      include SharedMethods
+      include Sinatra::Decompile
+      attr_reader :base, :templates
+
+      def self.prefixed(*names)
+        names.each { |n| define_method(n) { |*a, &b| prefixed(n, *a, &b) }}
+      end
+
+      prefixed :before, :after, :delete, :get, :head, :options, :patch, :post, :put
+
+      def helpers(*extensions, &block)
+        class_eval(&block) if block_given?
+        include(*extensions) if extensions.any?
+      end
+
+      def register(*extensions, &block)
+        extensions << Module.new(&block) if block_given?
+        @extensions += extensions
+        extensions.each do |extension|
+          extend extension
+          extension.registered(self) if extension.respond_to?(:registered)
+        end
+      end
+
+      def invoke_hook(name, *args)
+        @extensions.each { |e| e.send(name, *args) if e.respond_to?(name) }
+      end
+
+      def not_found(&block)
+        error(404, &block)
+      end
+
+      def errors
+        base.errors.merge(namespace_errors)
+      end
+
+      def namespace_errors
+        @errors
+      end
+
+      def error(*codes, &block)
+        args  = Sinatra::Base.send(:compile!, "ERROR", /^#{@pattern}/, block)
+        codes = codes.map { |c| Array(c) }.flatten
+        codes << Exception if codes.empty?
+        codes.each do |c|
+          errors = @errors[c] ||= []
+          errors << args
+        end
+      end
+
+      def respond_to(*args)
+        return @conditions[:provides] || base.respond_to if args.empty?
+        @conditions[:provides] = args
+      end
+
+      def set(key, value = self, &block)
+        raise ArgumentError, "may not set #{key}" if key != :views
+        return key.each { |k,v| set(k, v) } if block.nil? and value == self
+        block ||= proc { value }
+        singleton_class.send(:define_method, key, &block)
+      end
+
+      def enable(*opts)
+        opts.each { |key| set(key, true) }
+      end
+
+      def disable(*opts)
+        opts.each { |key| set(key, false) }
+      end
+
+      def template(name, &block)
+        filename, line = caller_locations.first
+        templates[name] = [block, filename, line.to_i]
+      end
+
+      def layout(name=:layout, &block)
+        template name, &block
+      end
+
+      private
+
+      def app
+        base.respond_to?(:base) ? base.base : base
+      end
+
+      def compile(pattern, conditions, default_pattern = nil)
+        if pattern.respond_to? :to_hash
+          conditions = conditions.merge pattern.to_hash
+          pattern = nil
+        end
+        base_pattern, base_conditions = @pattern, @conditions
+        pattern         ||= default_pattern
+        base_pattern    ||= base.pattern    if base.respond_to? :pattern
+        base_conditions ||= base.conditions if base.respond_to? :conditions
+        [ prefixed_path(base_pattern, pattern),
+          (base_conditions || {}).merge(conditions) ]
+      end
+
+      def prefixed_path(a, b)
+        return a || b || // unless a and b
+        a, b = decompile(a), decompile(b) unless a.class == b.class
+        a, b = regexpify(a), regexpify(b) unless a.class == b.class
+        path = a.class.new "#{a}#{b}"
+        path = /^#{path}$/ if path.is_a? Regexp and base == app
+        path
+      end
+
+      def regexpify(pattern)
+        pattern = Sinatra::Base.send(:compile, pattern).first.inspect
+        pattern.gsub! /^\/(\^|\\A)?|(\$|\\Z)?\/$/, ''
+        Regexp.new pattern
+      end
+
+      def prefixed(method, pattern = nil, conditions = {}, &block)
+        default = '*' if method == :before or method == :after
+        pattern, conditions = compile pattern, conditions, default
+        result = base.send(method, pattern, conditions, &block)
+        invoke_hook :route_added, method.to_s.upcase, pattern, block
+        result
+      end
+
+      def method_missing(method, *args, &block)
+        base.send(method, *args, &block)
+      end
+    end
+
+    module BaseMethods
+      include SharedMethods
+    end
+
+    def self.extend_object(base)
+      base.extend BaseMethods
+    end
+  end
+
+  #register Sinatra::Namespace
+  #Delegator.delegate :namespace
+end