rack-mount 0.6.1 → 0.6.2

data/lib/rack/mount/vendor/reginald/reginald/tokenizer.rb

@@ -140,7 +140,7 @@ class Parser < Racc::Parser
          action { [:NEGATE, text] }
 
       when (text = @ss.scan(/:(alnum|alpha|ascii|blank|cntrl|digit|graph|lower|print|punct|space|upper|word|xdigit):/))
-         action { [@ss[1], text] }
+         action { [:CTYPE, text] }
 
       when (text = @ss.scan(/\\-/))
          action { [:CHAR, text] }

data/lib/rack/mount/vendor/reginald/reginald/version.rb

@@ -0,0 +1,3 @@
+module Reginald
+  Version = '0.2.0'
+end

data/lib/rack/mount/version.rb

@@ -1,3 +1,3 @@
 module Rack::Mount
-  Version = '0.6.1'
+  Version = '0.6.2'
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 6
-  - 1
-  version: 0.6.1
+  - 2
+  version: 0.6.2
 platform: ruby
 authors: 
 - Joshua Peek
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-06 00:00:00 -06:00
+date: 2010-04-13 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
@@ -32,16 +32,10 @@ files:
 - lib/rack/mount/analysis/frequency.rb
 - lib/rack/mount/analysis/histogram.rb
 - lib/rack/mount/analysis/splitting.rb
-- lib/rack/mount/exceptions.rb
+- lib/rack/mount/code_generation.rb
 - lib/rack/mount/generatable_regexp.rb
-- lib/rack/mount/generation/route.rb
-- lib/rack/mount/generation/route_set.rb
-- lib/rack/mount/mixover.rb
 - lib/rack/mount/multimap.rb
 - lib/rack/mount/prefix.rb
-- lib/rack/mount/recognition/code_generation.rb
-- lib/rack/mount/recognition/route.rb
-- lib/rack/mount/recognition/route_set.rb
 - lib/rack/mount/regexp_with_named_groups.rb
 - lib/rack/mount/route.rb
 - lib/rack/mount/route_set.rb
@@ -63,8 +57,10 @@ files:
 - lib/rack/mount/vendor/reginald/reginald/collection.rb
 - lib/rack/mount/vendor/reginald/reginald/expression.rb
 - lib/rack/mount/vendor/reginald/reginald/group.rb
+- lib/rack/mount/vendor/reginald/reginald/options.rb
 - lib/rack/mount/vendor/reginald/reginald/parser.rb
 - lib/rack/mount/vendor/reginald/reginald/tokenizer.rb
+- lib/rack/mount/vendor/reginald/reginald/version.rb
 - lib/rack/mount/version.rb
 has_rdoc: true
 homepage: http://github.com/josh/rack-mount

data/lib/rack/mount/exceptions.rb

@@ -1,3 +0,0 @@
-module Rack::Mount
-  class RoutingError < StandardError; end
-end

data/lib/rack/mount/generation/route.rb

@@ -1,59 +0,0 @@
-require 'rack/mount/utils'
-
-module Rack::Mount
-  module Generation
-    module Route #:nodoc:
-      def initialize(*args)
-        super
-
-        @has_significant_params = @conditions.any? { |method, condition|
-          (condition.respond_to?(:required_params) && condition.required_params.any?) ||
-            (condition.respond_to?(:required_defaults) && condition.required_defaults.any?)
-        }
-      end
-
-      def generation_keys
-        @conditions.inject({}) { |keys, (method, condition)|
-          if condition.respond_to?(:required_defaults)
-            keys.merge!(condition.required_defaults)
-          else
-            keys
-          end
-        }
-      end
-
-      def significant_params?
-        @has_significant_params
-      end
-
-      def generate(method, params = {}, recall = {}, options = {})
-        if method.nil?
-          result = @conditions.inject({}) { |h, (method, condition)|
-            if condition.respond_to?(:generate)
-              h[method] = condition.generate(params, recall, options)
-            end
-            h
-          }
-          return nil if result.values.compact.empty?
-        else
-          result = generate_method(method, params, recall, options)
-        end
-
-        if result
-          @defaults.each do |key, value|
-            params.delete(key) if params[key] == value
-          end
-        end
-
-        result
-      end
-
-      private
-        def generate_method(method, params, recall, options)
-          if condition = @conditions[method]
-            condition.generate(params, recall, options)
-          end
-        end
-    end
-  end
-end

data/lib/rack/mount/generation/route_set.rb

