annotate 2.5.0 → 2.6.0.beta2

data/lib/annotate.rb

@@ -1,17 +1,150 @@
-here = File.dirname __FILE__
-require "#{here}/annotate/version"
+$:.unshift(File.dirname(__FILE__))
+require 'annotate/version'
+require 'annotate/annotate_models'
+require 'annotate/annotate_routes'
+
+begin
+  # ActiveSupport 3.x...
+  require 'active_support/hash_with_indifferent_access'
+rescue Exception => e
+  # ActiveSupport 2.x...
+  require 'active_support/core_ext/hash/indifferent_access'
+end
 
 module Annotate
+  ##
+  # The set of available options to customize the behavior of Annotate.
+  #
+  POSITION_OPTIONS=[
+    :position_in_routes, :position_in_class, :position_in_test,
+    :position_in_fixture, :position_in_factory, :position,
+  ]
+  FLAG_OPTIONS=[
+    :show_indexes, :simple_indexes, :include_version, :exclude_tests,
+    :exclude_fixtures, :exclude_factories, :ignore_model_sub_dir,
+    :format_bare, :format_rdoc, :format_markdown, :sort, :force, :trace,
+  ]
+  OTHER_OPTIONS=[
+    :model_dir,
+  ]
+  PATH_OPTIONS=[
+    :require,
+  ]
+
+
+  ##
+  # Set default values that can be overridden via environment variables.
+  #
+  def self.set_defaults(options = {})
+    return if(@has_set_defaults)
+    @has_set_defaults = true
+    options = HashWithIndifferentAccess.new(options)
+    [POSITION_OPTIONS, FLAG_OPTIONS, PATH_OPTIONS].flatten.each do |key|
+      if(options.has_key?(key))
+        default_value = if(options[key].is_a?(Array))
+          options[key].join(",")
+        else
+          options[key]
+        end
+      end
+      default_value = ENV[key.to_s] if(!ENV[key.to_s].blank?)
+      ENV[key.to_s] = default_value.to_s
+    end
+  end
+
+  TRUE_RE = /^(true|t|yes|y|1)$/i
+  def self.setup_options(options = {})
+    POSITION_OPTIONS.each do |key|
+      options[key] = fallback(ENV[key.to_s], ENV['position'], 'before')
+    end
+    FLAG_OPTIONS.each do |key|
+      options[key] = true?(ENV[key.to_s])
+    end
+    OTHER_OPTIONS.each do |key|
+      options[key] = (!ENV[key.to_s].blank?) ? ENV[key.to_s] : nil
+    end
+    PATH_OPTIONS.each do |key|
+      options[key] = (!ENV[key.to_s].blank?) ? ENV[key.to_s].split(',') : []
+    end
+
+    if(!options[:model_dir])
+      options[:model_dir] = 'app/models'
+    end
+
+    return options
+  end
+
+  def self.skip_on_migration?
+    ENV['skip_on_db_migrate'] =~ TRUE_RE
+  end
+
+  def self.loaded_tasks=(val); @loaded_tasks = val; end
+  def self.loaded_tasks; return @loaded_tasks; end
+
   def self.load_tasks
-    if File.exists?('Rakefile')
-      require 'rake'
-      load 'Rakefile'
-      # Rails 3 wants to load our .rake files for us.
-      # TODO: selectively do this require on Rails 2.x?
-      Dir[File.join(File.dirname(__FILE__), 'tasks', '**/*.rake')].each { |rake| load rake }
-      return true
+    return if(self.loaded_tasks)
+    self.loaded_tasks = true
+
+    Dir[File.join(File.dirname(__FILE__), 'tasks', '**/*.rake')].each { |rake| load rake }
+  end
+
+  def self.load_requires(options)
+    options[:require].each { |path| require path } if options[:require].count > 0
+  end
+
+  def self.eager_load(options)
+    self.load_requires(options)
+    require "annotate/active_record_patch"
+
+    if(defined?(Rails))
+      if(Rails.version.split('.').first.to_i < 3)
+        Rails.configuration.eager_load_paths.each do |load_path|
+          matcher = /\A#{Regexp.escape(load_path)}(.*)\.rb\Z/
+          Dir.glob("#{load_path}/**/*.rb").sort.each do |file|
+            require_dependency file.sub(matcher, '\1')
+          end
+        end
+      else
+        klass = Rails::Application.send(:subclasses).first
+        klass.eager_load!
+      end
     else
