shoulda_matchmakers 0.1.0

data/lib/model/active_record/options_definition.rb

@@ -0,0 +1,160 @@
+module ShouldaMatchmakers
+  module Model
+    module ActiveRecord
+      class OptionsDefinition
+
+
+
+        ### Attribute Accessors ###
+        attr_accessor :options_hash
+
+        def initialize
+          @options_hash = {
+                                      allow_blank:              "allow_blank",
+                                      allow_destroy:            "allow_destroy({ option_value })",
+                                      allow_nil:                "allow_nil",
+                                      autosave:                 "autosave({ option_value })",
+                                      case_sensitive:           "case_insensitive",
+                                      class_name:               "class_name('{ option_value }')",
+                                      counter_cache:            "counter_cache({ option_value })",
+                                      dependent:                "dependent(:{ option_value })",
+                                      dependent_boolean:        "dependent({ option_value })",
+                                      equal_to:                 "is_equal_to({ option_value })",
+                                      even:                     "even",
+                                      foreign_key:              "with_foreign_key('{ option_value }')",
+                                      greater_than:             "is_greater_than({ option_value })",
+                                      greater_than_or_equal_to: "is_greater_than_or_equal_to({ option_value })",
+                                      in:                       "is_at_least({ option_value.first.to_s }).\n      is_at_most({ option_value.last.to_s })",
+                                      in_array:                 "in_array({ option_value })",
+                                      in_range:                 "in_range({ option_value })",
+                                      inverse_of:               "inverse_of(:{ option_value })",
+                                      is:                       "is_equal_to({ option_value.to_s })",
+                                      join_table:               "join_table('{ option_value }')",
+                                      less_than:                "is_less_than({ option_value })",
+                                      less_than_or_equal_to:    "is_less_than_or_equal_to({ option_value })",
+                                      limit:                    "limit({ option_value })",
+                                      maximum:                  "is_at_most({ option_value.to_s })",
+                                      message_double_quotes:    "with_message(\"{ option_value }\")",
+                                      message_single_quotes:    "with_message('{ option_value }')",
+                                      minimum:                  "is_at_least({ option_value.to_s })",
+                                      odd:                      "odd",
+                                      on:                       "on(:{ option_value })",
+                                      only_integer:             "only_integer",
+                                      order_double_quotes:      "order(\"{ option_value }\")",
+                                      order_single_quotes:      "order('{ option_value }')",
+                                      primary_key:              "with_primary_key('{ option_value }')",
+                                      scope:                    "scoped_to({ option_value })",
+                                      source:                   "source(:{ option_value })",
+                                      through:                  "through(:{ option_value })",
+                                      too_long_double_quotes:   "with_long_message(\"{ option_value }\")",
+                                      too_long_single_quotes:   "with_long_message('{ option_value }')",
+                                      too_short_double_quotes:  "with_short_message(\"{ option_value }\")",
+                                      too_short_single_quotes:  "with_short_message('{ option_value }')",
+                                      touch:                    "touch({ option_value })",
+                                      update_only:              "update_only({ option_value })",
+                                      validate:                 "validate({ option_value })"
+                                    }
+        end
+
+        # else
+        #    # IMPLEMENTATION TODO: Possibly handle this case option as an error or modify evaluation of option above upon return from call
+        #    ""
+
+        # ALLOW VALUE
+        # IMPLEMENTATION TODO: Determine if Shoulda Matchers recognizes the 'multiline' option
+        # when :multiline
+        #   "multiline(#{ option_value })"
+
+        # VALIDATE ACCEPTANCE OF
+        # IMPLEMENTATION TODO: Determine if Shoulda Matchers recognizes the 'accept' option
+        # when :accept
+        #   "accept('#{ option_value }')"
+
+        # VALIDATE EXCLUSION OF
+        # IMPLEMENTATION TODO: Determine if 'allow_blank' is a valid option
+        # when :allow_blank
+        #   "allow_blank"
+        # IMPLEMENTATION TODO: Determine if 'allow_nil' is a valid option
+        # when :allow_nil
+        #   "allow_nil"
+
+        # VALIDATE INCLUSION OF
+        # IMPLEMENTATION TODO: Determine if it is possible to implement 'with_low_message' and 'with_high_message'
+        # IMPLEMENTATION TODO: Determine if 'allow_blank' is a valid option
+        # when :allow_blank
+        #   "allow_blank"
+        # IMPLEMENTATION TODO: Determine if 'allow_nil' is a valid option
+        # when :allow_nil
+        #   "allow_nil"
+
+        # VALIDATE LENGTH OF
+        # IMPLEMENTATION TODO: Determine if it is possible to implement 'tokenizer'
+        # IMPLEMENTATION TODO: Determine if 'allow_blank' is a valid option
+        # when :allow_blank
+        #   "allow_blank"
+        # IMPLEMENTATION TODO: Determine if 'allow_nil' is a valid option
+        # when :allow_nil
+        #   "allow_nil"
+        # IMPLEMENTATION TODO: Determine if Shoulda Matchers recognizes the 'wrong_length' option
+        #   if option_value.include? '"'
+        #     "wrong_length('#{ option_value }')"
+        #   else
+        #     "wrong_length(\"#{ option_value }\")"
+        #   end
+
+        # VALIDATE NUMERICALITY OF
+        # IMPLEMENTATION TODO: Determine if 'allow_blank' is a valid option
+        # when :allow_blank
+        #   "allow_blank"
+        # IMPLEMENTATION TODO: Determine if Shoulda Matchers recognizes the 'other_than' option
+        # when :other_than
+        #   "other_than(:#{ option_value })"
+
+        # BELONG TO
+        # IMPLEMENTATION TODO: Determine if it is possible to implement 'conditions'
+        # VERIFICATION TODO: Verify capture of 'order' value due to its unique syntax (e.g. '-> { order("priority desc")' })
+        # when :order
+        #   if option_value.include? '"'
+        #     "order('#{ option_value }')"
+        #   else
+        #     "order(\"#{ option_value }\")"
+        #   end
+
+        # HAVE AND BELONG TO MANY
+        # VERIFICATION TODO: Verify capture of 'order' value due to its unique syntax (e.g. '-> { order("priority desc")' })
+        # when :order
+        #   if option_value.include? '"'
+        #     "order('#{ option_value }')"
+        #   else
+        #     "order(\"#{ option_value }\")"
+        #   end
+
+        # HAVE MANY
+        # VERIFICATION TODO: Verify capture of 'order' value due to its unique syntax (e.g. '-> { order("priority desc")' })
+        # when :order
+        #   if option_value.include? '"'
+        #     "order('#{ option_value }')"
+        #   else
+        #     "order(\"#{ option_value }\")"
+        #   end
+
+        # HAVE ONE
+        # IMPLEMENTATION TODO: Determine if Shoulda Matchers recognizes the 'inverse_of' option for 'have_one'
+        # when :inverse_of
+        #   "inverse_of(:#{ option_value })"
+        # VERIFICATION TODO: Verify capture of 'order' value due to its unique syntax (e.g. '-> { order("priority desc")' })
+        # when :order
+        #   if option_value.include? '"'
+        #     "order('#{ option_value }')"
+        #   else
+        #     "order(\"#{ option_value }\")"
+        #   end
+
+        # VALIDATE UNIQUENESS OF
+        # IMPLEMENTATION TODO: Determine if it is possible to implement 'ignoring_case_sensitivity'
+
+
+      end
+    end
+  end
+end

