shoulda_matchmakers 0.1.0

data/lib/generators/shoulda_matchmakers/factory_generator.rb

@@ -0,0 +1,86 @@
+require 'haml'
+require_relative 'model_matcher_generator_helper'
+require 'model/active_record/factory_sm_model'
+require 'spin_to_win'
+
+module ShouldaMatchmakers
+  class FactoryGenerator < ::Rails::Generators::Base
+
+    include Generator::ActiveRecord::ModelMatcherGeneratorHelper
+
+    source_root(File.expand_path(File.dirname(__FILE__)))
+
+    class_option :include, type:    :array,
+                           require: false,
+                           aliases: '-i',
+                           default: [],
+                           desc:    "Sets list of application ActiveRecord class names of models to INCLUDE in generated factories.\n" +
+                                    "                                              By default, factories are generated for all ActiveRecord::Base descendant class models.\n" +
+                                    "                                              When used, '_included' and '_excluded' settings in '~/config/initializers/shoulda_matchmakers.rb'\n" +
+                                    "                                              configuration file are ignored. Example (space delimited, include namespaces):\n\n" +
+                                    "                                              -i Driver License Vehicle::Car Vehicle::Bus\n\n\n"
+
+    class_option :exclude, type:    :array,
+                           require: false,
+                           aliases: '-e',
+                           default: [],
+                           desc:    "Sets list of application ActiveRecord class names of models to EXCLUDE from generated factories.\n" +
+                                    "                                              By default, no ActiveRecord::Base descendant class models are excluded from generated factories.\n" +
+                                    "                                              When used, '_included' and '_excluded' settings in '~/config/initializers/shoulda_matchmakers.rb'\n" +
+                                    "                                              configuration file are ignored. Example (space delimited, include namespaces):\n\n" +
+                                    "                                              -e Driver Vehicle::Car\n\n\n"
+
+    class_option :include_and_config, type:    :array,
+                                       require: false,
+                                       aliases: '-I',
+                                       default: [],
+                                       desc:    "Same as '-i/-include', except that '_included' and '_excluded' settings in\n" +
+                                                "                                              '~/config/initializers/shoulda_matchmakers.rb' are not ignored. Configuration file\n" +
+                                                "                                              settings are applied first then the class names listed with this option are applied.\n" +
+                                                "                                              Example (space delimited, include namespaces):\n\n" +
+                                                "                                              -I Driver License Vehicle::Car Vehicle::Bus\n\n\n"
+
+    class_option :exclude_and_config, type:    :array,
+                                       require: false,
+                                       aliases: '-E',
+                                       default: [],
+                                       desc:    "Same as '-e/-exclude', except that '_included' and '_excluded' settings in\n" +
+                                                "                                              '~/config/initializers/shoulda_matchmakers.rb' are not ignored. Configuration file\n" +
+                                                "                                              settings are applied first then the class names listed with this option are applied.\n" +
+                                                "                                              Example (space delimited, include namespaces):\n\n" +
+                                                "                                              -E Driver Vehicle::Car\n\n\n"
+
+    def create_model_factories
+      puts "\n"
+      generator = "factory"
+      generator_options = options.to_hash
+      working_generated_code_line_length = ::ShouldaMatchmakers.configuration.preferred_generated_code_line_length - 6
+      SpinToWin.with_spinner('ShouldaMatchmakers:Factories') do |spinner|
+        spinner.banner('initializing...')
+        load_application
+        @app_active_record_descendants_names = get_app_active_record_descendants_names
+      end
+      puts "\n"
+      generate_active_record_model_factories(generator, generator_options, @app_active_record_descendants_names, working_generated_code_line_length)
+    end
+
+
+    private
+
+    def generate_active_record_model_factories(generator, generator_options, app_active_record_descendants_names, code_line_length)
+      if app_active_record_descendants_names.present?
+        selected_app_active_record_descendants_names = filter_app_active_record_descendants_names(generator, generator_options, app_active_record_descendants_names)
+        selected_app_active_record_descendants_names.each do |app_class_name|
+          save_generate(app_class_name, generator) do
+            @active_record_model_factory_sm_model = ::ShouldaMatchmakers::Model::ActiveRecord::FactorySmModel.new(app_class_name, code_line_length)
+            template_filename = File.expand_path('../../templates/factory/active_record/factory_template.haml', File.dirname(__FILE__))
+            template = File.read(template_filename)
+            create_file "#{ ::ShouldaMatchmakers.configuration.active_record_model_factories_path }/#{ app_class_name.underscore }_factory.rb",
+              Haml::Engine.new(template, filename: template_filename, format: :html5).to_html(binding)
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/generators/shoulda_matchmakers/install_generator.rb