-      return false
+      FileList["#{options[:model_dir]}/**/*.rb"].each do |fname|
+        require File.expand_path(fname)
+      end
     end
   end
+
+  def self.bootstrap_rake
+    begin
+      require 'rake/dsl_definition'
+    rescue Exception => e
+      # We might just be on an old version of Rake...
+    end
+    require 'rake'
+
+    if File.exists?('./Rakefile')
+      load './Rakefile'
+    end
+    Rake::Task[:environment].invoke rescue nil
+    if(!defined?(Rails))
+      # Not in a Rails project, so time to load up the parts of
+      # ActiveSupport we need.
+      require 'active_support'
+      require 'active_support/core_ext/class/subclasses'
+      require 'active_support/core_ext/string/inflections'
+    end
+    self.load_tasks
+    Rake::Task[:set_annotation_options].invoke
+  end
+
+  def self.fallback(*args)
+    return args.detect { |arg| !arg.blank? }
+  end
+
+  def self.true?(val)
+    return false if(val.blank?)
+    return false unless(val =~ TRUE_RE)
+    return true
+  end
 end

data/lib/annotate/active_record_patch.rb

@@ -6,4 +6,4 @@ module ::ActiveRecord
       # ignore this, so unknown/unloaded macros won't cause parsing to fail
     end
   end
-end
+end

data/lib/annotate/annotate_models.rb

@@ -9,11 +9,10 @@ module AnnotateModels
 
   # File.join for windows reverse bar compat?
   # I dont use windows, can`t test
-  UNIT_TEST_DIR         = File.join("test", "unit"  )
+  UNIT_TEST_DIR         = File.join("test", "unit")
   SPEC_MODEL_DIR        = File.join("spec", "models")
   FIXTURE_TEST_DIR      = File.join("test", "fixtures")
   FIXTURE_SPEC_DIR      = File.join("spec", "fixtures")
-  FIXTURE_DIRS = ["test/fixtures","spec/fixtures"]
 
   # Object Daddy http://github.com/flogic/object_daddy/tree/master
   EXEMPLARS_TEST_DIR    = File.join("test", "exemplars")
@@ -31,6 +30,29 @@ module AnnotateModels
   FABRICATORS_TEST_DIR  = File.join("test", "fabricators")
   FABRICATORS_SPEC_DIR  = File.join("spec", "fabricators")
 
+  TEST_PATTERNS = [
+    [UNIT_TEST_DIR,  "%MODEL_NAME%_test.rb"],
+    [SPEC_MODEL_DIR, "%MODEL_NAME%_spec.rb"],
+  ]
+
+  FIXTURE_PATTERNS = [
+    File.join(FIXTURE_TEST_DIR, "%TABLE_NAME%.yml"),
+    File.join(FIXTURE_SPEC_DIR, "%TABLE_NAME%.yml"),
+  ]
+
+  FACTORY_PATTERNS = [
+    File.join(EXEMPLARS_TEST_DIR,     "%MODEL_NAME%_exemplar.rb"),
+    File.join(EXEMPLARS_SPEC_DIR,     "%MODEL_NAME%_exemplar.rb"),
+    File.join(BLUEPRINTS_TEST_DIR,    "%MODEL_NAME%_blueprint.rb"),
+    File.join(BLUEPRINTS_SPEC_DIR,    "%MODEL_NAME%_blueprint.rb"),
+    File.join(FACTORY_GIRL_TEST_DIR,  "%MODEL_NAME%_factory.rb"),    # (old style)
+    File.join(FACTORY_GIRL_SPEC_DIR,  "%MODEL_NAME%_factory.rb"),    # (old style)
+    File.join(FACTORY_GIRL_TEST_DIR,  "%TABLE_NAME%.rb"),            # (new style)
+    File.join(FACTORY_GIRL_SPEC_DIR,  "%TABLE_NAME%.rb"),            # (new style)
+    File.join(FABRICATORS_TEST_DIR,   "%MODEL_NAME%_fabricator.rb"),
+    File.join(FABRICATORS_SPEC_DIR,   "%MODEL_NAME%_fabricator.rb"),
+  ]
+
   # Don't show limit (#) on these column types
   # Example: show "integer" instead of "integer(4)"
   NO_LIMIT_COL_TYPES = ["integer", "boolean"]
@@ -39,7 +61,7 @@ module AnnotateModels
     def model_dir
       @model_dir || "app/models"
     end
-    
+
     def model_dir=(dir)
       @model_dir = dir
     end
