http_router 0.8.11 → 0.9.3

data/lib/http_router/node/destination.rb

@@ -1,45 +0,0 @@
-class HttpRouter
-  class Node
-    class Destination < Node
-      attr_reader :blk, :allow_partial, :param_names
-      
-      def initialize(router, parent, blk, allow_partial)
-        @blk, @allow_partial = blk, allow_partial
-        super(router, parent)
-      end
-
-      def usable?(other)
-        other.class == self.class && other.allow_partial == allow_partial && other.blk == blk
-      end
-
-      def to_code
-        path = blk
-        path_ivar = :"@path_#{router.next_counter}"
-        inject_root_ivar(path_ivar, blk)
-        "#{"if request.path_finished?" unless @allow_partial}
-          catch(:pass) do
-            #{"if request.path.size == 1 && request.path.first == '' && (request.rack_request.head? || request.rack_request.get?) && request.rack_request.path_info[-1] == ?/
-              response = ::Rack::Response.new
-              response.redirect(request.rack_request.path_info[0, request.rack_request.path_info.size - 1], 302)
-              throw :success, response.finish
-            end" if @router.redirect_trailing_slash?}
-
-            #{"if request.path.empty?#{" or (request.path.size == 1 and request.path.first == '')" if @router.ignore_trailing_slash?}" unless @allow_partial}
-              if request.perform_call
-                env = request.rack_request.dup.env
-                env['router.request'] = request
-                env['router.params'] ||= {}
-                #{"env['router.params'].merge!(Hash[#{path.param_names.inspect}.zip(request.params)])" if path.dynamic?}
-                #{@allow_partial ? "router.rewrite_partial_path_info(env, request)" : "router.rewrite_path_info(env, request)" }
-                response = @router.process_destination_path(#{path_ivar}, env)
-                router.pass_on_response(response) ? throw(:pass) : throw(:success, response)
-              else
-                throw :success, Response.new(request, #{path_ivar})
-              end
-            #{"end" unless @allow_partial}
-          end
-        #{"end" unless @allow_partial}"
-      end
-    end
-  end
-end

data/lib/http_router/path.rb

@@ -1,58 +0,0 @@
-require 'uri'
-class HttpRouter
-  class Path
-    attr_reader :route, :param_names, :dynamic
-    alias_method :dynamic?, :dynamic
-    def initialize(route, path, param_names = [])
-      @route, @path, @param_names, @dynamic = route, path, param_names, !param_names.empty?
-      duplicate_param_names = param_names.dup.uniq!
-      raise AmbiguousVariableException, "You have duplicate variable name present: #{duplicate_param_names.join(', ')}" if duplicate_param_names
-      if path.respond_to?(:split)
-        regex_parts = path.split(/([:\*][a-zA-Z0-9_]+)/)
-        @path_validation_regex, code = '', ''
-        regex_parts.each_with_index{ |part, index|
-          new_part = case part[0]
-          when ?:, ?*
-            if index != 0 && regex_parts[index - 1][-1] == ?\\
-              @path_validation_regex << Regexp.quote(part)
-              code << part
-            else
-              @path_validation_regex << (route.matches_with[part[1, part.size].to_sym] || '.*?').to_s
-              code << "\#{args.shift || (options && options.delete(:#{part[1, part.size]})) || raise(MissingParameterException, \"missing parameter :#{part[1, part.size]}\")}"
-            end
-          else
-            @path_validation_regex << Regexp.quote(part)
-            code << part
-          end
-          new_part
-        }
-        @path_validation_regex = Regexp.new("^#{@path_validation_regex}$")
-        instance_eval <<-EOT, __FILE__, __LINE__ + 1
-        def raw_url(args,options)
-          \"#{code}\"
-        end
-        EOT
-      end
-    end
-
-    def hashify_params(params)
-      @dynamic && params ? Hash[param_names.zip(params)] : {}
-    end
-
-    def url(args, options)
-      path = raw_url(args, options)
-      raise InvalidRouteException if path !~ @path_validation_regex
-      raise TooManyParametersException unless args.empty?
-      [URI.escape(path), options]
-    end
-
-    def original_path
-      @path
-    end
-
-    private
-    def raw_url(args, options)
-      raise InvalidRouteException
-    end
-  end
-end