@@ -0,0 +1,10 @@
+module ShouldaMatchmakers
+  class InstallGenerator < Rails::Generators::Base
+    source_root(File.expand_path(File.dirname(__FILE__)))
+
+    def copy_initializer
+      copy_file '../../templates/shoulda_matchmakers.rb', 'config/initializers/shoulda_matchmakers.rb'
+    end
+
+  end
+end

data/lib/generators/shoulda_matchmakers/model_matcher_generator.rb

@@ -0,0 +1,87 @@
+require 'haml'
+require_relative 'model_matcher_generator_helper'
+require 'model/active_record/active_record_model_sm_model'
+require 'spin_to_win'
+
+module ShouldaMatchmakers
+  class ModelMatcherGenerator < ::Rails::Generators::Base
+
+    include Generator::ActiveRecord::ModelMatcherGeneratorHelper
+
+    source_root(File.expand_path(File.dirname(__FILE__)))
+
+    class_option :include, type:    :array,
+                           require: false,
+                           aliases: '-i',
+                           default: [],
+                           desc:    "Sets list of application ActiveRecord models to INCLUDE in generated tests.\n" +
+                                    "                                              By default, tests are generated for all ActiveRecord::Base descendant classes.\n" +
+                                    "                                              When used, '_included' and '_excluded' settings in '~/config/initializers/shoulda_matchmakers.rb'\n" +
+                                    "                                              configuration file are ignored. Example (space delimited, include namespaces):\n\n" +
+                                    "                                              -i Driver License Vehicle::Car Vehicle::Bus\n\n\n"
+
+    class_option :exclude, type:    :array,
+                           require: false,
+                           aliases: '-e',
+                           default: [],
+                           desc:    "Sets list of application ActiveRecord models to EXCLUDE from generated tests.\n" +
+                                    "                                              By default, no ActiveRecord::Base descendant classes are excluded from generated tests.\n" +
+                                    "                                              When used, '_included' and '_excluded' settings in '~/config/initializers/shoulda_matchmakers.rb'\n" +
+                                    "                                              configuration file are ignored. Example (space delimited, include namespaces):\n\n" +
+                                    "                                              -e Driver Vehicle::Car\n\n\n"
+
+    class_option :include_and_config, type:    :array,
+                                       require: false,
+                                       aliases: '-I',
+                                       default: [],
+                                       desc:    "Same as '-i/-include', except that '_included' and '_excluded' settings in\n" +
+                                                "                                              '~/config/initializers/shoulda_matchmakers.rb' are not ignored. Configuration file\n" +
+                                                "                                              settings are applied first then the class names listed with this option are applied.\n" +
+                                                "                                              Example (space delimited, include namespaces):\n\n" +
+                                                "                                              -I Driver License Vehicle::Car Vehicle::Bus\n\n\n"
+
+    class_option :exclude_and_config, type:    :array,
+                                       require: false,
+                                       aliases: '-E',
+                                       default: [],
+                                       desc:    "Same as '-e/-exclude', except that '_included' and '_excluded' settings in\n" +
+                                                "                                              '~/config/initializers/shoulda_matchmakers.rb' are not ignored. Configuration file\n" +
+                                                "                                              settings are applied first then the class names listed with this option are applied.\n" +
+                                                "                                              Example (space delimited, include namespaces):\n\n" +
+                                                "                                              -E Driver Vehicle::Car\n\n\n"
+
+    def create_model_matchmakers
+      puts "\n"
+      generator = "model"
+      generator_options = options.to_hash
+      working_generated_code_line_length = ::ShouldaMatchmakers.configuration.preferred_generated_code_line_length - 6
+      SpinToWin.with_spinner('ShouldaMatchmakers:ModelMatchers') do |spinner|
+        spinner.banner('initializing...')
+        load_application
+        @app_active_record_descendants_names = get_app_active_record_descendants_names
+      end
+      puts "\n"
+      generate_active_record_model_matchmakers(generator, generator_options, @app_active_record_descendants_names, working_generated_code_line_length)
+    end
+
+
+    private
+
+    def generate_active_record_model_matchmakers(generator, generator_options, app_active_record_descendants_names, code_line_length)
+      if app_active_record_descendants_names.present?
+        selected_app_active_record_descendants_names = filter_app_active_record_descendants_names(generator, generator_options, app_active_record_descendants_names)
+        selected_app_active_record_descendants_names.each do |app_class_name|
+          save_generate(app_class_name, generator) do
+            @active_record_model_sm_model = ::ShouldaMatchmakers::Model::ActiveRecord::ActiveRecordModelSmModel.new(app_class_name, app_active_record_descendants_names, code_line_length)
+            template_filename = File.expand_path('../../templates/model/active_record/model_spec_template.haml', File.dirname(__FILE__))
+            template = File.read(template_filename)
+            create_file "#{ ::ShouldaMatchmakers.configuration.active_record_model_tests_path }/#{ app_class_name.underscore }_spec.rb",
+              Haml::Engine.new(template, filename: template_filename, format: :html5).to_html(binding)
+          end
+        end
+      end
+    end
+
+  end
+end
+