@@ -65,15 +87,24 @@ module AnnotateModels
     def get_schema_info(klass, header, options = {})
       info = "# #{header}\n"
       info<< "#\n"
-      info<< "# Table name: #{klass.table_name}\n"
+      if(options[:format_markdown])
+        info<< "# Table name: `#{klass.table_name}`\n"
+        info<< "#\n"
+        info<< "# ### Columns\n"
+      else
+        info<< "# Table name: #{klass.table_name}\n"
+      end
       info<< "#\n"
 
       max_size = klass.column_names.map{|name| name.size}.max || 0
       max_size += options[:format_rdoc] ? 5 : 1
+      md_names_overhead = 6
+      md_type_allowance = 18
+      bare_type_allowance = 16
 
       if(options[:format_markdown])
-        info<< sprintf( "# %-#{max_size + 4}.#{max_size + 4}s | %-18.18s | %s\n", 'Field', 'Type', 'Attributes' )
-        info<< "# #{ '-' * ( max_size + 4 ) } | #{'-' * 18} | #{ '-' * 25 }\n"
+        info<< sprintf( "# %-#{max_size + md_names_overhead}.#{max_size + md_names_overhead}s | %-#{md_type_allowance}.#{md_type_allowance}s | %s\n", 'Name', 'Type', 'Attributes' )
+        info<< "# #{ '-' * ( max_size + md_names_overhead ) } | #{'-' * md_type_allowance} | #{ '-' * 27 }\n"
       end
 
       cols = klass.columns
@@ -82,7 +113,7 @@ module AnnotateModels
         attrs = []
         attrs << "default(#{quote(col.default)})" unless col.default.nil?
         attrs << "not null" unless col.null
-        attrs << "primary key" if klass.primary_key && col.name.to_sym == klass.primary_key.to_sym
+        attrs << "primary key" if klass.primary_key && (klass.primary_key.is_a?(Array) ? klass.primary_key.collect{|c|c.to_sym}.include?(col.name.to_sym) : col.name.to_sym == klass.primary_key.to_sym)
 
         col_type = (col.type || col.sql_type).to_s
         if col_type == "decimal"
@@ -92,7 +123,7 @@ module AnnotateModels
             col_type << "(#{col.limit})" unless NO_LIMIT_COL_TYPES.include?(col_type)
           end
         end
-       
+
         # Check out if we got a geometric column
         # and print the type and SRID
         if col.respond_to?(:geometry_type)
@@ -114,14 +145,16 @@ module AnnotateModels
         if options[:format_rdoc]
           info << sprintf("# %-#{max_size}.#{max_size}s<tt>%s</tt>", "*#{col.name}*::", attrs.unshift(col_type).join(", ")).rstrip + "\n"
         elsif options[:format_markdown]
-          info << sprintf("# **%-#{max_size}.#{max_size}s** | `%-16.16s` | `%s`", col.name, col_type, attrs.join(", ").rstrip) + "\n"
+          name_remainder = max_size - col.name.length
+          type_remainder = (md_type_allowance - 2) - col_type.length
+          info << (sprintf("# **`%s`**%#{name_remainder}s | `%s`%#{type_remainder}s | `%s`", col.name, " ", col_type, " ", attrs.join(", ").rstrip)).gsub('``', '  ').rstrip + "\n"
         else
-          info << sprintf("#  %-#{max_size}.#{max_size}s:%-16.16s %s", col.name, col_type, attrs.join(", ")).rstrip + "\n"
+          info << sprintf("#  %-#{max_size}.#{max_size}s:%-#{bare_type_allowance}.#{bare_type_allowance}s %s", col.name, col_type, attrs.join(", ")).rstrip + "\n"
         end
       end
 
       if options[:show_indexes] && klass.table_exists?
-        info << get_index_info(klass)
+        info << get_index_info(klass, options)
       end
 
       if options[:format_rdoc]
@@ -133,15 +166,23 @@ module AnnotateModels
       end
     end
 
-    def get_index_info(klass)
-      index_info = "#\n# Indexes\n#\n"
+    def get_index_info(klass, options={})
+      if(options[:format_markdown])
+        index_info = "#\n# ### Indexes\n#\n"
+      else
+        index_info = "#\n# Indexes\n#\n"
+      end
 
       indexes = klass.connection.indexes(klass.table_name)
       return "" if indexes.empty?
 
       max_size = indexes.collect{|index| index.name.size}.max + 1
       indexes.sort_by{|index| index.name}.each do |index|
