josh-rack-mount 0.0.1

data/lib/rack/mount/mappers/rails_classic.rb

@@ -0,0 +1,164 @@
+require 'action_controller'
+
+module ActionController
+  module Routing
+    class RouteSet
+      NotFound = lambda { |env|
+        raise RoutingError, "No route matches #{env[::Rack::Mount::Const::PATH_INFO].inspect} with #{env.inspect}"
+      }
+
+      class Dispatcher
+        def initialize(options = {})
+          defaults = options[:defaults]
+          @glob_param = options.delete(:glob)
+          @app = controller(defaults) if bind_controller_const?
+        end
+
+        def call(env)
+          params = env[::Rack::Mount::Const::RACK_ROUTING_ARGS]
+          app = @app || controller(params)
+          merge_default_action!(params)
+          split_glob_param!(params) if @glob_param
+
+          # TODO: Rails response is not finalized by the controller
+          app.call(env).to_a
+        end
+
+        private
+          def bind_controller_const?
+            if defined? Rails
+              Rails.env.production?
+            else
+              true
+            end
+          end
+
+          def controller(params)
+            if params && params.has_key?(:controller)
+              controller = "#{params[:controller].camelize}Controller"
+              ActiveSupport::Inflector.constantize(controller)
+            end
+          end
+
+          def merge_default_action!(params)
+            params[:action] ||= 'index'
+          end
+
+          def split_glob_param!(params)
+            params[@glob_param] = params[@glob_param].split('/')
+          end
+      end
+
+      module RouteExtensions
+        def segment_keys
+          path.names.compact.map(&:to_sym)
+        end
+      end
+
+      class NamedRouteCollection
+        private
+          def generate_optimisation_block(*args)
+          end
+      end
+
+      def draw
+        yield Mapper.new(self)
+        @set.add_route(NotFound, :path => /.*/)
+        install_helpers
+        @set.freeze
+      end
+
+      def clear!
+        routes.clear
+        named_routes.clear
+        @combined_regexp = nil
+        @routes_by_controller = nil
+        @set = ::Rack::Mount::RouteSet.new
+      end
+
+      def add_route(path, options = {})
+        clear! unless @set
+
+        if path.is_a?(String)
+          path = path.gsub('.:format', '(.:format)')
+          path = optionalize_trailing_dynamic_segments(path)
+        end
+
+        if conditions = options.delete(:conditions)
+          method = conditions.delete(:method)
+        end
+
+        name = options.delete(:name)
+
+        requirements = options.delete(:requirements) || {}
+        defaults = {}
+        options.each do |k, v|
+          if v.is_a?(Regexp)
+            requirements[k.to_sym] = options.delete(k)
+          else
+            defaults[k.to_sym] = options.delete(k)
+          end
+        end
+
+        if path.is_a?(String)
+          glob = $1.to_sym if path =~ /\/\*(\w+)$/
+          path = ::Rack::Mount::Utils.convert_segment_string_to_regexp(path, requirements, %w( / . ? ))
+        end
+
+        app = Dispatcher.new(:defaults => defaults, :glob => glob)
+
+        conditions = { :method => method, :path => path }
+        route = @set.add_route(app, conditions, defaults, name)
+        route.extend(RouteExtensions)
+        route
+      end
+
+      def add_named_route(name, path, options = {})
+        options[:name] = name
+        named_routes[name.to_sym] = add_route(path, options)
+      end
+
+      def generate(options, recall = {}, method = :generate)
+        named_route = options.delete(:use_route)
+        expire_on = build_expiry(options, recall)
+        expire_on.each { |k, v| recall.delete(k) unless v }
+        options = recall.merge(options)
+        options.each { |k, v| options[k] = v.to_param }
+        @set.url_for(named_route, options)
+      end
+
+      def url_for(*args)
+        @set.url_for(*args)
+      end
+
+      def call(env)
+        @set.call(env)
+      end
+
+      private
+        def optionalize_trailing_dynamic_segments(path)
+          path = (path =~ /^\//) ? path.dup : "/#{path}"
+          optional, segments = true, []
+
+          old_segments = path.split('/')
+          old_segments.shift
+          length = old_segments.length
+
+          old_segments.reverse.each_with_index do |segment, index|
+            if optional && !(segment =~ /^:\w+$/) && !(segment =~ /^:\w+\(\.:format\)$/)
+              optional = false
+            end
+
+            if optional && index < length - 1
+              segments.unshift('(/', segment)
+              segments.push(')')
+            else
+              segments.unshift('/', segment)
+            end
+          end
+
+          segments.join
+        end
+    end
+  end
+end

data/lib/rack/mount/mappers/rails_draft.rb

@@ -0,0 +1,179 @@
+require 'active_support/inflector'
+
+module Rack
+  module Mount
+    class RouteSet
+      def new_draw(&block)
+        mapper = Mappers::RailsDraft.new(self)
+        mapper.instance_eval(&block)
+        add_route(Mappers::RailsDraft::NotFound, :path => /.*/)
+        freeze
+      end
+    end
+
+    module Mappers
+      class RailsDraft
+        class RoutingError < StandardError; end
+
+        NotFound = lambda { |env|
+          raise RoutingError, "No route matches #{env[Const::PATH_INFO].inspect} with #{env.inspect}"
+        }
+
+        DynamicController = lambda { |env|
+          app = "#{env[Const::RACK_ROUTING_ARGS][:controller].camelize}Controller"
+          app = ActiveSupport::Inflector.constantize(app)
+          app.call(env)
+        }
+
+        def initialize(set)
+          require 'action_controller'
+          @set = set
+          @scope_stack = []
+        end
+
+        def get(path, options = {})
+          match(path, options.merge(:via => :get))
+        end
+
+        def post(path, options = {})
+          match(path, options.merge(:via => :post))
+        end
+
+        def put(path, options = {})
+          match(path, options.merge(:via => :put))
+        end
+
+        def delete(path, options = {})
+          match(path, options.merge(:via => :delete))
+        end
+
+        def match(path, options = {}, &block)
+          if block
+            @scope_stack.push(options.merge({:path => path}))
+            begin
+              instance_eval(&block)
+            ensure
+              @scope_stack.pop
+            end
+
+            return
+          end
+
+          new_options = {}
+          method = options.delete(:via)
+          requirements = options.delete(:constraints) || {}
+          defaults = {}
+
+          if path.is_a?(Symbol) && scope_options.has_key?(:path)
+            defaults[:action] = path.to_s
+            path = scope_options[:path]
+          elsif path.is_a?(Regexp)
+          else
+            scoped_path = @scope_stack.map { |scope| scope[:path] }.compact
+            scoped_path << path if path.is_a?(String)
+            scoped_path.map! { |path| path =~ /^\// ? path : "/#{path}" }
+            path = scoped_path.join
+          end
+
+          if path.is_a?(String)
+            path = optionalize_trailing_dynamic_segments(path)
+          end
+
+          if controller = scope_options[:controller]
+            defaults[:controller] = controller.to_s
+          end
+
+          if to = options.delete(:to)
+            controller, action = to.to_s.split('#')
+
+            if controller && action && defaults[:controller]
+              defaults[:controller] = "#{defaults[:controller]}#{controller}"
+              defaults[:action] = action
+            elsif !action && defaults[:controller]
+              defaults[:action] = controller if controller
+            else
+              defaults[:controller] = controller if controller
+              defaults[:action] = action if action
+            end
+          end
+
+          app = defaults.has_key?(:controller) ?
+            ActiveSupport::Inflector.constantize("#{defaults[:controller].camelize}Controller") :
+            DynamicController
+
+          if path.is_a?(String)
+            path = Utils.convert_segment_string_to_regexp(path, requirements, %w( / . ? ))
+          end
+          conditions = { :method => method, :path => path }
+          @set.add_route(app, conditions, defaults)
+        end
+
+        def controller(controller, &block)
+          @scope_stack.push(:controller => controller)
+          begin
+            instance_eval(&block)
+          ensure
+            @scope_stack.pop
+          end
+        end
+
+        def namespace(namespace, &block)
+          @scope_stack.push(:path => namespace.to_s, :controller => "#{namespace}/")
+          begin
+            instance_eval(&block)
+          ensure
+            @scope_stack.pop
+          end
+        end
+
+        def resources(*entities, &block)
+          options = entities.extract_options!
+          entities.each { |entity| map_resource(entity, options.dup, &block) }
+        end
+
+        private
+          def scope_options
+            options = {}
+            @scope_stack.each { |opts| options.merge!(opts) }
+            options
+          end
+
+          def map_resource(entities, options = {}, &block)
+            resource = ActionController::Resources::Resource.new(entities, options)
+
+            get(resource.path, :to => "#{resource.controller}#index")
+            post(resource.path, :to => "#{resource.controller}#create")
+            get(resource.new_path, :to => "#{resource.controller}#new")
+            get("#{resource.member_path}/edit", :to => "#{resource.controller}#edit")
+            get(resource.member_path, :to => "#{resource.controller}#show")
+            put(resource.member_path, :to => "#{resource.controller}#update")
+            delete(resource.member_path, :to => "#{resource.controller}#destroy")
+          end
+
+          def optionalize_trailing_dynamic_segments(path)
+            path = (path =~ /^\//) ? path.dup : "/#{path}"
+            optional, segments = true, []
+
+            old_segments = path.split('/')
+            old_segments.shift
+            length = old_segments.length
+
+            old_segments.reverse.each_with_index do |segment, index|
+              if optional && !(segment =~ /^:\w+$/) && !(segment =~ /^:\w+\(\.:format\)$/)
+                optional = false
+              end
+
+              if optional && index < length - 1
+                segments.unshift('(/', segment)
+                segments.push(')')
+              else
+                segments.unshift('/', segment)
+              end
+            end
+
+            segments.join
+          end
+      end
+    end
+  end
+end

data/lib/rack/mount/mappers/simple.rb

@@ -0,0 +1,37 @@
+module Rack
+  module Mount
+    class RouteSet
+      def prepare
+        map = Mappers::Simple.new(self)
+        yield map
+        freeze
+      end
+    end
+
+    module Mappers
+      class Simple
+        def initialize(set)
+          @set = set
+        end
+
+        def map(*args)
+          options = args.last.is_a?(Hash) ? args.pop : {}
+
+          app = options[:to]
+          path = args[0]
+          method = args[1]
+          defaults = options[:with]
+
+          requirements = options[:conditions] || {}
+          requirements.each { |k,v| requirements[k] = v.to_s unless v.is_a?(Regexp) }
+
+          if path.is_a?(String)
+            path = Utils.convert_segment_string_to_regexp(path, requirements, %w( / . ? ))
+          end
+          conditions = { :method => method, :path => path }
+          @set.add_route(app, conditions, defaults)
+        end
+      end
+    end
+  end
+end

data/lib/rack/mount/nested_set.rb

@@ -0,0 +1,106 @@
+module Rack
+  module Mount
+    class NestedSet < Hash #:nodoc:
+      class List < Array #:nodoc:
+        def freeze
+          each { |e| e.freeze }
+          super
+        end
+      end
+
+      def initialize(default = List.new)
+        super(default)
+      end
+
+      alias_method :at, :[]
+
+      WILD_REGEXP = /.*/.freeze
+
+      def []=(*args)
+        args  = args.flatten
+        value = args.pop
+        key   = args.shift.freeze
+        key   = WILD_REGEXP if key.nil?
+        keys  = args.freeze
+
+        raise ArgumentError, 'missing value' unless value
+
+        case key
+        when Regexp
+          if keys.empty?
+            each { |k, v| v << value if key =~ k }
+            default << value
+          else
+            each { |k, v| v[keys.dup] = value if key =~ k }
+            self.default = NestedSet.new(default) if default.is_a?(List)
+            default[keys.dup] = value
+          end
+        when String
+          v = at(key)
+          v = v.dup if v.equal?(default)
+
+          if keys.empty?
+            v << value
+          else
+            v = NestedSet.new(v) if v.is_a?(List)
+            v[keys.dup] = value
+          end
+
+          super(key, v)
+        else
+          raise ArgumentError, 'unsupported key'
+        end
+      end
+
+      def [](*keys)
+        result, i = self, 0
+        until result.is_a?(Array)
+          result = result.at(keys[i])
+          i += 1
+        end
+        result
+      end
+
+      def <<(value)
+        values_with_default.each { |e| e << value }
+        nil
+      end
+
+      def values_with_default
+        values.push(default)
+      end
+
+      def inspect
+        super.gsub(/\}$/, ", nil => #{default.inspect}}")
+      end
+
+      def freeze
+        values_with_default.each { |v| v.freeze }
+        super
+      end
+
+      def lists
+        descendants = []
+        values_with_default.each do |v|
+          if v.is_a?(NestedSet)
+            v.lists.each do |descendant|
+              descendants << descendant
+            end
+          else
+            descendants << v
+          end
+        end
+        descendants
+      end
+
+      def height
+        longest_list_descendant.length
+      end
+
+      private
+        def longest_list_descendant
+          lists.max { |a, b| a.length <=> b.length }
+        end
+    end
+  end
+end