data/lib/generators/shoulda_matchmakers/model_matcher_generator_helper.rb

@@ -0,0 +1,107 @@
+module ShouldaMatchmakers
+  module Generator
+    module ActiveRecord
+      module ModelMatcherGeneratorHelper
+
+        def load_application
+          Rails.application.try(:eager_load!)
+        end
+
+        def get_app_active_record_descendants_names
+          if defined?(::ActiveRecord::Base)
+            ::ActiveRecord::Base.descendants.map(&:name)
+          else
+            []
+          end
+        end
+
+        def save_generate(class_name, generator)
+          begin
+            yield
+          rescue => e
+            if generator == "model"
+              puts "Cannot create model spec for #{ class_name }. Reason #{ e.message }"
+            else
+              puts "Cannot create factory for #{ class_name }. Reason #{ e.message }"
+            end
+          end
+        end
+
+        def filter_app_active_record_descendants_names(generator, generator_options, app_active_record_class_names)
+
+          generator_include_option_active_record_class_names = generator_options.fetch('include')
+          generator_exclude_option_active_record_class_names = generator_options.fetch('exclude')
+          generator_include_and_config_options_active_record_class_names = generator_options.fetch('include_and_config')
+          generator_exclude_and_config_options_active_record_class_names = generator_options.fetch('exclude_and_config')
+
+          if generator_include_option_active_record_class_names.present?
+            filter_active_record_class_names_with_include_option(app_active_record_class_names, generator_include_option_active_record_class_names)
+
+          elsif generator_exclude_option_active_record_class_names.present?
+            filter_active_record_class_names_with_exclude_option(app_active_record_class_names, generator_exclude_option_active_record_class_names)
+
+          elsif generator_include_and_config_options_active_record_class_names.present?
+            filter_active_record_class_names_with_generator_include_and_config_options(app_active_record_class_names, generator_include_and_config_options_active_record_class_names, generator)
+
+          elsif generator_exclude_and_config_options_active_record_class_names.present?
+            filter_active_record_class_names_with_generator_exclude_and_config_options(app_active_record_class_names, generator_exclude_and_config_options_active_record_class_names, generator)
+
+          else
+            selected_app_active_record_class_names = filter_active_record_class_names_with_config_options(app_active_record_class_names, generator)
+            if selected_app_active_record_class_names.present?
+              selected_app_active_record_class_names
+            else
+              app_active_record_class_names.uniq.sort
+            end
+          end
+
+        end
+
+        def filter_active_record_class_names_with_include_option(app_active_record_class_names, include_option_active_record_class_names)
+          app_active_record_class_names.map.select { |app_class_name| include_option_active_record_class_names.include? app_class_name }.uniq.sort
+        end
+
+        def filter_active_record_class_names_with_exclude_option(app_active_record_class_names, exclude_option_active_record_class_names)
+          app_active_record_class_names.map.reject { |app_class_name| exclude_option_active_record_class_names.include? app_class_name }.uniq.sort
+        end
+
+        def filter_active_record_class_names_with_generator_include_and_config_options(app_active_record_class_names, generator_include_and_config_options_active_record_class_names, generator)
+          selected_app_active_record_class_names = filter_active_record_class_names_with_config_options(app_active_record_class_names, generator)
+          if selected_app_active_record_class_names.present?
+            selected_app_active_record_class_names +
+              filter_active_record_class_names_with_include_option(app_active_record_class_names, generator_include_and_config_options_active_record_class_names).uniq.sort
+          else
+            filter_active_record_class_names_with_include_option(app_active_record_class_names, generator_include_and_config_options_active_record_class_names).uniq.sort
+          end
+        end
+
+        def filter_active_record_class_names_with_generator_exclude_and_config_options(app_active_record_class_names, generator_exclude_and_config_options_active_record_class_names, generator)
+          selected_active_record_model_names = filter_active_record_class_names_with_config_options(app_active_record_class_names, generator)
+          if selected_active_record_model_names.present?
+            filter_active_record_class_names_with_exclude_option(selected_active_record_model_names, generator_exclude_and_config_options_active_record_class_names).uniq.sort
+          else
+            filter_active_record_class_names_with_exclude_option(app_active_record_class_names, generator_exclude_and_config_options_active_record_class_names).uniq.sort
+          end
+        end
+
+        def filter_active_record_class_names_with_config_options(app_active_record_class_names, generator)
+          if generator == "model"
+            config_included_option_active_record_class_names = ::ShouldaMatchmakers.configuration.active_record_class_names_included
+            config_excluded_option_active_record_class_names = ::ShouldaMatchmakers.configuration.active_record_class_names_excluded
+          else
+            config_included_option_active_record_class_names = ::ShouldaMatchmakers.configuration.active_record_model_class_names_for_factories_included
+            config_excluded_option_active_record_class_names = ::ShouldaMatchmakers.configuration.active_record_model_class_names_for_factories_excluded
+          end
+          if config_included_option_active_record_class_names.present?
+            filter_active_record_class_names_with_include_option(app_active_record_class_names, config_included_option_active_record_class_names).uniq.sort
+          elsif config_excluded_option_active_record_class_names.present?
+            filter_active_record_class_names_with_exclude_option(app_active_record_class_names, config_excluded_option_active_record_class_names).uniq.sort
+          else
+            []
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/model/active_record/active_record_model_sm_model.rb