data/lib/shoulda_matchmakers.rb

@@ -0,0 +1,48 @@
+module ShouldaMatchmakers
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration) if block_given?
+  end
+
+  class Configuration
+
+    attr_accessor :active_record_class_names_included,
+                  :active_record_class_names_excluded,
+                  :active_record_model_tests_path,
+
+                  :action_controller_controller_names_included,
+                  :action_controller_controller_names_excluded,
+                  :action_controller_controller_tests_path,
+
+                  :active_record_model_class_names_for_factories_included,
+                  :active_record_model_class_names_for_factories_excluded,
+                  :active_record_model_factories_path,
+
+                  :include_enums,
+                  :preferred_generated_code_line_length
+
+    def initialize
+
+      @active_record_class_names_included = %w()
+      @active_record_class_names_excluded = %w()
+      @active_record_model_tests_path     = 'spec/shoulda_matchmakers/models/active_record'
+
+      @action_controller_controller_names_included = %w()
+      @action_controller_controller_names_excluded = %w()
+      @action_controller_controller_tests_path     = 'spec/shoulda_matchmakers/controllers/action_controller'
+
+      @active_record_model_class_names_for_factories_included = %w()
+      @active_record_model_class_names_for_factories_excluded = %w()
+      @active_record_model_factories_path                     = 'spec/shoulda_matchmakers/factories/active_record'
+
+      @include_enums = true
+      @preferred_generated_code_line_length = 120
+
+    end
+
+  end
+end

data/lib/shoulda_matchmakers/version.rb

@@ -0,0 +1,3 @@
+module ShouldaMatchmakers
+  VERSION = "0.1.0"
+end

