merb 0.3.7 → 0.4.0

data/lib/merb/merb_request.rb

@@ -1,165 +0,0 @@
-module Merb
-
-  class Request
-    attr_accessor :env
-    def initialize(env, method, request)
-      @env = env
-      @method = method
-      @request = request
-    end
-    
-    def raw_post
-      @request.rewind
-      @request.read
-    end  
-    
-    # Returns true if the request is an Ajax request.
-    #
-    # Also aliased as the more memorable ajax? and xhr?.
-    def xml_http_request?
-      not /XMLHttpRequest/i.match(@env['HTTP_X_REQUESTED_WITH']).nil?
-    end
-    alias xhr? :xml_http_request?
-    alias ajax? :xml_http_request?
-    
-    # returns the remote IP address if it can find it.
-    def remote_ip
-      return @env['HTTP_CLIENT_IP'] if @env.include?('HTTP_CLIENT_IP')
-    
-      if @env.include?(Merb::Const::HTTP_X_FORWARDED_FOR) then
-        remote_ips = @env[Merb::Const::HTTP_X_FORWARDED_FOR].split(',').reject do |ip|
-          ip =~ /^unknown$|^(127|10|172\.16|192\.168)\./i
-        end
-    
-        return remote_ips.first.strip unless remote_ips.empty?
-      end
-    
-      return @env[Merb::Const::REMOTE_ADDR]
-    end
-    
-    # returns either 'https://' or 'http://' depending on
-    # the HTTPS header
-    def protocol
-      ssl? ? 'https://' : 'http://'
-    end
-    
-    # returns true if the request is an SSL request
-    def ssl?
-      @env['HTTPS'] == 'on' || @env['HTTP_X_FORWARDED_PROTO'] == 'https'
-    end
-    
-    # returns the request HTTP_REFERER.
-    def referer
-      @env['HTTP_REFERER']
-    end
-    
-    # returns he request uri.
-    def uri
-      @env['REQUEST_URI']
-    end
-    
-    def user_agent
-      @env['HTTP_USER_AGENT']
-    end
-
-    def server_name
-      @env['SERVER_NAME']
-    end
-
-    def accept_encoding
-      @env['HTTP_ACCEPT_ENCODING']
-    end
-
-    def script_name
-      @env['SCRIPT_NAME']
-    end
-
-    def cache_control
-      @env['HTTP_CACHE_CONTROL']
-    end
-
-    def accept_language
-      @env['HTTP_ACCEPT_LANGUAGE']
-    end
-
-    def host
-      @env['HTTP_HOST']
-    end
-
-    def server_software
-      @env['SERVER_SOFTWARE']
-    end
-
-    def keep_alive
-      @env['HTTP_KEEP_ALIVE']
-    end
-
-    def accept_charset
-      @env['HTTP_ACCEPT_CHARSET']
-    end
-
-    def version
-      @env['HTTP_VERSION']
-    end
-
-    def gateway
-      @env['GATEWAY_INTERFACE']
-    end
-
-    def accept
-      @env['HTTP_ACCEPT']
-    end
-
-    def connection
-      @env['HTTP_CONNECTION']
-    end
-
-    def query_string
-      @env['QUERY_STRING']  
-    end
-    
-    # returns the uri without the query string.
-    def path
-      uri ? uri.split('?').first : ''
-    end
-    
-    # returns the PATH_INFO
-    def path_info
-      @env['PATH_INFO']
-    end
-    
-    # returns the port the server is running on
-    def port
-      @env['SERVER_PORT'].to_i
-    end
-    
-    # returns the full hostname including port
-    def host
-      @env['HTTP_X_FORWARDED_HOST'] || @env['HTTP_HOST'] 
-    end
-    
-    # returns an array of all the subdomain parts of the host.
-    def subdomains(tld_length = 1)
-      parts = host.split('.')
-      parts[0..-(tld_length+2)]
-    end
-    
-    # returns the full domain name without the port number.
-    def domain(tld_length = 1)
-      host.split('.').last(1 + tld_length).join('.').sub(/:\d+$/,'')
-    end
-    
-    # returns the REQUEST_METHOD
-    def method
-      @method ||= @env['REQUEST_METHOD'].downcase.intern
-    end  
-    
-    # create predicate methods for querying the REQUEST_METHOD
-    [:get, :post, :put, :delete, :head].each do |m|
-      define_method("#{m}?") { method == m.to_sym }
-    end
-  
-  end
-  
-end    
-    