@@ -0,0 +1,50 @@
+require_relative 'matchmakers/accept_nested_attributes_for'
+require_relative 'matchmakers/allow_value'
+require_relative 'matchmakers/associations'
+require_relative 'matchmakers/define_enum_for'
+require_relative 'matchmakers/delegate_method'
+require_relative 'matchmakers/have_db_column'
+require_relative 'matchmakers/have_db_index'
+require_relative 'matchmakers/have_readonly_attribute'
+require_relative 'matchmakers/have_secure_password'
+require_relative 'matchmakers/serialize'
+require_relative 'matchmakers/validations'
+require_relative 'active_record_model_sm_model_helper'
+
+
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      class ActiveRecordModelSmModel
+
+        ### Includes ###
+        include Matchmaker::AllowValue
+        include Matchmaker::Associations
+        include Matchmaker::AcceptNestedAttributesFor
+        include Matchmaker::DefineEnumFor
+        include Matchmaker::DelegateMethod
+        include Matchmaker::HaveDbColumn
+        include Matchmaker::HaveDbIndex
+        include Matchmaker::HaveReadonlyAttribute
+        include Matchmaker::HaveSecurePassword
+        include Matchmaker::Serialize
+        include Matchmaker::Validations
+        include ActiveRecordModelSmModelHelper
+
+
+        ### Attribute Accessors ###
+        attr_accessor :app_class_name,
+                      :working_generated_code_line_length
+
+
+        ### Methods ###
+        def initialize(app_class_name, app_active_record_descendants_names, code_line_length)
+          @app_class_name = app_class_name
+          @app_active_record_descendants_names = app_active_record_descendants_names
+          @working_generated_code_line_length = code_line_length
+        end
+
+      end
+    end
+  end
+end