-        index_info << sprintf("#  %-#{max_size}.#{max_size}s %s %s", index.name, "(#{index.columns.join(",")})", index.unique ? "UNIQUE" : "").rstrip + "\n"
+        if(options[:format_markdown])
+          index_info << sprintf("# * `%s`%s:\n#     * **`%s`**\n", index.name, index.unique ? " (_unique_)" : "", index.columns.join("`**\n#     * **`"))
+        else
+          index_info << sprintf("#  %-#{max_size}.#{max_size}s %s %s", index.name, "(#{index.columns.join(",")})", index.unique ? "UNIQUE" : "").rstrip + "\n"
+        end
       end
       return index_info
     end
@@ -153,14 +194,11 @@ module AnnotateModels
     # Returns true or false depending on whether the file was modified.
     #
     # === Options (opts)
-    #  :position<Symbol>:: where to place the annotated section in fixture or model file,
-    #                      :before or :after. Default is :before.
-    #  :position_in_class<Symbol>:: where to place the annotated section in model file
-    #  :position_in_fixture<Symbol>:: where to place the annotated section in fixture file
-    #  :position_in_others<Symbol>:: where to place the annotated section in the rest of
-    #                      supported files
+    #  :force<Symbol>:: whether to update the file even if it doesn't seem to need it.
+    #  :position_in_*<Symbol>:: where to place the annotated section in fixture or model file,
+    #                           :before or :after. Default is :before.
     #
