refactoring 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+*.swp

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in refactoring.gemspec
+gemspec

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/generators/refactoring/refactorization/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Explain the generator
+
+Example:
+    rails generate refactoring Thing
+
+    This will create:
+        what/will/it/create

data/lib/generators/refactoring/refactorization/refactorization_generator.rb

@@ -0,0 +1,22 @@
+module Refactoring
+  module Generators
+    class RefactorizationGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path('../templates', __FILE__)
+
+      def initialize_names
+        @version = Time.now.utc.strftime("%Y%m%d%H%M%S")
+        @versions_file_name = "#{Refactoring::REFACTORIZATIONS_ROOT}/versions"
+        @file_name = "#{@version}_#{name}.rb"
+        @class_name = name.classify
+      end
+
+      def generate_versions_file
+        create_file @versions_file_name unless File.exists?(@versions_file_name)
+      end
+
+      def generate_refactoring
+        template "refactoring.rb", "#{Refactoring::REFACTORIZATIONS_ROOT}/#{@file_name}"
+      end
+    end
+  end
+end

data/lib/generators/refactoring/refactorization/templates/refactoring.rb

@@ -0,0 +1,7 @@
+class <%= @class_name %> < Refactoring::Base
+  def up
+  end
+
+  def down
+  end
+end

data/lib/generators/refactoring/run/USAGE

@@ -0,0 +1,9 @@
+Description:
+    Explain the generator
+
+Example:
+    rails generate refactoring Thing
+
+    This will create:
+        what/will/it/create
+

data/lib/generators/refactoring/run/run_generator.rb

@@ -0,0 +1,36 @@
+module Refactoring
+  module Generators
+    class RunGenerator < Rails::Generators::Base
+      def run_refactorizations
+        Dir.glob(Rails.root.to_s + "/#{Refactoring::REFACTORIZATIONS_ROOT}/2*.rb") do |f|
+          if !refactorization_ran?(File.basename(f).split("_")[0])
+            run_refactorization(f)
+          end
+        end
+      end
+
+      private
+        def refactorization_ran?(version)
+          @versions_file_name ||= Rails.root.to_s + "/#{Refactoring::REFACTORIZATIONS_ROOT}/versions"
+          f = File.open(@versions_file_name, "r")
+          f.each_line do |line|
+            if line.strip == version
+              f.close
+              return true
+            end
+          end
+          false
+        end
+
+        def run_refactorization(file_name)
+          basename = File.basename(file_name, ".rb")
+          puts "Running refactorization #{basename}..."
+
+          require file_name
+          class_name = basename.sub(/^.+?_/, "").classify
+          instance = eval "#{class_name}.new"
+          instance.refactor(:up)
+        end
+    end
+  end
+end

data/lib/refactoring.rb