@@ -1,200 +0,0 @@
-require 'rack/mount/utils'
-require 'forwardable'
-
-module Rack::Mount
-  module Generation
-    module RouteSet
-      # Adds generation related concerns to RouteSet.new.
-      def initialize(*args)
-        @named_routes = {}
-        @generation_key_analyzer = Analysis::Frequency.new
-
-        super
-      end
-
-      # Adds generation aspects to RouteSet#add_route.
-      def add_route(*args)
-        route = super
-        @named_routes[route.name] = route if route.name
-        @generation_key_analyzer << route.generation_keys
-        route
-      end
-
-      # Generates a url from Rack env and identifiers or significant keys.
-      #
-      # To generate a url by named route, pass the name in as a +Symbol+.
-      #   url(env, :dashboard) # => "/dashboard"
-      #
-      # Additional parameters can be passed in as a hash
-      #   url(env, :people, :id => "1") # => "/people/1"
-      #
-      # If no name route is given, it will fall back to a slower
-      # generation search.
-      #   url(env, :controller => "people", :action => "show", :id => "1")
-      #     # => "/people/1"
-      def url(env, *args)
-        named_route, params = nil, {}
-
-        case args.length
-        when 2
-          named_route, params = args[0], args[1].dup
-        when 1
-          if args[0].is_a?(Hash)
-            params = args[0].dup
-          else
-            named_route = args[0]
-          end
-        else
-          raise ArgumentError
-        end
-
-        only_path = params.delete(:only_path)
-        recall = env[@parameters_key] || {}
-
-        unless result = generate(:all, named_route, params, recall,
-            :parameterize => lambda { |name, param| Utils.escape_uri(param) })
-          return
-        end
-
-        parts, params = result
-        return unless parts
-
-        params.each do |k, v|
-          if v
-            params[k] = v
-          else
-            params.delete(k)
-          end
-        end
-
-        req = stubbed_request_class.new(env)
-        req._stubbed_values = parts.merge(:query_string => Utils.build_nested_query(params))
-        only_path ? req.fullpath : req.url
-      end
-
-      def generate(method, *args) #:nodoc:
-        raise 'route set not finalized' unless @generation_graph
-
-        method = nil if method == :all
-        named_route, params, recall, options = extract_params!(*args)
-        merged = recall.merge(params)
-        route = nil
-
-        if named_route
-          if route = @named_routes[named_route.to_sym]
-            recall = route.defaults.merge(recall)
-            url = route.generate(method, params, recall, options)
-            [url, params]
-          else
-            raise RoutingError, "#{named_route} failed to generate from #{params.inspect}"
-          end
-        else
-          keys = @generation_keys.map { |key|
-            if k = merged[key]
-              k.to_s
-            else
-              nil
-            end
-          }
-          @generation_graph[*keys].each do |r|
-            next unless r.significant_params?
-            if url = r.generate(method, params, recall, options)
-              return [url, params]
-            end
-          end
-
-          raise RoutingError, "No route matches #{params.inspect}"
-        end
-      end
-
-      def rehash #:nodoc:
-        @generation_keys  = build_generation_keys
-        @generation_graph = build_generation_graph
-
-        super
-      end
-
-      private
-        def expire!
-          @generation_keys = @generation_graph = nil
-          @generation_key_analyzer.expire!
-          super
-        end
-
-        def flush!
-          @generation_key_analyzer = nil
-          super
-        end
-
-        def build_generation_graph
-          build_nested_route_set(@generation_keys) { |k, i|
-            throw :skip unless @routes[i].significant_params?
-
-            if k = @generation_key_analyzer.possible_keys[i][k]
-              k.to_s
-            else
-              nil
-            end
-          }
-        end
-
-        def build_generation_keys
-          @generation_key_analyzer.report
-        end
-
-        def extract_params!(*args)
-          case args.length
-          when 4
-            named_route, params, recall, options = args
-          when 3
-            if args[0].is_a?(Hash)
-              params, recall, options = args
-            else
-              named_route, params, recall = args
-            end
-          when 2
-            if args[0].is_a?(Hash)
-              params, recall = args
-            else
-              named_route, params = args
-            end
-          when 1
-            if args[0].is_a?(Hash)
-              params = args[0]
-            else
-              named_route = args[0]
-            end
-          else
-            raise ArgumentError
-          end
-
-          named_route ||= nil
-          params  ||= {}
-          recall  ||= {}
-          options ||= {}
-
-          [named_route, params.dup, recall.dup, options.dup]
-        end
-
-        def instance_variables_to_serialize
-          super - [:@stubbed_request_class]
-        end
-
-        def stubbed_request_class
-          @stubbed_request_class ||= begin
-            klass = Class.new(@request_class)
-            klass.public_instance_methods.each do |method|
-              next if method =~ /^__|object_id/
-              klass.class_eval <<-RUBY
-                def #{method}(*args, &block)
-                  @_stubbed_values[:#{method}] || super
-                end
-              RUBY
-            end
-            klass.class_eval { attr_accessor :_stubbed_values }
-            klass
-          end
-        end
-    end
-  end
-end

data/lib/rack/mount/mixover.rb

@@ -1,60 +0,0 @@
-module Rack::Mount
-  # A mixin that changes the behavior of +include+. Instead of modules
-  # being chained as a superclass, they are mixed into the objects
-  # metaclass. This allows mixins to be stacked ontop of the instance
-  # methods.
-  module Mixover
-    def self.extended(klass)
-      klass.instance_eval do
-        @extended_modules = []
-      end
-    end
-
-    module InstanceMethods #:nodoc:
-      def dup
-        obj = super
-        included_modules = (class << self; included_modules; end) - (class << obj; included_modules; end)
-        included_modules.reverse.each { |mod| obj.extend(mod) }
-        obj
-      end
-    end
-
-    # Replaces include with a lazy version.
-    def include(*mod)
-      extended_modules.push(*mod)
-    end
-
-    def extended_modules
-      Thread.current[extended_modules_thread_local_key] || @extended_modules
-    end
-
-    def new(*args, &block) #:nodoc:
-      obj = allocate
-      obj.extend(InstanceMethods)
-      extended_modules.each { |mod| obj.extend(mod) }
-      obj.send(:initialize, *args, &block)
-      obj
-    end
-
-    # Create a new class without an included module.
-    def new_without_module(mod, *args, &block)
-      (Thread.current[extended_modules_thread_local_key] = extended_modules.dup).delete(mod)
-      new(*args, &block)
-    ensure
-      Thread.current[extended_modules_thread_local_key] = nil
-    end
-
-    # Create a new class temporarily with a module.
-    def new_with_module(mod, *args, &block)
-      (Thread.current[extended_modules_thread_local_key] = extended_modules.dup).push(*mod)
-      new(*args, &block)
-    ensure
-      Thread.current[extended_modules_thread_local_key] = nil
-    end
-
-    private
-      def extended_modules_thread_local_key
-        "mixover_extended_modules_#{object_id}"
-      end
-  end
-end

data/lib/rack/mount/recognition/code_generation.rb

@@ -1,124 +0,0 @@
-module Rack::Mount
-  module Recognition
-    module CodeGeneration #:nodoc:
-      def initialize(*args)
-        @optimized_recognize_defined = false
-        super
-      end
-
-      def _expired_recognize(env) #:nodoc:
-        raise 'route set not finalized'
-      end
-
-      def rehash
-        super
-        optimize_recognize!
-      end
-
-      private
-        def instance_variables_to_serialize
-          super - [:@optimized_recognize_defined]
-        end
-
-        def expire!
-          if @optimized_recognize_defined
-            remove_metaclass_method :recognize
-
-            class << self
-              alias_method :recognize, :_expired_recognize
-            end
-
-            @optimized_recognize_defined = false
-          end
-
-          super
-        end
-
-        def optimize_container_iterator(container)
-          body = []
-
-          container.each_with_index { |route, i|
-            body << "route = self[#{i}]"
-            body << 'matches = {}'
-            body << 'params = route.defaults.dup'
-
-            conditions = []
-            route.conditions.each do |method, condition|
-              b = []
-              if condition.is_a?(Regexp)
-                b << "if m = obj.#{method}.match(#{condition.inspect})"
-                b << "matches[:#{method}] = m"
-                if (named_captures = route.named_captures[method]) && named_captures.any?
-                  b << 'captures = m.captures'
-                  b << 'p = nil'
-                  b << named_captures.map { |k, j| "params[#{k.inspect}] = p if p = captures[#{j}]" }.join('; ')
-                end
-              else
-                b << "if m = obj.#{method} == route.conditions[:#{method}]"
-              end
-              b << 'true'
-              b << 'end'
-              conditions << "(#{b.join('; ')})"
-            end
-
-            body << <<-RUBY
-              if #{conditions.join(' && ')}
-                yield route, matches, params
-              end
-            RUBY
-          }
-
-          container.instance_eval(<<-RUBY, __FILE__, __LINE__)
-            def optimized_each(obj)
-              #{body.join("\n")}
-              nil
-            end
-          RUBY
-        end
-
-        def optimize_recognize!
-          keys = @recognition_keys.map { |key|
-            if key.respond_to?(:call_source)
-              key.call_source(:cache, :obj)
-            else
-              "obj.#{key}"
-            end
-          }.join(', ')
-
-          @optimized_recognize_defined = true
-
-          remove_metaclass_method :recognize
-
-          instance_eval(<<-RUBY, __FILE__, __LINE__)
-            def recognize(obj)
-              cache = {}
-              container = @recognition_graph[#{keys}]
-              optimize_container_iterator(container) unless container.respond_to?(:optimized_each)
-
-              if block_given?
-                container.optimized_each(obj) do |route, matches, params|
-                  yield route, matches, params
-                end
-              else
-                container.optimized_each(obj) do |route, matches, params|
-                  return route, matches, params
-                end
-              end
-
-              nil
-            end
-          RUBY
-        end
-
-        # method_defined? can't distinguish between instance
-        # and meta methods. So we have to rescue if the method
-        # has not been defined in the metaclass yet.
-        def remove_metaclass_method(symbol)
-          metaclass = class << self; self; end
-          metaclass.send(:remove_method, symbol)
-        rescue NameError => e
-          nil
-        end
-    end
-  end
-end