data/lib/support/command_line_interface.rb

@@ -0,0 +1,100 @@
+require 'slop'
+require 'json'
+
+class CLI
+
+  # set up defaults in its own method
+  def cli_flags
+    options = Slop::Options.new
+    options.banner =  "usage: RAILS_ENV=test rails generate shoulda_matchmakers:model [options] ...\n" +
+                      "       RAILS_ENV=test rails generate shoulda_matchmakers:controller [options] ...\n" +
+                      "       RAILS_ENV=test rails generate shoulda_matchmakers:factory [options] ..."
+
+    options.separator ""
+    options.separator "Options (in order of precedence):"
+
+    options.null      "-ci",    "--config_included",  "Lists models/controllers included in the shoulda_matchmakers configuration file"
+
+    options.array     "-i []",  "--include []",       "User entered array of names of models/controllers for which to generate matchmakers\n" +
+                                                      "  All models in apps/models and controllers in apps/controllers are\nincluded by default.\n" +
+                                                      " (When this option is used, the '_included' and '_excluded' settings\nin the configuration file are ignored.)",
+                      delimiter: ','
+
+    options.array     "-ii []", "--include_plus []",  "User entered array of names of models/controllers to include after\nconfiguration file inclusions/exclusions have been applied.",
+                      delimiter: ','
+
+    options.null      "-ce",    "--config_excluded",  "List of models/controllers excluded in the shoulda_matchmakers configuration file"
+
+    options.array     "-e []",  "--exclude []",       "  User entered array of names of models/controllers for which to\nnot generate matchmakers\n" +
+                                                      "  No models/controllers in apps/models and apps/controllers are\nexcluded by default.\n" +
+                                                      " (If this option is used, the '_included' and '_excluded' settings\nin the configuration file are ignored.\n" +
+                                                      "  If the 'include' option is used, this option is ignored.)",
+                      delimiter: ','
+
+    options.array     "-ee []", "--exclude_plus []",  "User entered array of names of models/controllers to exclude after\nconfiguration file inclusions/exclusions have been applied.",
+                      delimiter: ','
+
+    options.null      "-h",     "--help",             "Displays this list of options"
+
+    options
+  end
+
+  def parse_arguments(command_line_options, parser)
+    begin
+      # slop has the advantage over optparse that it can do strings and not just ARGV
+      result = parser.parse command_line_options
+      result.to_hash
+
+    # Very important to not bury this begin/rescue logic in another method
+    # otherwise it will be difficult to check to see if -h or --help was passed
+    # in this case -h acts as an unknown option as long as we don't define it
+    # in cli_flags.
+    rescue Slop::UnknownOption
+      # print help
+      puts cli_flags
+      exit
+      # If, for your program, you can't exit here, then reraise Slop::UnknownOption
+      # raise a custom exception, push the rescue up to main or track that "help was invoked"
+    end
+  end
+
+  def flags
+    [:ce, :ci, :e, :ee, :h, :i, :ii]
+  end
+
+  def set?(arguments, flag)
+    !arguments.fetch(flag).nil?
+  end
+
+  # main style entry point
+  def main(command_line_options=ARGV)
+    parser = Slop::Parser.new cli_flags
+    arguments = parse_arguments(command_line_options, parser)
+
+    if arguments.key?(:ce) || arguments.key?(:ci) || arguments.key?(:h)
+      if arguments.key?(:ci)
+
+      end
+      if arguments.key?(:ce)
+
+      end
+      if arguments.key?(:h)
+        puts cli_flags
+      end
+      exit
+    end
+
+    elsif set?(arguments, :port)
+      puts portquiz arguments[:port]
+    elsif set?(arguments, :down)
+      puts is_it_up arguments[:down]
+    end
+  end
+
+
+
+end
+
+# this kind of sucks, you shouldn't ever change your code to accomodate tests
+# but this is a main
+# CLI.new.main if !defined?(RSpec)

data/lib/support/controller_generator.rb