data/lib/model/active_record/active_record_model_sm_model_helper.rb

@@ -0,0 +1,206 @@
+require 'model/active_record/options_definition'
+
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      module ActiveRecordModelSmModelHelper
+
+
+        def compose_extended_model_file_path(app_class_name)
+          Rails.root.join("app", "models").to_s + "/" + app_class_name.underscore.concat(".rb")
+        end
+
+        def extract_validators(app_class_name, validator_type)
+          extracted_validators = app_class_name.constantize.validators.select do |validator|
+                                   validator.class.to_s == validator_type.to_s
+                                 end
+          extracted_validators.flatten
+        end
+
+        def conditional_options_exist(validator_options)
+          if validator_options.key?(:if) || validator_options.key?(:unless)
+            true
+          else
+            false
+          end
+        end
+
+        def parse_validator_options(validator_options)
+          non_conditional_options = validator_options
+          if validator_options.key?(:if)
+            if_option_values = non_conditional_options.delete(:if)
+            if_option_values = [if_option_values] if !if_option_values.is_a?(Array)
+          else
+            if_option_values = []
+          end
+          if validator_options.key?(:unless)
+            unless_option_values = non_conditional_options.delete(:unless)
+            unless_option_values = [unless_option_values] if !unless_option_values.is_a?(Array)
+          else
+            unless_option_values = []
+          end
+          { non_conditional_options: non_conditional_options, if_option_values: if_option_values, unless_option_values: unless_option_values }
+        end
+
+        def order_options(options)
+          options_unordered = options.dup
+          options_ordered = {}
+          options_ordered = options_ordered.merge({ :in=>options_unordered.delete(:in) }) if options_unordered.include?(:in)
+          options_ordered = options_ordered.merge({ :minimum=>options_unordered.delete(:minimum) }) if options_unordered.include?(:minimum)
+          options_ordered = options_ordered.merge({ :maximum=>options_unordered.delete(:maximum) }) if options_unordered.include?(:maximum)
+          options_ordered.merge(options_unordered)
+        end
+
+        def all_option_values_are_symbols(option_values)
+          option_values_are_symbols = true
+          if option_values.present?
+            option_values.each do |option_value|
+              if !option_value.is_a?(Symbol)
+                option_values_are_symbols = false
+              end
+            end
+          end
+          option_values_are_symbols
+        end
+
+        def get_possible_true_false_permutations(validator_options)
+          number_of_conditional_option_values = validator_options[:if_option_values].size +
+                                                  validator_options[:unless_option_values].size
+          [true, false].repeated_permutation(number_of_conditional_option_values).to_a
+        end
+
+        def get_validating_true_false_permutation(validator_options)
+          validating_permutation = []
+          validator_options[:if_option_values].size.times do |n|
+            validating_permutation << true
+          end
+          validator_options[:unless_option_values].size.times do |n|
+            validating_permutation << false
+          end
+          validating_permutation
+        end
+
+        def get_options_string(options)
+          options_hash = ::ShouldaMatchmakers::Model::ActiveRecord::OptionsDefinition.new.options_hash
+          options_string = ""
+          options.map do |option_key, option_value|
+           if options_hash.key?(option_key)
+              option_string = options_hash[option_key].to_s
+              option_value_refined = apply_option_value_qualifiers(option_value, option_string)
+              option_string = option_string.gsub(/\s*\{\s*/,"").gsub(/\s*\}\s*/,"").gsub(/option_value(?:\.[a-zA-Z0-9_]+)*/, option_value_refined)
+              options_string.concat("." + option_string)
+            end
+          end
+          options_string
+        end
+
+        def apply_option_value_qualifiers(option_value, association_option_string)
+          option_value_refined = option_value
+          option_value_qualifiers = association_option_string.scan(/(?: option_value|\.[a-zA-Z0-9_]+)(\.[a-zA-Z0-9_]+)/)
+          option_value_qualifiers.each do |option_value_qualifier|
+            case option_value_qualifier
+              when ".first"
+                option_value_refined = option_value_refined.first
+              when ".last"
+                option_value_refined = option_value_refined.last
+              when ".to_s"
+                option_value_refined = option_value_refined.to_s
+            end
+          end
+          option_value_refined.to_s
+        end
+
+        def compose_conditional_validating_context_string(validator_options)
+          validating_context_string = "  context \""
+          conditional_option_values = validator_options[:if_option_values] + validator_options[:unless_option_values]
+          conditional_option_values.each_with_index do |option_value, cov_index|
+            if cov_index < validator_options[:if_option_values].size
+              validating_context_string.concat("if #{ option_value.to_s.chomp('?')} and ")
+            else
+              validating_context_string.concat("unless #{ option_value.to_s.chomp('?')} and ")
+            end
+          end
+          validating_context_string.chomp!(" and ").concat("\" do\n")
+        end
+
+        def compose_conditional_non_validating_context_string(validator_options, non_validating_permutation)
+          non_validating_context_string = "  context \""
+          conditional_option_values = validator_options[:if_option_values] + validator_options[:unless_option_values]
+          conditional_option_values.each_with_index do |conditional_option_value, cov_index|
+            if cov_index < validator_options[:if_option_values].size
+              non_validating_context_string.concat(get_if_context_condition(conditional_option_value, non_validating_permutation[cov_index]))
+            else
+              non_validating_context_string.concat(get_unless_context_condition(conditional_option_value, non_validating_permutation[cov_index]))
+            end
+          end
+          non_validating_context_string.chomp!(" and ").concat("\" do\n")
+        end
+
+        def get_if_context_condition(option_value, permutation_boolean_value_for_option)
+          if permutation_boolean_value_for_option
+            if_context_condition = "if #{ option_value.to_s.chomp('?')} and "
+          else
+            if_context_condition = "if not #{ option_value.to_s.chomp('?')} and "
+          end
+          if_context_condition
+        end
+
+        def get_unless_context_condition(option_value, permutation_boolean_value_for_option)
+          if permutation_boolean_value_for_option
+            unless_context_condition = "if (unless not) #{ option_value.to_s.chomp('?')} and "
+          else
+            unless_context_condition = "if not (unless) #{ option_value.to_s.chomp('?')} and "
+          end
+          unless_context_condition
+        end
+
+        def compose_conditional_before_strings(validator_options, conditional_options_permutation)
+          conditional_before_strings = ""
+          conditional_option_values = validator_options[:if_option_values] + validator_options[:unless_option_values]
+          conditional_option_values.each_with_index do |conditional_option_value, cov_index|
+            conditional_before_strings.concat("    before { allow(subject).to receive(:#{ conditional_option_value }).and_return(#{ conditional_options_permutation[cov_index] }) }\n")
+          end
+          conditional_before_strings
+        end
+
+        def append_element(element, element_set)
+          if element.present?
+            element_set << element
+          end
+          element_set
+        end
+
+        def adjust_conditional_test_indentation(conditional_test)
+          if conditional_test.include?("\n")
+            conditional_test.sub("  it do\n","\n    it do\n").
+                             sub("it do\n    ","it do\n      ").
+                             gsub(").\n    ",").\n      ").
+                             sub("\n  end","\n    end")
+          else
+            conditional_test.sub("  it {", "\n    it {")
+          end
+        end
+
+        def format_tests(tests)
+          formatted_tests = properly_line_space_tests(tests)
+          formatted_tests.flatten.compact.uniq.join("\n")
+        end
+
+        def properly_line_space_tests(tests)
+          tests_properly_line_spaced = []
+          previous_test = ""
+          tests.each do |test|
+            if (test.include?("\n") && previous_test.present?) ||
+                 (!test.include?("\n") && previous_test.include?("\n"))
+              test = "\n" + test
+            end
+            tests_properly_line_spaced << test
+            previous_test = test
+          end
+          tests_properly_line_spaced
+        end
+
+      end
+    end
+  end
+end