data/lib/merb/merb_router.rb

@@ -1,309 +0,0 @@
-module Merb
-
-  class Router
-    
-    SECTION_REGEXP = /(?::([a-z*_]+))/.freeze
-    
-    class << self
-      
-      def prepare
-        @@matcher = RouteMatcher.new
-        @@generator = RouteGenerator.new
-      
-        yield self
-      
-        @@matcher.compile_router
-      end
-      
-      def add(*route)
-        @@matcher.add(*route)
-      end
-      
-      def matcher
-        @@matcher
-      end
-      
-      def generator
-        @@generator
-      end
-      
-      def match(path)
-        @@matcher.route_request(path)
-      end
-      
-      def generate(method, *args)
-        @@generator.generate(method, *args)
-      end
-      
-      def resources(res, opts={})
-        opts[:prefix] ||= ""
-        if block_given?
-          procs = []
-          yield Resource.new(res, procs, opts)
-          procs.reverse.each &:call
-        else
-          generate_resources_routes(res,opts)
-        end
-      end
-      
-      def resource(res, opts={})
-        opts[:prefix] ||= ""
-        if block_given?
-          procs = []
-          yield Resource.new(res, procs, opts)
-          procs.reverse.each &:call
-        else
-          generate_singleton_routes(res,opts)
-        end
-      end
-      
-      def default_routes(*a)
-        @@matcher.default_routes(*a)
-      end
-      
-      def compiled_statement
-        @@matcher.compiled_statement
-      end
-      
-      def compiled_regexen
-        @@matcher.compiled_regexen
-      end
-        
-      def generate_resources_routes(res, opts)
-        [@@matcher,@@generator].each { |r| r.generate_resources_routes(res, opts) }
-      end
-      
-      def generate_singleton_routes(res, opts)
-        [@@matcher,@@generator].each { |r| r.generate_singleton_routes(res, opts) }
-      end
-
-    end # class << self
-    
-    class RouteMatcher
-      attr_reader :routes, :compiled_statement, :compiled_regexen
-
-      def initialize
-        @routes = Array.new
-        # The final compiled lambda that gets used as the body of the route_request method.
-        @compiled_statement = String.new
-        @compiled_regexen   = Array.new
-      end
-
-      # Add a route to be compiled.
-      def add(*route)
-        opt = Hash === route.last ? route.pop : {}
-        if n = opt[:namespace]
-          path = "/#{n}#{route[0]}" 
-        else
-          path = route[0]
-        end    
-        @routes << [path, opt]
-      end
-      
-      def raw_add(*route)
-        @routes << [route[0], (route[1]||{})]
-      end
-      
-      # Build up a string that defines a lambda that does a case statement on
-      # the PATH_INFO against each of the compiled routes in turn. First route
-      # that matches wins.
-      def compile_router
-        router_lambda = @routes.inject("lambda{|path| \n  sections={}\n  case path\n") { |m,r|
-          m << compile(r)
-        } << "  else\n    return {:controller=>'Noroutefound', :action=>'noroute'}\n  end\n}"
-        @compiled_statement = router_lambda
-        meta_def(:route_request, &eval(router_lambda))
-      end  
-      
-      # Compile each individual route into a when /.../ component of the case
-      # statement. Takes /:sections of the route def that start with : and
-      # turns them into placeholders for whatever urls match against the route
-      # in question.
-      def compile(route)
-        raise ArgumentError unless String === route[0]
-        code, count = '', 0
-        while route[0] =~ Router::SECTION_REGEXP
-          route[0] = route[0].dup
-          name = $1
-          (name =~ /(\*+)(\w+)/) ? (flag = true; name = $2) : (flag = false)
-          count += 1
-          if flag
-            route[0].sub!(Router::SECTION_REGEXP, "([^,?]+)")
-          else  
-            route[0].sub!(Router::SECTION_REGEXP, "([^\/,?]+)")
-          end
-          code << "    sections[:#{name}] = $#{count}\n"
-        end
-        @compiled_regexen << Regexp.new(route[0])
-        index = @compiled_regexen.size - 1
-        condition = "  when @compiled_regexen[#{index}] "
-        statement = "#{condition}\n#{code}"
-        statement << "    return #{route[1].inspect}.update(sections)\n"
-        statement
-      end
-      
-      def generate_resources_routes(res,opt)
-        with_options opt.merge(:controller => res.to_s, :rest => true) do |r|
-          r.raw_add "#{opt[:prefix]}/#{res}/:id[;/]edit", :allowed => {:get => 'edit'}
-          r.raw_add "#{opt[:prefix]}/#{res}/new[;/]:action", :allowed => {:get => 'new', :post => 'new', :put => 'new', :delete => 'new'}
-          r.raw_add "#{opt[:prefix]}/#{res}/new" , :allowed => {:get => 'new'}
-          if mem = opt[:member]
-            mem.keys.sort_by{|x| "#{x}"}.each {|action|
-              allowed = mem[action].injecting({}) {|h, verb| h[verb] = "#{action}"}
-              r.raw_add "#{opt[:prefix]}/#{res}/:id[;/]+#{action}", :allowed => allowed
-            }
-          end
-          if coll = opt[:collection]
-            coll.keys.sort_by{|x| "#{x}"}.each {|action|
-              allowed = coll[action].injecting({}) {|h, verb| h[verb] = "#{action}"}
-              r.raw_add "#{opt[:prefix]}/#{res}[;/]#{action}", :allowed => allowed
-            }
-          end  
-          r.raw_add "#{opt[:prefix]}/#{res}/:id\\.:format", :allowed => {:get => 'show', :put => 'update', :delete => 'destroy'}
-          r.raw_add "#{opt[:prefix]}/#{res}\\.:format", :allowed => {:get => 'index', :post => 'create'}
-          r.raw_add "#{opt[:prefix]}/#{res}/:id", :allowed => {:get => 'show', :put => 'update', :delete => 'destroy'}
-          r.raw_add "#{opt[:prefix]}/#{res}/?", :allowed => {:get => 'index', :post => 'create'}
-        end
-      end
-      
-      def generate_singleton_routes(res,opt)
-        with_options opt.merge(:controller => res.to_s, :rest => true ) do |r|
-          r.raw_add "#{opt[:prefix]}/#{res}[;/]edit", :allowed => {:get => 'edit'}
-          r.raw_add "#{opt[:prefix]}/#{res}\\.:format", :allowed => {:get => 'show'}
-          r.raw_add "#{opt[:prefix]}/#{res}/new" , :allowed => {:get => 'new'}
-          r.raw_add "#{opt[:prefix]}/#{res}/?", :allowed => {:get => 'show', :post => 'create', :put => 'update', :delete => 'destroy'}
-        end
-      end
-      
-      def default_routes(opt={})
-        namespace = opt[:namespace] ? "/#{opt[:namespace]}" : ""
-        with_options opt do |r|
-          r.raw_add namespace + "/:controller/:action/:id\\.:format"
-          r.raw_add namespace + "/:controller/:action/:id"
-          r.raw_add namespace + "/:controller/:action\\.:format"
-          r.raw_add namespace + "/:controller/:action"
-          r.raw_add namespace + "/:controller\\.:format", :action => 'index'
-          r.raw_add namespace + "/:controller", :action => 'index'
-        end  
-      end
-    end
-
-    class RouteGenerator
-
-      attr_accessor :paths
-
-      def initialize
-        @paths = {}
-      end
-
-      def add(name, path)
-        @paths[name.to_sym] = path
-      end
-      
-      def generate(name, *args)
-        options = Hash === args.last ? args.pop : {}
-        obj = args[0]
-        options.each do |key, value|
-          next unless value.respond_to?(:to_param)
-          unless key.to_s =~ /_?id$/
-            old_key = key
-            options[old_key] = value.to_param
-            key = "#{key}_id".intern
-          end
-          options[key] = value.to_param
-        end  
-        
-        path = @paths[name].dup
-        while path =~ Router::SECTION_REGEXP
-          if obj.respond_to?($1) && ! obj.nil?
-            path.sub!(Router::SECTION_REGEXP, obj.send($1).to_s)
-          else  
-            path.sub!(Router::SECTION_REGEXP, options[$1.intern].to_s)
-          end
-        end
-        if f = options[:format]
-          "#{path}.#{f}"
-        else
-          path
-        end   
-      end
-      
-      def generate_singleton_routes(res,opt)
-        res = res.to_s
-        if opt[:namespace]
-          namespace = "#{opt[:namespace]}_"
-          name = "/#{opt[:namespace]}"
-        else
-          namespace = ''
-          name = ''
-        end
-        add namespace + "edit_#{res}", name + "#{opt[:prefix]}/#{res}/edit"
-        add namespace + "new_#{res}", name + "#{opt[:prefix]}/#{res}/new"
-        add namespace + res, name + "#{opt[:prefix]}/#{res}"
-      end
-      
-      def generate_resources_routes(res,opt)
-        res = res.to_s
-        res_singular = res.singularize
-        if opt[:namespace]
-          namespace = "#{opt[:namespace]}_"
-          name = "/#{opt[:namespace]}"
-        else
-          namespace = ''
-          name = ''
-        end  
-        add namespace + res,                    name + "#{opt[:prefix]}/#{res}"
-        add namespace + res_singular,           name + "#{opt[:prefix]}/#{res}/:id"
-        add namespace + "new_#{res_singular}",  name + "#{opt[:prefix]}/#{res}/new"
-        add namespace + "custom_new_#{res_singular}",  name + "#{opt[:prefix]}/#{res}/new/:action"
-        add namespace + "edit_#{res_singular}", name + "#{opt[:prefix]}/#{res}/:id/edit"
-        if mem = opt[:member]
-          mem.keys.sort_by{|x| "#{x}"}.each {|action|
-            add namespace + "#{action}_#{res_singular}", name + "#{opt[:prefix]}/#{res}/:id/#{action}"
-          }
-        end
-        if coll = opt[:collection]
-          coll.keys.sort_by{|x| "#{x}"}.each {|action|
-            add namespace + "#{action}_#{res_singular}", name + "#{opt[:prefix]}/#{res}/#{action}"
-          }
-        end
-      end
-    end
-
-    class Resource
-      
-      def initialize(resource, procs=[], opts={})
-        @resource, @procs, @opts = resource, procs, opts
-        @procs << proc do
-           [::Merb::Router.matcher, ::Merb::Router.generator].each {|r| r.generate_resources_routes(@resource, @opts) } 
-        end
-      end
-
-      def resources(res, opts={})
-        (opts[:prefix]||='') << "/#{@resource}/:#{@resource.to_s.singularize}_id"
-
-        opts[:prefix] = @opts[:prefix] + opts[:prefix]
-        if block_given?
-          yield self.class.new(res, @procs, opts)
-        else
-          @procs << proc do
-             [::Merb::Router.matcher, ::Merb::Router.generator].each {|r| r.generate_resources_routes(res, opts) }
-          end
-        end
-      end
-      
-      def resource(res, opts={})
-        (opts[:prefix]||='') << "/#{@resource}/:#{@resource.to_s.singularize}_id"
-
-        opts[:prefix] = @opts[:prefix] + opts[:prefix]
-        if block_given?
-          yield self.class.new(res, @procs, opts)
-        else
-          @procs << proc do
-             [::Merb::Router.matcher, ::Merb::Router.generator].each { |r| r.generate_singleton_routes(res, opts) }
-          end   
-        end
-      end
-    end
-  end
-end