-    def annotate_one_file(file_name, info_block, options={})
+    def annotate_one_file(file_name, info_block, position, options={})
       if File.exist?(file_name)
         old_content = File.read(file_name)
         return false if(old_content =~ /# -\*- SkipSchemaAnnotations.*\n/)
@@ -178,9 +216,9 @@ module AnnotateModels
         encoding_header = old_content.match(encoding).to_s
 
         if old_columns == new_columns && !options[:force]
-          false
+          return false
         else
-          
+
 # todo: figure out if we need to extract any logic from this merge chunk
 # <<<<<<< HEAD
 #           # Replace the old schema info with the new schema info
@@ -197,22 +235,30 @@ module AnnotateModels
           # Strip the old schema info, and insert new schema info.
           old_content.sub!(encoding, '')
           old_content.sub!(PATTERN, '')
-          
-          new_content = (options[:position] || 'before').to_s == 'after' ?
+
+          new_content = options[position].to_s == 'after' ?
             (encoding_header + (old_content.rstrip + "\n\n" + info_block)) :
             (encoding_header + info_block + old_content)
 
           File.open(file_name, "wb") { |f| f.puts new_content }
-          true
+          return true
         end
+      else
+        return false
       end
     end
-    
+
     def remove_annotation_of_file(file_name)
       if File.exist?(file_name)
         content = File.read(file_name)
+
         content.sub!(PATTERN, '')
+
         File.open(file_name, "wb") { |f| f.puts content }
+
+        return true
+      else
+        return false
       end
     end
 
@@ -222,48 +268,55 @@ module AnnotateModels
     # of the model and fixture source files.
     # Returns true or false depending on whether the source
     # files were modified.
+    #
+    # === Options (opts)
+    #  :position_in_class<Symbol>:: where to place the annotated section in model file
+    #  :position_in_test<Symbol>:: where to place the annotated section in test/spec file(s)
+    #  :position_in_fixture<Symbol>:: where to place the annotated section in fixture file
+    #  :position_in_factory<Symbol>:: where to place the annotated section in factory file
+    #  :exclude_tests<Symbol>:: whether to skip modification of test/spec files
+    #  :exclude_fixtures<Symbol>:: whether to skip modification of fixture files
+    #  :exclude_factories<Symbol>:: whether to skip modification of factory files
+    #
     def annotate(klass, file, header, options={})
-      info = get_schema_info(klass, header, options)
-      annotated = false
-      model_name = klass.name.underscore
-      model_file_name = File.join(model_dir, file)
+      begin
+        info = get_schema_info(klass, header, options)
+        did_annotate = false
+        model_name = klass.name.underscore
+        table_name = klass.table_name
+        model_file_name = File.join(model_dir, file)
+
+        if annotate_one_file(model_file_name, info, :position_in_class, options_with_position(options, :position_in_class))
+          did_annotate = true
+        end
 
-      if annotate_one_file(model_file_name, info, options_with_position(options, :position_in_class))
-        annotated = true
-      end
+        unless options[:exclude_tests]
+          did_annotate = TEST_PATTERNS.
+            map { |pat| [pat[0], resolve_filename(pat[1], model_name, table_name)] }.
+            map { |pat| find_test_file(*pat) }.
+            map { |file| annotate_one_file(file, info, :position_in_test, options_with_position(options, :position_in_test)) }.
+            detect { |result| result } || did_annotate
+        end
 
-      unless options[:exclude_tests]
-        [
-          find_test_file(UNIT_TEST_DIR,      "#{model_name}_test.rb"), # test
-          find_test_file(SPEC_MODEL_DIR,     "#{model_name}_spec.rb"), # spec
-        ].each do |file|
-          # todo: add an option "position_in_test" -- or maybe just ask if anyone ever wants different positions for model vs. test vs. fixture
-          if annotate_one_file(file, info, options_with_position(options, :position_in_fixture))
-            annotated = true
-          end
+        unless options[:exclude_fixtures]
+          did_annotate = FIXTURE_PATTERNS.
+            map { |file| resolve_filename(file, model_name, table_name) }.
+            map { |file| annotate_one_file(file, info, :position_in_fixture, options_with_position(options, :position_in_fixture)) }.
+            detect { |result| result } || did_annotate
         end
-      end
 
-      unless options[:exclude_fixtures]
-        [
-         File.join(FIXTURE_TEST_DIR,       "#{klass.table_name}.yml"),     # fixture
-         File.join(FIXTURE_SPEC_DIR,       "#{klass.table_name}.yml"),     # fixture
-         File.join(EXEMPLARS_TEST_DIR,     "#{model_name}_exemplar.rb"),   # Object Daddy
-         File.join(EXEMPLARS_SPEC_DIR,     "#{model_name}_exemplar.rb"),   # Object Daddy
-         File.join(BLUEPRINTS_TEST_DIR,    "#{model_name}_blueprint.rb"),  # Machinist Blueprints
-         File.join(BLUEPRINTS_SPEC_DIR,    "#{model_name}_blueprint.rb"),  # Machinist Blueprints
-         File.join(FACTORY_GIRL_TEST_DIR,  "#{model_name}_factory.rb"),    # Factory Girl Factories
-         File.join(FACTORY_GIRL_SPEC_DIR,  "#{model_name}_factory.rb"),    # Factory Girl Factories
-         File.join(FABRICATORS_TEST_DIR,   "#{model_name}_fabricator.rb"), # Fabrication Fabricators
-         File.join(FABRICATORS_SPEC_DIR,   "#{model_name}_fabricator.rb"), # Fabrication Fabricators
-        ].each do |file|
-          if annotate_one_file(file, info, options_with_position(options, :position_in_fixture))
-            annotated = true
-          end
+        unless options[:exclude_factories]
+          did_annotate = FACTORY_PATTERNS.
+            map { |file| resolve_filename(file, model_name, table_name) }.
+            map { |file| annotate_one_file(file, info, :position_in_factory, options_with_position(options, :position_in_factory)) }.
+            detect { |result| result } || did_annotate
         end
-      end
 
-      annotated
+        return did_annotate
+      rescue Exception => e
+        puts "Unable to annotate #{file}: #{e.message}"
+        puts "\t" + e.backtrace.join("\n\t") if options[:trace]
+      end
     end
 
     # position = :position_in_fixture or :position_in_class
@@ -297,19 +350,18 @@ module AnnotateModels
           puts "No models found in directory '#{model_dir}'."
           puts "Either specify models on the command line, or use the --model-dir option."
           puts "Call 'annotate --help' for more info."
-          exit 1;
+          exit 1
         end
       end
       models
     end
-  
+
     # Retrieve the classes belonging to the model names we're asked to process
     # Check for namespaced models in subdirectories as well as models
     # in subdirectories without namespacing.
     def get_model_class(file)
       # this is for non-rails projects, which don't get Rails auto-require magic
-      require File.expand_path("#{model_dir}/#{file}")
-
+      require File.expand_path("#{model_dir}/#{file}") unless Module.const_defined?(:Rails)
       model_path = file.gsub(/\.rb$/, '')
       get_loaded_model(model_path) || get_loaded_model(model_path.split('/').last)
     end
@@ -320,7 +372,7 @@ module AnnotateModels
         select do |c|
           Class === c and    # note: we use === to avoid a bug in activesupport 2.3.14 OptionMerger vs. is_a?
           c.ancestors.respond_to?(:include?) and  # to fix FactoryGirl bug, see https://github.com/ctran/annotate_models/pull/82
-          c.ancestors.include?(ActiveRecord::Base) 
+          c.ancestors.include?(ActiveRecord::Base)
         end.
         detect { |c| ActiveSupport::Inflector.underscore(c) == model_path }
     end
@@ -330,21 +382,15 @@ module AnnotateModels
     # if its a subclass of ActiveRecord::Base,
     # then pass it to the associated block
     def do_annotations(options={})
-      if options[:require]
-        options[:require].each do |path|
-          require path
-        end
-      end
-
       header = options[:format_markdown] ? PREFIX_MD.dup : PREFIX.dup
 
       if options[:include_version]
         version = ActiveRecord::Migrator.current_version rescue 0
         if version > 0
           header << "\n# Schema version: #{version}"
-        end        
+        end
       end
-      
+
       self.model_dir = options[:model_dir] if options[:model_dir]
 
       annotated = []
@@ -373,46 +419,54 @@ module AnnotateModels
     end
 
     def remove_annotations(options={})
+
       self.model_dir = options[:model_dir] if options[:model_dir]
       deannotated = []
+      deannotated_klass = false
       get_model_files(options).each do |file|
         begin
           klass = get_model_class(file)
           if klass < ActiveRecord::Base && !klass.abstract_class?
-            deannotated << klass
-
             model_name = klass.name.underscore
+            table_name = klass.table_name
             model_file_name = File.join(model_dir, file)
-            remove_annotation_of_file(model_file_name)
-
-            [
-             File.join(UNIT_TEST_DIR,          "#{model_name}_test.rb"),
-             File.join(SPEC_MODEL_DIR,         "#{model_name}_spec.rb"),
-             File.join(FIXTURE_TEST_DIR,       "#{klass.table_name}.yml"),     # fixture
-             File.join(FIXTURE_SPEC_DIR,       "#{klass.table_name}.yml"),     # fixture
-             File.join(EXEMPLARS_TEST_DIR,     "#{model_name}_exemplar.rb"),   # Object Daddy
-             File.join(EXEMPLARS_SPEC_DIR,     "#{model_name}_exemplar.rb"),   # Object Daddy
-             File.join(BLUEPRINTS_TEST_DIR,    "#{model_name}_blueprint.rb"),  # Machinist Blueprints
-             File.join(BLUEPRINTS_SPEC_DIR,    "#{model_name}_blueprint.rb"),  # Machinist Blueprints
-             File.join(FACTORY_GIRL_TEST_DIR,  "#{model_name}_factory.rb"),    # Factory Girl Factories
-             File.join(FACTORY_GIRL_SPEC_DIR,  "#{model_name}_factory.rb"),    # Factory Girl Factories
-             File.join(FABRICATORS_TEST_DIR,   "#{model_name}_fabricator.rb"), # Fabrication Fabricators
-             File.join(FABRICATORS_SPEC_DIR,   "#{model_name}_fabricator.rb"), # Fabrication Fabricators
-            ].each do |file|
-              remove_annotation_of_file(file) if File.exist?(file)
-            end
-
+            deannotated_klass = true if(remove_annotation_of_file(model_file_name))
+
+            TEST_PATTERNS.
+              map { |pat| [pat[0], resolve_filename(pat[1], model_name, table_name)]}.
+              map { |pat| find_test_file(*pat) }.each do |file|
+                if(File.exist?(file))
+                  remove_annotation_of_file(file)
+                  deannotated_klass = true
+                end
+              end
+
+            (FIXTURE_PATTERNS + FACTORY_PATTERNS).
+              map { |file| resolve_filename(file, model_name, table_name) }.
+              each do |file|
+                if File.exist?(file)
+                  remove_annotation_of_file(file)
+                  deannotated_klass = true
+                end
+              end
           end
+          deannotated << klass if(deannotated_klass)
         rescue Exception => e
           puts "Unable to deannotate #{file}: #{e.message}"
-          puts "\t" + e.backtrace.join("\n\t") if options[:trace]          
+          puts "\t" + e.backtrace.join("\n\t") if options[:trace]
         end
       end
-      puts "Removed annotation from: #{deannotated.join(', ')}"
+      puts "Removed annotations from: #{deannotated.join(', ')}"
     end
 
     def find_test_file(dir, file_name)
       Dir.glob(File.join(dir, "**", file_name)).first || File.join(dir, file_name)
     end
+
+    def resolve_filename(filename_template, model_name, table_name)
+      return filename_template.
+        gsub('%MODEL_NAME%', model_name).
+        gsub('%TABLE_NAME%', table_name || model_name.pluralize)
+    end
   end
 end