i can haz railz 3

vendor/plugins/rails_upgrade/lib/routes_upgrader.rb

@@ -0,0 +1,349 @@
+# TODO: Fix formatting on member/collection methods
+
+module Rails
+  module Upgrading
+    module FakeRouter
+      module ActionController
+        module Routing
+          class Routes
+            def self.setup
+              @redrawer = Rails::Upgrading::RouteRedrawer.new
+            end
+
+            def self.redrawer
+              @redrawer
+            end
+
+            def self.draw
+              yield @redrawer
+            end
+          end
+        end
+      end
+    end
+    
+    class RoutesUpgrader
+      def generate_new_routes
+        if has_routes_file?
+          upgrade_routes
+        else
+          raise FileNotFoundError, "Can't find your routes file [config/routes.rb]!"
+        end
+      end
+      
+      def has_routes_file?
+        File.exists?("config/routes.rb")
+      end
+      
+      def routes_code
+        File.read("config/routes.rb")
+      end
+      
+      def upgrade_routes
+        FakeRouter::ActionController::Routing::Routes.setup
+
+        # Read and eval the file; our fake route mapper will capture
+        # the calls to draw routes and generate new route code
+        FakeRouter.module_eval(routes_code)
+
+        # Give the route set to the code generator and get its output
+        generator = RouteGenerator.new(FakeRouter::ActionController::Routing::Routes.redrawer.routes)
+        generator.generate
+      end
+    end
+    
+    class RouteRedrawer
+      attr_accessor :routes
+
+      def self.stack
+        @stack
+      end
+      
+      def self.stack=(val)
+        @stack = val
+      end
+      
+      def initialize
+        @routes = []
+
+        # The old default route was actually two routes; we generate the new style
+        # one only if we haven't generated it for the first old default route.
+        @default_route_generated = false
+        
+        # Setup the stack for parents; used use proper indentation
+        self.class.stack = [@routes]
+      end
+      
+      def root(options)
+        debug "mapping root"
+        @routes << FakeRoute.new("/", options)
+      end
+      
+      def connect(path, options={})
+        debug "connecting #{path}"
+        
+        if (path == ":controller/:action/:id.:format" || path == ":controller/:action/:id")
+          if !@default_route_generated
+            current_parent << FakeRoute.new("/:controller(/:action(/:id))", {:default_route => true})
+          
+            @default_route_generated = true
+          end
+        else
+          current_parent << FakeRoute.new(path, options)
+        end
+      end
+      
+      def resources(*args)
+        if block_given?
+          parent = FakeResourceRoute.new(args.shift)
+          debug "mapping resources #{parent.name} with block"
+          
+          parent = stack(parent) do
+            yield(self)
+          end
+          
+          current_parent << parent
+        else
+          if args.last.is_a?(Hash)
+            current_parent << FakeResourceRoute.new(args.shift, args.pop)
+            debug "mapping resources #{current_parent.last.name} w/o block with args"
+          else
+            args.each do |a|              
+              current_parent << FakeResourceRoute.new(a)
+              debug "mapping resources #{current_parent.last.name}"
+            end
+          end
+        end
+      end
+      
+      def resource(*args)
+        if block_given?
+          parent = FakeSingletonResourceRoute.new(args.shift)
+          debug "mapping resource #{parent.name} with block"
+          
+          parent = stack(parent) do
+            yield(self)
+          end
+          
+          current_parent << parent
+        else
+          if args.last.is_a?(Hash)
+            current_parent << FakeSingletonResourceRoute.new(args.shift, args.pop)
+            debug "mapping resources #{current_parent.last.name} w/o block with args"
+          else
+            args.each do |a|
+              current_parent << FakeSingletonResourceRoute.new(a)
+              debug "mapping resources #{current_parent.last.name}"
+            end
+          end
+        end
+      end
+      
+      def namespace(name)
+        debug "mapping namespace #{name}"
+        namespace = FakeNamespace.new(name)
+        
+        namespace = stack(namespace) do
+          yield(self)
+        end
+        
+        current_parent << namespace
+      end
+      
+      def method_missing(m, *args)
+        debug "named route: #{m}"
+        current_parent << FakeRoute.new(args.shift, args.pop, m.to_s)
+      end
+      
+      def self.indent
+        ' ' * ((stack.length) * 2)
+      end
+
+    private
+      def debug(txt)
+        puts txt if ENV['DEBUG']
+      end
+      
+      def stack(obj)
+        self.class.stack << obj
+        yield
+        self.class.stack.pop
+      end
+    
+      def current_parent
+        self.class.stack.last
+      end
+    end
+    
+    class RouteObject
+      def indent_lines(code_lines)
+        if code_lines.length > 1
+          code_lines.flatten.map {|l| "#{@indent}#{l.chomp}"}.join("\n") + "\n"
+        else
+          "#{@indent}#{code_lines.shift}"
+        end
+      end
+      
+      def opts_to_string(opts)
+        opts.is_a?(Hash) ? opts.map {|k, v|
+          ":#{k} => " + (v.is_a?(Hash) ? ('{ ' + opts_to_string(v) + ' }') : "#{value_to_string(v)}")
+        }.join(", ") : opts.to_s
+      end
+      
+      def value_to_string(value)
+        case value
+        when Regexp then value.inspect
+        when String then "'" + value.to_s + "'"
+        else value.to_s
+        end
+      end
+    end
+    
+    class FakeNamespace < RouteObject
+      attr_accessor :routes, :name
+      
+      def initialize(name)
+        @routes = []
+        @name = name
+        @indent = RouteRedrawer.indent
+      end
+      
+      def to_route_code
+        lines = ["namespace :#{@name} do", @routes.map {|r| r.to_route_code}, "end"]
+        
+        indent_lines(lines)
+      end
+      
+      def <<(val)
+        @routes << val
+      end
+      
+      def last
+        @routes.last
+      end
+    end
+    
+    class FakeRoute < RouteObject
+      attr_accessor :name, :path, :options
+      
+      def initialize(path, options, name = "")
+        @path = path
+        @options = options || {}
+        @name = name
+        @indent = RouteRedrawer.indent
+      end
+      
+      def to_route_code
+        if @options[:default_route]
+          indent_lines ["match '#{@path}'"]
+        else
+          base = "match '%s' => '%s#%s'"
+          extra_options = []
+        
+          if not name.empty?
+            extra_options << ":as => :#{name}"
+          end
+          
+          if @options[:requirements]
+            @options[:constraints] = @options.delete(:requirements)
+          end
+          
+          if @options[:conditions]
+            @options[:via] = @options.delete(:conditions).delete(:method)
+          end
+        
+          @options ||= {}
+          base = (base % [@path, @options.delete(:controller), (@options.delete(:action) || "index")])
+          opts = opts_to_string(@options)
+          
+          route_pieces = ([base] + extra_options + [opts])
+          route_pieces.delete("")
+          
+          indent_lines [route_pieces.join(", ")]
+        end
+      end
+    end
+    
+    class FakeResourceRoute < RouteObject
+      attr_accessor :name, :children
+      
+      def initialize(name, options = {})
+        @name = name
+        @children = []
+        @options = options
+        @indent = RouteRedrawer.indent
+      end
+      
+      def to_route_code
+        
+        if !@children.empty? || @options.has_key?(:collection) || @options.has_key?(:member)
+          prefix = ["#{route_method} :#{@name} do"]
+          lines = prefix + custom_methods + [@children.map {|r| r.to_route_code}.join("\n"), "end"]
+        
+          indent_lines(lines)
+        else
+          base = "#{route_method} :%s"
+          indent_lines [base % [@name]]
+        end
+      end
+      
+      def custom_methods
+        collection_code = generate_custom_methods_for(:collection)
+        member_code = generate_custom_methods_for(:member)
+        [collection_code, member_code]
+      end
+      
+      def generate_custom_methods_for(group)
+        return "" unless @options[group]
+        
+        method_code = []
+        
+        RouteRedrawer.stack << self
+        @options[group].each do |k, v|
+          method_code << "#{v} :#{k}"
+        end
+        RouteRedrawer.stack.pop
+        
+        indent_lines ["#{group} do", method_code, "end"].flatten
+      end
+      
+      def route_method
+        "resources"
+      end
+      
+      def <<(val)
+        @children << val
+      end
+      
+      def last
+        @children.last
+      end
+    end
+    
+    class FakeSingletonResourceRoute < FakeResourceRoute
+      def route_method
+        "resource"
+      end
+    end
+    
+    class RouteGenerator
+      def initialize(routes)
+        @routes = routes
+        @new_code = ""
+      end
+      
+      def generate
+        @new_code = @routes.map do |r|
+          r.to_route_code
+        end.join("\n")
+        
+        "#{app_name.underscore.classify}::Application.routes.draw do\n#{@new_code}\nend\n"
+      end
+      
+    private
+      def app_name
+        File.basename(Dir.pwd)
+      end
+    end
+  end
+end