annotaterb 4.0.0.beta.1

data/lib/annotate_rb/model_annotator/file_name_resolver.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    class FileNameResolver
+      class << self
+        def call(filename_template, model_name, table_name)
+          filename_template
+            .gsub('%MODEL_NAME%', model_name)
+            .gsub('%PLURALIZED_MODEL_NAME%', model_name.pluralize)
+            .gsub('%TABLE_NAME%', table_name || model_name.pluralize)
+        end
+      end
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/file_patterns.rb

@@ -0,0 +1,129 @@
+module AnnotateRb
+  module ModelAnnotator
+    # This module provides module method to get file paths.
+    module FilePatterns
+      # Controller files
+      CONTROLLER_DIR       = File.join('app', 'controllers')
+
+      # Active admin registry files
+      ACTIVEADMIN_DIR      = File.join('app', 'admin')
+
+      # Helper files
+      HELPER_DIR           = File.join('app', 'helpers')
+
+      # File.join for windows reverse bar compat?
+      # I dont use windows, can`t test
+      UNIT_TEST_DIR        = File.join('test', 'unit')
+      MODEL_TEST_DIR       = File.join('test', 'models') # since rails 4.0
+      SPEC_MODEL_DIR       = File.join('spec', 'models')
+
+      FIXTURE_TEST_DIR     = File.join('test', 'fixtures')
+      FIXTURE_SPEC_DIR     = File.join('spec', 'fixtures')
+
+      # Other test files
+      CONTROLLER_TEST_DIR  = File.join('test', 'controllers')
+      CONTROLLER_SPEC_DIR  = File.join('spec', 'controllers')
+      REQUEST_SPEC_DIR     = File.join('spec', 'requests')
+      ROUTING_SPEC_DIR     = File.join('spec', 'routing')
+
+      # Object Daddy http://github.com/flogic/object_daddy/tree/master
+      EXEMPLARS_TEST_DIR   = File.join('test', 'exemplars')
+      EXEMPLARS_SPEC_DIR   = File.join('spec', 'exemplars')
+
+      # Machinist http://github.com/notahat/machinist
+      BLUEPRINTS_TEST_DIR  = File.join('test', 'blueprints')
+      BLUEPRINTS_SPEC_DIR  = File.join('spec', 'blueprints')
+
+      # Factory Bot https://github.com/thoughtbot/factory_bot
+      FACTORY_BOT_TEST_DIR = File.join('test', 'factories')
+      FACTORY_BOT_SPEC_DIR = File.join('spec', 'factories')
+
+      # Fabrication https://github.com/paulelliott/fabrication.git
+      FABRICATORS_TEST_DIR = File.join('test', 'fabricators')
+      FABRICATORS_SPEC_DIR = File.join('spec', 'fabricators')
+
+      # Serializers https://github.com/rails-api/active_model_serializers
+      SERIALIZERS_DIR      = File.join('app',  'serializers')
+      SERIALIZERS_TEST_DIR = File.join('test', 'serializers')
+      SERIALIZERS_SPEC_DIR = File.join('spec', 'serializers')
+
+      class << self
+        def generate(root_directory, pattern_type, options)
+          case pattern_type
+          when 'test'       then test_files(root_directory)
+          when 'fixture'    then fixture_files(root_directory)
+          when 'scaffold'   then scaffold_files(root_directory)
+          when 'factory'    then factory_files(root_directory)
+          when 'serializer' then serialize_files(root_directory)
+          when 'additional_file_patterns'
+            [options[:additional_file_patterns] || []].flatten
+          when 'controller'
+            [File.join(root_directory, CONTROLLER_DIR, '%PLURALIZED_MODEL_NAME%_controller.rb')]
+          when 'admin'
+            [
+              File.join(root_directory, ACTIVEADMIN_DIR, '%MODEL_NAME%.rb'),
+              File.join(root_directory, ACTIVEADMIN_DIR, '%PLURALIZED_MODEL_NAME%.rb')
+            ]
+          when 'helper'
+            [File.join(root_directory, HELPER_DIR, '%PLURALIZED_MODEL_NAME%_helper.rb')]
+          else
+            []
+          end
+        end
+
+        private
+
+        def test_files(root_directory)
+          [
+            File.join(root_directory, UNIT_TEST_DIR,  '%MODEL_NAME%_test.rb'),
+            File.join(root_directory, MODEL_TEST_DIR, '%MODEL_NAME%_test.rb'),
+            File.join(root_directory, SPEC_MODEL_DIR, '%MODEL_NAME%_spec.rb')
+          ]
+        end
+
+        def fixture_files(root_directory)
+          [
+            File.join(root_directory, FIXTURE_TEST_DIR, '%TABLE_NAME%.yml'),
+            File.join(root_directory, FIXTURE_SPEC_DIR, '%TABLE_NAME%.yml'),
+            File.join(root_directory, FIXTURE_TEST_DIR, '%PLURALIZED_MODEL_NAME%.yml'),
+            File.join(root_directory, FIXTURE_SPEC_DIR, '%PLURALIZED_MODEL_NAME%.yml')
+          ]
+        end
+
+        def scaffold_files(root_directory)
+          [
+            File.join(root_directory, CONTROLLER_TEST_DIR, '%PLURALIZED_MODEL_NAME%_controller_test.rb'),
+            File.join(root_directory, CONTROLLER_SPEC_DIR, '%PLURALIZED_MODEL_NAME%_controller_spec.rb'),
+            File.join(root_directory, REQUEST_SPEC_DIR,    '%PLURALIZED_MODEL_NAME%_spec.rb'),
+            File.join(root_directory, ROUTING_SPEC_DIR,    '%PLURALIZED_MODEL_NAME%_routing_spec.rb')
+          ]
+        end
+
+        def factory_files(root_directory)
+          [
+            File.join(root_directory, EXEMPLARS_TEST_DIR,   '%MODEL_NAME%_exemplar.rb'),
+            File.join(root_directory, EXEMPLARS_SPEC_DIR,   '%MODEL_NAME%_exemplar.rb'),
+            File.join(root_directory, BLUEPRINTS_TEST_DIR,  '%MODEL_NAME%_blueprint.rb'),
+            File.join(root_directory, BLUEPRINTS_SPEC_DIR,  '%MODEL_NAME%_blueprint.rb'),
+            File.join(root_directory, FACTORY_BOT_TEST_DIR, '%MODEL_NAME%_factory.rb'),    # (old style)
+            File.join(root_directory, FACTORY_BOT_SPEC_DIR, '%MODEL_NAME%_factory.rb'),    # (old style)
+            File.join(root_directory, FACTORY_BOT_TEST_DIR, '%TABLE_NAME%.rb'),            # (new style)
+            File.join(root_directory, FACTORY_BOT_SPEC_DIR, '%TABLE_NAME%.rb'),            # (new style)
+            File.join(root_directory, FACTORY_BOT_TEST_DIR, '%PLURALIZED_MODEL_NAME%.rb'), # (new style)
+            File.join(root_directory, FACTORY_BOT_SPEC_DIR, '%PLURALIZED_MODEL_NAME%.rb'), # (new style)
+            File.join(root_directory, FABRICATORS_TEST_DIR, '%MODEL_NAME%_fabricator.rb'),
+            File.join(root_directory, FABRICATORS_SPEC_DIR, '%MODEL_NAME%_fabricator.rb')
+          ]
+        end
+
+        def serialize_files(root_directory)
+          [
+            File.join(root_directory, SERIALIZERS_DIR,      '%MODEL_NAME%_serializer.rb'),
+            File.join(root_directory, SERIALIZERS_TEST_DIR, '%MODEL_NAME%_serializer_test.rb'),
+            File.join(root_directory, SERIALIZERS_SPEC_DIR, '%MODEL_NAME%_serializer_spec.rb')
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/helper.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    module Helper
+      MATCHED_TYPES = %w(test fixture factory serializer scaffold controller helper).freeze
+
+      class << self
+        def matched_types(options)
+          types = MATCHED_TYPES.dup
+          types << 'admin' if options[:active_admin] =~ Constants::TRUE_RE && !types.include?('admin')
+          types << 'additional_file_patterns' if options[:additional_file_patterns].present?
+
+          types
+        end
+
+        def magic_comments_as_string(content)
+          magic_comments = content.scan(Annotator::MAGIC_COMMENT_MATCHER).flatten.compact
+
+          if magic_comments.any?
+            magic_comments.join
+          else
+            ''
+          end
+        end
+
+        def skip_on_migration?
+          Env.read('ANNOTATE_SKIP_ON_DB_MIGRATE') =~ Constants::TRUE_RE || Env.read('skip_on_db_migrate') =~ Constants::TRUE_RE
+        end
+
+        def include_routes?
+          Env.read('routes') =~ Constants::TRUE_RE
+        end
+
+        def include_models?
+          Env.read('models') =~ Constants::TRUE_RE
+        end
+
+        def true?(val)
+          val.present? && Constants::TRUE_RE.match?(val)
+        end
+
+        # TODO: Find another implementation that doesn't depend on ActiveSupport
+        def fallback(*args)
+          args.compact.detect(&:present?)
+        end
+
+        def reset_options(options)
+          options.flatten.each { |key| Env.write(key, nil) }
+        end
+      end
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/model_class_getter.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    class ModelClassGetter
+      class << self
+        # 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 call(file, options)
+          model_path = file.gsub(/\.rb$/, '')
+          options[:model_dir].each { |dir| model_path = model_path.gsub(/^#{dir}/, '').gsub(/^\//, '') }
+
+          begin
+            get_loaded_model(model_path, file) || raise(BadModelFileError.new)
+          rescue LoadError
+            # this is for non-rails projects, which don't get Rails auto-require magic
+            file_path = File.expand_path(file)
+            if File.file?(file_path) && Kernel.require(file_path)
+              retry
+            elsif model_path =~ /\//
+              model_path = model_path.split('/')[1..-1].join('/').to_s
+              retry
+            else
+              raise
+            end
+          end
+        end
+
+        private
+
+        # Retrieve loaded model class
+        def get_loaded_model(model_path, file)
+          loaded_model_class = get_loaded_model_by_path(model_path)
+          return loaded_model_class if loaded_model_class
+
+          # We cannot get loaded model when `model_path` is loaded by Rails
+          # auto_load/eager_load paths. Try all possible model paths one by one.
+          absolute_file = File.expand_path(file)
+          model_paths =
+            $LOAD_PATH.select { |path| absolute_file.include?(path) }
+                      .map { |path| absolute_file.sub(path, '').sub(/\.rb$/, '').sub(/^\//, '') }
+          model_paths
+            .map { |path| get_loaded_model_by_path(path) }
+            .find { |loaded_model| !loaded_model.nil? }
+        end
+
+        # Retrieve loaded model class by path to the file where it's supposed to be defined.
+        def get_loaded_model_by_path(model_path)
+          ::ActiveSupport::Inflector.constantize(::ActiveSupport::Inflector.camelize(model_path))
+        rescue StandardError, LoadError
+          # Revert to the old way but it is not really robust
+          ObjectSpace.each_object(::Class)
+                     .select do |c|
+            Class === c && # note: we use === to avoid a bug in activesupport 2.3.14 OptionMerger vs. is_a?
+              c.ancestors.respond_to?(:include?) && # to fix FactoryGirl bug, see https://github.com/ctran/annotate_models/pull/82
+              c.ancestors.include?(::ActiveRecord::Base)
+          end.detect { |c| ::ActiveSupport::Inflector.underscore(c.to_s) == model_path }
+        end
+      end
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/model_file_annotator.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    # Not sure yet what the difference is between this and FileAnnotator
+    class ModelFileAnnotator
+      class << self
+        def call(annotated, file, header, options)
+          begin
+            return false if /#{Constants::SKIP_ANNOTATION_PREFIX}.*/ =~ (File.exist?(file) ? File.read(file) : '')
+            klass = ModelClassGetter.call(file, options)
+
+            klass_is_a_class = klass.is_a?(Class)
+            klass_inherits_active_record_base = klass < ActiveRecord::Base
+            klass_is_not_abstract = !klass.abstract_class?
+            klass_table_exists = klass.table_exists?
+
+            not_sure_this_conditional = (!options[:exclude_sti_subclasses] || !(klass.superclass < ActiveRecord::Base && klass.table_name == klass.superclass.table_name))
+
+            annotate_conditions = [
+              klass_is_a_class,
+              klass_inherits_active_record_base,
+              not_sure_this_conditional,
+              klass_is_not_abstract,
+              klass_table_exists
+            ]
+
+            do_annotate = annotate_conditions.all?
+
+            if do_annotate
+              files_annotated = annotate(klass, file, header, options)
+              annotated.concat(files_annotated)
+            end
+
+          rescue BadModelFileError => e
+            unless options[:ignore_unknown_models]
+              $stderr.puts "Unable to annotate #{file}: #{e.message}"
+              $stderr.puts "\t" + e.backtrace.join("\n\t") if options[:trace]
+            end
+          rescue StandardError => e
+            $stderr.puts "Unable to annotate #{file}: #{e.message}"
+            $stderr.puts "\t" + e.backtrace.join("\n\t") if options[:trace]
+          end
+        end
+
+        private
+
+        # Given the name of an ActiveRecord class, create a schema
+        # info block (basically a comment containing information
+        # on the columns and their types) and put it at the front
+        # of the model and fixture source files.
+        #
+        # === 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
+        #  :position_in_serializer<Symbol>:: where to place the annotated section in serializer 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
+        #  :exclude_serializers<Symbol>:: whether to skip modification of serializer files
+        #  :exclude_scaffolds<Symbol>:: whether to skip modification of scaffold files
+        #  :exclude_controllers<Symbol>:: whether to skip modification of controller files
+        #  :exclude_helpers<Symbol>:: whether to skip modification of helper files
+        #  :exclude_sti_subclasses<Symbol>:: whether to skip modification of files for STI subclasses
+        #
+        # == Returns:
+        # an array of file names that were annotated.
+        #
+        def annotate(klass, file, header, options = {})
+          begin
+            klass.reset_column_information
+            info = SchemaInfo.generate(klass, header, options)
+            model_name = klass.name.underscore
+            table_name = klass.table_name
+            model_file_name = File.join(file)
+            annotated = []
+
+            if FileAnnotator.call(model_file_name, info, :position_in_class, options)
+              annotated << model_file_name
+            end
+
+            Helper.matched_types(options).each do |key|
+              exclusion_key = "exclude_#{key.pluralize}".to_sym
+              position_key = "position_in_#{key}".to_sym
+
+              # Same options for active_admin models
+              if key == 'admin'
+                exclusion_key = 'exclude_class'.to_sym
+                position_key = 'position_in_class'.to_sym
+              end
+
+              next if options[exclusion_key]
+
+              patterns = PatternGetter.call(options, key)
+
+              patterns
+                .map { |f| FileNameResolver.call(f, model_name, table_name) }
+                .map { |f| Dir.glob(f) }
+                .flatten
+                .each do |f|
+                if FileAnnotator.call(f, info, position_key, options)
+                  annotated << f
+                end
+              end
+            end
+          rescue StandardError => e
+            $stderr.puts "Unable to annotate #{file}: #{e.message}"
+            $stderr.puts "\t" + e.backtrace.join("\n\t") if options[:trace]
+          end
+
+          annotated
+        end
+      end
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/model_files_getter.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    class ModelFilesGetter
+      class << self
+        # Return a list of the model files to annotate.
+        # If we have command line arguments, they're assumed to the path
+        # of model files from root dir. Otherwise we take all the model files
+        # in the model_dir directory.
+        def call(options)
+          model_files = []
+
+          model_files = list_model_files_from_argument(options) if !options[:is_rake]
+
+          return model_files if !model_files.empty?
+
+          options[:model_dir].each do |dir|
+            Dir.chdir(dir) do
+              list = if options[:ignore_model_sub_dir]
+                       Dir["*.rb"].map { |f| [dir, f] }
+                     else
+                       Dir["**/*.rb"].reject { |f| f["concerns/"] }.map { |f| [dir, f] }
+                     end
+              model_files.concat(list)
+            end
+          end
+
+          model_files
+        rescue SystemCallError
+          $stderr.puts "No models found in directory '#{options[:model_dir].join("', '")}'."
+          $stderr.puts "Either specify models on the command line, or use the --model-dir option."
+          $stderr.puts "Call 'annotate --help' for more info."
+          # exit 1 # TODO: Return exit code back to caller. Right now it messes up RSpec being able to run
+        end
+
+        private
+
+        def list_model_files_from_argument(options)
+          return [] if ARGV.empty?
+
+          specified_files = ARGV.map { |file| File.expand_path(file) }
+
+          model_files = options[:model_dir].flat_map do |dir|
+            absolute_dir_path = File.expand_path(dir)
+            specified_files
+              .find_all { |file| file.start_with?(absolute_dir_path) }
+              .map { |file| [dir, file.sub("#{absolute_dir_path}/", '')] }
+          end
+
+          if model_files.size != specified_files.size
+            $stderr.puts "The specified file could not be found in directory '#{options[:model_dir].join("', '")}'."
+            $stderr.puts "Call 'annotate --help' for more info."
+            # exit 1 # TODO: Return exit code back to caller. Right now it messes up RSpec being able to run
+          end
+
+          model_files
+        end
+      end
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/pattern_getter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    class PatternGetter
+      class << self
+        def call(options, pattern_types = [])
+          current_patterns = []
+
+          options[:root_dir].each do |root_directory|
+            Array(pattern_types).each do |pattern_type|
+              patterns = FilePatterns.generate(root_directory, pattern_type, options)
+
+              current_patterns += if pattern_type.to_sym == :additional_file_patterns
+                                    patterns
+                                  else
+                                    patterns.map { |p| p.sub(/^[\/]*/, '') }
+                                  end
+            end
+          end
+
+          current_patterns
+        end
+      end
+    end
+  end
+end