@@ -0,0 +1,198 @@
+require 'controller/action_controller/action_controller_controller'
+
+module ShouldaMatchmakers
+  class ControllerGenerator < Rails::Generators::Base
+
+    source_root(File.expand_path(File.dirname(__FILE__)))
+
+    class_option :include, type:    :array,
+                           require: false,
+                           aliases: '-i',
+                           default: [],
+                           desc:    "Allows user to enter a space-delimited list of controller names for which to generate matchmakers\n" +
+                                    "                                                All controllers that are descendants of ActionController::Base are included by default.\n" +
+                                    "                                                Example: -i DriversController LicensesController Vehicle::CarsController Vehicle::BusesController\n\n" +
+                                    "                                                When this option is used, the '_included' and '_excluded' settings in the\n" +
+                                    "                                                '~/config/initializers/shoulda_matchmakers.rb' configuration file are ignored.\n\n\n"
+
+    class_option :exclude, type:    :array,
+                           require: false,
+                           aliases: '-e',
+                           default: [],
+                           desc:    "Allows user to enter a space-delimited list of controller names for which to not generate matchmakers\n" +
+                                    "                                                No controllers that are descendants of ActionController::Base are excluded by default.\n" +
+                                    "                                                Example: -e DriversController Vehicle::CarsController\n\n" +
+                                    "                                                When this option is used, the '_included' and '_excluded' settings in the\n" +
+                                    "                                                '~/config/initializers/shoulda_matchmakers.rb' configuration file are ignored.\n\n\n"
+
+    class_option :include_with_config, type:    :array,
+                                       require: false,
+                                       aliases: '-I',
+                                       default: [],
+                                       desc:    "Same as '-i/-include', except that configuration file inclusions/exclusions\n" +
+                                                "                                                are not ignored. Configuration file inclusions/exclusions are applied first\n" +
+                                                "                                                then the controllers in the arguments list of this option are applied.\n\n\n"
+
+    class_option :exclude_with_config, type:    :array,
+                                       require: false,
+                                       aliases: '-E',
+                                       default: [],
+                                       desc:    "Same as '-e/-exclude', except that configuration file inclusions/exclusions\n" +
+                                                "                                                are not ignored. Configuration file inclusions/exclusions are applied first\n" +
+                                                "                                                then the controllers in the arguments list of this option are applied.\n\n\n"
+
+    def create_controller_matchmakers
+
+      generator_options = options.to_hash
+
+      # TRACE.debug ""
+      # TRACE.debug "      GENERATOR OPTIONS:"
+      # TRACE.debug generator_options.inspect
+
+      load_application
+      generate_controller_matchmakers(generator_options)
+    end
+
+    def load_application
+      Rails.application.try(:eager_load!)
+    end
+
+    def generate_controller_matchmakers(generator_options)
+      app_action_controller_descendants_names = load_action_controller_controller_names
+      if app_action_controller_descendants_names.present?
+        selected_action_controller_controller_names = select_action_controller_controller_names(app_action_controller_descendants_names, generator_options)
+
+        # TRACE.debug "      SELECTED ACTION CONTROLLER CONTROLLERS:"
+        # TRACE.debug selected_action_controller_controller_names.inspect
+
+        selected_action_controller_controller_names.each do |controller_name|
+          save_generate(controller_name) do
+            @action_controller_controller_sm_model       = ::ShouldaMatchmakers::Controller::ActionController::ActionControllerController.new(controller_name)
+            template_filename = File.expand_path('vendor/shoulda_matchmakers/lib/templates/controller/action_controller/controller_spec_template.haml')
+            template          = File.read(template_filename)
+            create_file "#{ ShouldaMatchmakers.configuration.controllers_test_path }/#{ controller_name.underscore }_spec.rb",
+              Haml::Engine.new(template, filename: template_filename, format: :html5).to_html(binding)
+          end
+        end
+      end
+    end
+
+    def load_action_controller_controller_names
+      if defined?(::ActionController::Base)
+        ActionController::Base.descendants.map(&:name)
+      else
+        []
+      end
+    end
+
+    def save_generate(controller_name)
+      begin
+        yield
+      rescue => e
+        puts "Cannot create controller spec for #{ controller_name }. Reason #{ e.message }"
+      end
+    end
+
+    def select_action_controller_controller_names(app_action_controller_descendants_names, generator_options)
+      generator_options_include = generator_options.fetch('include')
+      generator_options_exclude = generator_options.fetch('exclude')
+      generator_options_include_with_config = generator_options.fetch('include_with_config')
+      generator_options_exclude_with_config = generator_options.fetch('exclude_with_config')
+
+      if generator_options_include.present?
+        select_controller_names_generator_option_include(app_action_controller_descendants_names, generator_options_include)
+      elsif generator_options_exclude.present?
+        select_controller_names_generator_option_exclude(app_action_controller_descendants_names, generator_options_exclude)
+      elsif generator_options_include_with_config.present?
+        select_controller_names_generator_option_include_with_config(app_action_controller_descendants_names, generator_options_include_with_config)
+      elsif generator_options_exclude_with_config.present?
+        select_controller_names_generator_option_exclude_with_config(app_action_controller_descendants_names, generator_options_exclude_with_config)
+      else
+        select_controller_names_config(app_action_controller_descendants_names)
+      end
+    end
+
+    def select_controller_names_generator_option_include(app_action_controller_descendants_names, include_controller_names)
+      app_action_controller_descendants_names.map(&:name).select { |app_controller_name| include_controller_names.include? app_controller_name }.uniq.sort
+    end
+
+    def select_controller_names_generator_option_exclude(app_action_controller_descendants_names, exclude_controller_names)
+      app_action_controller_descendants_names.map(&:name).reject { |app_controller_name| exclude_controller_names.include? app_controller_name }.uniq.sort
+    end
+
+    def select_controller_names_generator_option_include_with_config(app_action_controller_descendants_names, include_with_config_controller_names)
+      selected_action_controller_controller_names = select_controller_names_config(app_action_controller_descendants_names)
+      if selected_action_controller_controller_names.present?
+        (selected_action_controller_controller_names + app_action_controller_descendants_names.map.select { |app_controller_name| include_with_config_controller_names.include? app_controller_name }).uniq.sort
+      else
+        select_controller_names_generator_option_include(app_action_controller_descendants_names, include_with_config_controller_names).uniq.sort
+      end
+    end
+
+    def select_controller_names_generator_option_exclude_with_config(app_action_controller_descendants_names, exclude_with_config_controller_names)
+      selected_action_controller_controller_names = select_controller_names_config(app_action_controller_descendants_names)
+      if selected_action_controller_controller_names.present?
+        selected_action_controller_controller_names.map.reject { |app_controller_name| exclude_with_config_controller_names.include? app_controller_name }.uniq.sort
+      else
+        select_controller_names_generator_option_exclude(app_action_controller_descendants_names, exclude_with_config_controller_names).uniq.sort
+      end
+    end
+
+    def select_controller_names_config(app_action_controller_descendants_names)
+      controller_names_config_included = ShouldaMatchmakers.configuration.models_included
+      controller_names_config_excluded = ShouldaMatchmakers.configuration.models_excluded
+
+      # TRACE.debug ""
+      # TRACE.debug "      CONTROLLER NAME INCLUDED - CONFIG:"
+      # TRACE.debug controller_names_config_included
+      # TRACE.debug "      CONTROLLER NAME EXCLUDED - CONFIG:"
+      # TRACE.debug controller_names_config_excluded.inspect
+
+      if controller_names_config_included.present?
+
+        # app_action_controller_descendants_names.each do |model|
+        #   # TRACE.debug ""
+        #   # TRACE.debug "      MODEL:"
+        #   # TRACE.debug model.inspect
+        # end
+        selected_controller_names_config = app_action_controller_descendants_names.map.select { |app_controller_name| controller_names_config_included.include? app_controller_name }.uniq.sort
+
+        # TRACE.debug "      CONFIG SELECTED CONTROLLERS:"
+        # TRACE.debug selected_controller_names_config.inspect
+
+        selected_controller_names_config
+      elsif controller_names_config_excluded.present?
+        selected_controller_names_config = app_action_controller_descendants_names.map.reject { |app_controller_name| controller_names_config_excluded.include? app_controller_name }.uniq.sort
+
+        # TRACE.debug "      CONFIG EXCLUDED CONTROLLERS:"
+        # TRACE.debug selected_controller_names_config.inspect
+
+        selected_controller_names_config
+      else
+
+        # TRACE.debug "      NO CONTROLLERS INCLUDED OR EXCLUDED:"
+        # TRACE.debug app_action_controller_descendants_names.map.inspect
+
+        app_action_controller_descendants_names.map.uniq.sort
+      end
+    end
+
+
+    # def create_regression_files
+    #   Rails.application.eager_load!
+    #   all_controllers = ApplicationController.descendants << ApplicationController
+    #   all_controllers.each do |a_controller|
+    #     a_controller.action_methods.each do |action_method|
+    #     end
+    #   end
+    #   all_controllers.map(&:name).reject { |x| ShouldaMatchmakers.configuration.controllers_excluded.include? x }.each do |controller|
+    #     @sm_model_action_controller_controller = ::ShouldaMatchmakers::Controller::ActionController::ActionControllerController.new(controller)
+    #     template_filename = File.expand_path('vendor/shoulda_matchmakers/lib/templates/controller/action_controller/controller_spec_template.haml')
+    #     template          = File.read(template_filename)
+    #     create_file "#{ ShouldaMatchmakers.configuration.controllers_test_path }/#{ controller.underscore }_spec.rb",
+    #       Haml::Engine.new(template, filename: template_filename, format: :html5).to_html(binding)
+    #   end
+    # end
+
+  end
+end