@@ -0,0 +1,337 @@
+require 'irb/ruby-lex'
+require 'stringio'
+
+module Refactoring
+  REFACTORIZATIONS_ROOT = "refactorizations"
+
+  class Base
+    def rename(old, new)
+      @names = {
+        :old => name_variants(old),
+        :new => name_variants(new)
+      }
+
+      puts "  - renaming #{@names[:old][:model][:class]} to #{@names[:new][:model][:class]}..."
+
+      rename_model_file
+      rename_model_class
+      rename_model_associations
+      rename_controller_file
+      rename_controller_class
+      rename_params
+      rename_views_directory
+      rename_helper_file
+      rename_helper_module
+      rename_test_files
+      rename_test_classes
+      rename_fixture_files
+      rename_instance_variables
+      rename_routes
+      rename_foreign_keys
+      generate_table_rename_migration
+      rename_scaffold_comments
+    end
+
+    def refactor(direction)
+      return unless respond_to?(direction.to_s)
+      send(direction)
+    end
+
+    private
+      def rename_model_file
+        puts "    - renaming model file..."
+        File.rename(@names[:old][:model][:path], @names[:new][:model][:path])
+      end
+
+      def rename_model_class
+        puts "    - renaming model class..."
+        rename_constant(@names[:old][:model][:class], @names[:new][:model][:class])
+      end
+
+      def rename_model_associations
+        puts "    - renaming model associations..."
+        Dir.glob("#{models_path}/*.rb") do |model_file_name|
+          replace_in_file(model_file_name, /((?:^|\n)\s*(?:has_one|belongs_to)\s*:)#{@names[:old][:model][:name][:singular]}/, "\\1#{@names[:new][:model][:name][:singular]}")
+          replace_in_file(model_file_name, /((?:^|\n)\s*(?:has_(?:and_belongs_to)?many)\s*:)#{@names[:old][:model][:name][:plural]}/, "\\1#{@names[:new][:model][:name][:plural]}")
+          replace_in_file(model_file_name, /(:class_name\s*=>\s*['"])#{@names[:old][:model][:class]}/, "\\1#{@names[:new][:model][:class]}")
+        end
+      end
+
+      def rename_controller_file
+        puts "    - renaming controller file..."
+        File.rename(@names[:old][:controller][:path], @names[:new][:controller][:path])
+      end
+
+      def rename_controller_class
+        puts "    - renaming controller class..."
+        rename_constant(@names[:old][:controller][:class], @names[:new][:controller][:class])
+      end
+
+      def rename_views_directory
+        puts "    - renaming views directory..."
+        File.rename(@names[:old][:views][:path], @names[:new][:views][:path])
+      end
+
+      def rename_helper_file
+        puts "    - renaming helper file..."
+        File.rename(@names[:old][:helper][:path], @names[:new][:helper][:path])
+      end
+
+      def rename_helper_module
+        puts "    - renaming helper module..."
+        rename_constant(@names[:old][:helper][:module], @names[:new][:helper][:module])
+      end
+
+      def rename_test_files
+        puts "    - renaming test files..."
+        File.rename(@names[:old][:test][:unit][:path], @names[:new][:test][:unit][:path])
+        File.rename(@names[:old][:test][:helper][:path], @names[:new][:test][:helper][:path])
+        File.rename(@names[:old][:test][:functional][:path], @names[:new][:test][:functional][:path])
+      end
+
+      def rename_test_classes
+        puts "    - renaming test classes..."
+        rename_constant(@names[:old][:test][:unit][:class], @names[:new][:test][:unit][:class])
+        rename_constant(@names[:old][:test][:helper][:class], @names[:new][:test][:helper][:class])
+        rename_constant(@names[:old][:test][:functional][:class], @names[:new][:test][:functional][:class])
+      end
+
+      def rename_instance_variables
+        puts "    - renaming instance variables..."
+
+        variants = []
+        variants << [@names[:old][:model][:name][:singular], @names[:new][:model][:name][:singular]]
+        variants << [@names[:old][:model][:name][:plural], @names[:new][:model][:name][:plural]]
+
+        code_files.each do |file_name|
+          variants.each do |variant|
+            text_original = File.read(file_name)
+            text_changed = rename_instance_variables_in_text(text_original, variant[0], variant[1])
+
+            if text_changed != text_original
+              open(file_name, "w") { |f| f.puts(text_changed) }
+            end
+          end
+        end
+      end
+
+      def rename_scaffold_comments
+        puts "    - renaming scaffold comments..."
+        replace_in_file(@names[:new][:controller][:path], /((?:^|\n)\s*#\s+(?:GET|POST|PUT|DELETE)\s+\/)#{@names[:old][:model][:name][:plural]}/, "\\1#{@names[:new][:model][:name][:plural]}")
+      end
+
+      def rename_fixture_files
+        puts "    - renaming fixture files..."
+        File.rename(@names[:old][:test][:fixtures][:path], @names[:new][:test][:fixtures][:path])
+      end
+
+      def generate_table_rename_migration
+        puts "    - generating table rename migration..."
+        time = Time.now.utc.strftime("%Y%m%d%H%M%S")
+        open("#{db_path}/migrate/#{time}_rename_#{@names[:old][:table]}_to_#{@names[:new][:table]}.rb", "w") do |f|
+          f.puts "class Rename#{@names[:old][:table].titleize}To#{@names[:new][:table].titleize} < ActiveRecord::Migration\n"
+          f.puts "  def self.up\n"
+          f.puts "    rename_table :#{@names[:old][:table]}, :#{@names[:new][:table]}\n"
+          f.puts "  end\n"
+          f.puts "\n"
+          f.puts "  def self.down\n"
+          f.puts "    rename_table :#{@names[:new][:table]}, :#{@names[:old][:table]}\n"
+          f.puts "  end\n"
+          f.puts "end\n"
+        end
+      end
+
+      def rename_params
+        puts "    - renaming params..."
+        replace_in_file(@names[:new][:controller][:path], /(\bparams\[:)#{@names[:old][:model][:name][:singular]}/, "\\1#{@names[:new][:model][:name][:singular]}")
+      end
+
+      def rename_foreign_keys
+        puts "    - renaming foreign keys TODO..."
+      end
+
+      def rename_routes
+        puts "    - renaming routes..."
+
+        sgo = @names[:old][:model][:name][:singular]
+        sgn = @names[:new][:model][:name][:singular]
+        plo = @names[:old][:model][:name][:plural]
+        pln = @names[:new][:model][:name][:plural]
+
+        replace_in_file(routes_path, /(\bresources\s+:)#{plo}/, "\\1#{pln}")
+        replace_in_file(routes_path, /(\bresource\s+:)#{sgo}/, "\\1#{sgn}")
+        replace_in_file(routes_path, /(\b:controller\s*=>\s*['"])#{plo}/, "\\1#{pln}")
+
+        route_identifiers = {
+          plo => pln,
+          "new_#{sgo}" => "new_#{sgn}",
+          "edit_#{sgo}" => "edit_#{sgn}",
+          sgo => sgn
+        }
+
+        code_files.each do |file_name|
+          text_original = File.read(file_name)
+          text_changed = text_original
+
+          route_identifiers.each do |from, to|
+            {"#{from}_path" => "#{to}_path", "#{from}_url" => "#{to}_url"}.each do |old, new|
+              text_changed = rename_identifier_in_text(text_changed, old, new)
+            end
+          end
+
+          if text_changed != text_original
+            open(file_name, "w") { |f| f.puts(text_changed) }
+          end
+        end
+      end
+
+      def name_variants(name)
+        variants = {
+          :model => {:name => {}},
+          :controller => {},
+          :views => {},
+          :helper => {},
+          :test => {:unit => {}, :helper => {}, :functional => {}, :fixtures => {}},
+          :table => {}
+        }
+
+        variants[:model][:name][:singular] = name.to_s
+        variants[:model][:name][:plural] = variants[:model][:name][:singular].pluralize
+        variants[:model][:class] = variants[:model][:name][:singular].classify
+        variants[:model][:path] = "#{models_path}/#{name.to_s}.rb"
+
+        variants[:controller][:name] = "#{variants[:model][:name][:plural]}_controller"
+        variants[:controller][:class] = variants[:controller][:name].classify
+        variants[:controller][:path] = "#{controllers_path}/#{variants[:controller][:name]}.rb"
+
+        variants[:views][:path] = "#{views_path}/#{variants[:model][:name][:plural]}"
+
+        variants[:helper][:path] = "#{helpers_path}/#{variants[:model][:name][:plural]}_helper.rb"
+        variants[:helper][:module] = "#{variants[:model][:class].pluralize}Helper"
+
+        variants[:test][:unit][:path] = "#{test_path}/unit/#{variants[:model][:name][:singular]}_test.rb"
+        variants[:test][:unit][:class] = "#{variants[:model][:class]}Test"
+        variants[:test][:helper][:path] = "#{test_path}/unit/helpers/#{variants[:model][:name][:plural]}_helper_test.rb"
+        variants[:test][:helper][:class] = "#{variants[:model][:class].pluralize}HelperTest"
+        variants[:test][:functional][:path] = "#{test_path}/functional/#{variants[:controller][:name]}_test.rb"
+        variants[:test][:functional][:class] = "#{variants[:controller][:class]}Test"
+        variants[:test][:fixtures][:path] = "#{test_path}/fixtures/#{variants[:model][:name][:plural]}.yml"
+
+        variants[:table] = variants[:model][:name][:plural]
+
+        variants
+      end
+
+      def rename_token_in_text(token_to_find, text, old, new)
+        changes = []
+
+        parser = RubyLex.new
+        parser.set_input(StringIO.new(text))
+
+        loop do
+          token = parser.token
+          break if token.nil?
+
+          if token.class == token_to_find && token.name == old
+            if changes.length == 0
+              changes << token.seek
+            else
+              changes << token.seek + ((new.length - old.length) * changes.length)
+            end
+          end
+        end
+
+        changes.each do |offset|
+          first_part = text.slice(0, offset)
+          last_part = text.slice(offset + old.length, text.length)
+          text = first_part + new + last_part
+        end
+
+        text.scan /".+?(?<!\\)"/ms do |quote|
+          quote_original = quote
+          quote.scan /\#{(.+?(?<!\\))}/ do |code|
+            text_original = code[0]
+            text_changed = rename_token_in_text(token_to_find, text_original, old, new)
+            quote = quote.gsub("\#{#{text_original}}", "\#{#{text_changed}}")
+          end
+          if quote_original != quote
+            text = text.gsub(quote_original, quote)
+          end
+        end
+
+        text.scan /((?:assert_.+?|eval)\s*\(?)(["'])(.+?)(?<!\\)\2/ do |method, quote, code|
+          text_original = code
+          text_changed = rename_token_in_text(token_to_find, text_original, old, new)
+          if text_changed != text_original
+            text = text.gsub("#{method}#{quote}#{code}", "#{method}#{quote}#{text_changed}")
+          end
+        end
+
+        text
+      end
+
+      def rename_constant_in_text(text, old, new)
+        rename_token_in_text(RubyToken::TkCONSTANT, text, old, new)
+      end
+
+      def rename_instance_variables_in_text(text, old, new)
+        rename_token_in_text(RubyToken::TkIVAR, text, "@#{old}", "@#{new}")
+      end
+
+      def rename_identifier_in_text(text, old, new)
+        rename_token_in_text(RubyToken::TkIDENTIFIER, text, old, new)
+      end
+
+      def rename_constant(old, new)
+        code_files.each do |file_name|
+          text_original = File.read(file_name)
+          text_changed = rename_constant_in_text(text_original, old, new)
+
+          if text_changed != text_original
+            open(file_name, "w") { |f| f.puts(text_changed) }
+          end
+        end
+      end
+
+      def models_path
+        @models_path ||= Rails.application.config.paths.app.models.to_a[0]
+      end
+
+      def controllers_path
+        @controllers_path ||= Rails.application.config.paths.app.controllers.to_a[0]
+      end
+
+      def views_path
+        @views_path ||= Rails.application.config.paths.app.views.to_a[0]
+      end
+
+      def helpers_path
+        @helpers_path ||= Rails.application.config.paths.app.helpers.to_a[0]
+      end
+
+      def root_path
+        @root_path ||= Rails.root.to_s
+      end
+
+      def test_path
+        @test_path ||= "#{root_path}/test"
+      end
+
+      def db_path
+        @db_path ||= "#{root_path}/db"
+      end
+
+      def routes_path
+        @routes_path ||= "#{root_path}/config/routes.rb"
+      end
+
+      def code_files
+        Dir.glob("#{Rails.root}/app/**/*.rb") + Dir.glob("#{Rails.root}/test/**/*.rb")
+      end
+
+      def replace_in_file(file_name, regexp, replacement)
+        text = File.read(file_name)
+        open(file_name, "w") { |f| f.puts(text.gsub(regexp, replacement)) }
+      end
+  end
+end

data/lib/refactoring/version.rb

@@ -0,0 +1,3 @@
+module Refactoring
+  VERSION = "0.0.1"
+end

data/refactoring.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "refactoring/version"
+
+Gem::Specification.new do |s|
+  s.name        = "refactoring"
+  s.version     = Refactoring::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Radu Dineiu"]
+  s.email       = ["radu.dineiu@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Refactoring for Ruby on Rails}
+  s.description = %q{Refactoring for Ruby on Rails}
+
+  s.rubyforge_project = "refactoring"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: refactoring
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Radu Dineiu
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-10 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Refactoring for Ruby on Rails
+email: 
+- radu.dineiu@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README
+- Rakefile
+- lib/generators/refactoring/refactorization/USAGE
+- lib/generators/refactoring/refactorization/refactorization_generator.rb
+- lib/generators/refactoring/refactorization/templates/refactoring.rb
+- lib/generators/refactoring/run/USAGE
+- lib/generators/refactoring/run/run_generator.rb
+- lib/refactoring.rb
+- lib/refactoring/version.rb
+- refactoring.gemspec
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: refactoring
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: Refactoring for Ruby on Rails
+test_files: []
+