spec_producer 0.11.0 → 0.13.0

data/lib/spec_producer/factories_production_module.rb

@@ -14,7 +14,7 @@ module SpecProducer::FactoriesProductionModule
       final_text = "FactoryGirl.define do\n"
       final_text << "  factory :#{descendant.name.underscore}, :class => #{descendant.name} do\n"
 
-      descendant.columns.each do |column|
+      descendant.columns.reject { |column| ['id', 'created_at', 'updated_at'].include? column.name }.each do |column|
         value = case column.type
                   when :string then "'#{descendant.name.underscore.upcase}_#{column.name.underscore.upcase}'"
                   when :text then "'#{descendant.name.underscore.upcase}_#{column.name.underscore.upcase}'"
@@ -31,28 +31,34 @@ module SpecProducer::FactoriesProductionModule
         final_text << "    #{column.name} #{value}\n"
       end
 
+      descendant.reflections.each_pair do |key, reflection|
+        if reflection.macro == :has_one
+          final_text << "    association :#{key.to_s}\n"
+        end
+      end
+
       final_text << "  end\n"
       final_text << "end"
 
       if File.exists?(Rails.root.join("spec/factories/#{descendant.name.underscore}.rb"))
-        puts '#'*100
-        puts "Please, check whether the following lines are included in: spec/factories/" + descendant.name.underscore + ".rb\n"
-        puts '#'*100
-        puts "\n"
+        puts ('#'*100).colorize(:light_blue)
+        puts ("Please, check whether the following lines are included in: spec/factories/" + descendant.name.underscore + ".rb").colorize(:light_blue)
+        puts ('#'*100).colorize(:light_blue)
         puts final_text
+        puts "\n\n"
       else
         unless Dir.exists? Rails.root.join("spec")
-          puts "Generating spec directory"
+          puts "Generating spec directory".colorize(:yellow)
           Dir.mkdir(Rails.root.join("spec"))
         end
 
         unless Dir.exists? Rails.root.join("spec/factories")
-          puts "Generating spec/factories directory"
+          puts "Generating spec/factories directory".colorize(:yellow)
           Dir.mkdir(Rails.root.join("spec/factories"))
         end
 
         path = "spec/factories/#{descendant.name.underscore}.rb"
-        puts "Producing factory file for: #{path}"
+        puts "Producing factory file for: #{path}".colorize(:green)
         f = File.open("#{Rails.root.join(path)}", 'wb+')
         f.write(final_text)
         f.close
@@ -61,8 +67,8 @@ module SpecProducer::FactoriesProductionModule
 
     nil
   rescue NameError => e
-    puts "NameError '#{e}' was raised. Can't produce factories for this project."
+    puts "NameError '#{e}' was raised. Can't produce factories for this project.".colorize(:red)
   rescue Exception => e
-    puts "Exception '#{e}' was raised. Skipping factories production."
+    puts "Exception '#{e}' was raised. Skipping factories production.".colorize(:red)
   end
-end
+end

data/lib/spec_producer/missing_files_module.rb

@@ -1,3 +1,5 @@
+require 'colorize'
+
 module SpecProducer::MissingFilesModule
   def self.print_missing_model_specs(options = {})
     if options[:specific_namespace]
@@ -6,14 +8,16 @@ module SpecProducer::MissingFilesModule
       files_list = Dir["app/models/**/*.rb"]
     end
 
-    puts "\n" << "## Searching for missing model specs..."
-    files_list.each do |file|
-      unless FileTest.exists?(file.gsub('app/', 'spec/').gsub('.rb', '_spec.rb'))
-        puts "Missing model spec file for: #{file}"
-      end
+    puts "\n" << "## Searching for missing model specs...".colorize(:light_blue)
+    missing = files_list.select { |file| !FileTest.exists?(file.gsub('app/', 'spec/').gsub('.rb', '_spec.rb')) }
+
+    missing.each do |file|
+      puts "Missing model spec file for: #{file}".colorize(:red)
     end
 
-    nil
+    if missing.size == 0
+      puts "No missing model spec files found!".colorize(:green)
+    end
   end
 
   def self.print_missing_controller_specs(options = {})
@@ -23,14 +27,16 @@ module SpecProducer::MissingFilesModule
       files_list = Dir["app/controllers/**/*.rb"]
     end
 
-    puts "\n" << "## Searching for missing controller specs..."
-    files_list.each do |file|
-      unless FileTest.exists?(file.gsub('app/', 'spec/').gsub('.rb', '_spec.rb'))
-        puts "Missing controller spec file for: #{file}"
-      end
+    puts "\n" << "## Searching for missing controller specs...".colorize(:light_blue)
+    missing = files_list.select { |file| !FileTest.exists?(file.gsub('app/', 'spec/').gsub('.rb', '_spec.rb')) }
+
+    missing.each do |file|
+      puts "Missing controller spec file for: #{file}".colorize(:red)
     end
 
-    nil
+    if missing.size == 0
+      puts "No missing controller spec files found!".colorize(:green)
+    end
   end
 
   def self.print_missing_job_specs(options = {})
@@ -40,14 +46,16 @@ module SpecProducer::MissingFilesModule
       files_list = Dir["app/jobs/**/*.rb"]
     end
 
-    puts "\n" << "## Searching for missing jobs specs..."
-    files_list.each do |file|
-      unless FileTest.exists?(file.gsub('app/', 'spec/').gsub('.rb', '_spec.rb'))
-        puts "Missing job spec file for: #{file}"
-      end
+    puts "\n" << "## Searching for missing jobs specs...".colorize(:light_blue)
+    missing = files_list.select { |file| !FileTest.exists?(file.gsub('app/', 'spec/').gsub('.rb', '_spec.rb')) }
+
+    missing.each do |file|
+      puts "Missing job spec file for: #{file}".colorize(:red)
     end
 
-    nil
+    if missing.size == 0
+      puts "No missing job spec files found!".colorize(:green)
+    end
   end
 
   def self.print_missing_mailer_specs(options = {})
@@ -57,47 +65,102 @@ module SpecProducer::MissingFilesModule
       files_list = Dir["app/mailers/**/*.rb"]
     end
 
-    puts "\n" << "## Searching for missing mailers specs..."
-    files_list.each do |file|
-      unless FileTest.exists?(file.gsub('app/', 'spec/').gsub('.rb', '_spec.rb'))
-        puts "Missing mailer spec file for: #{file}"
-      end
+    puts "\n" << "## Searching for missing mailers specs...".colorize(:light_blue)
+    missing = files_list.select { |file| !FileTest.exists?(file.gsub('app/', 'spec/').gsub('.rb', '_spec.rb')) }
+
+    missing.each do |file|
+      puts "Missing mailer spec file for: #{file}".colorize(:red)
     end
 
-    nil
+    if missing.size == 0
+      puts "No missing mailer spec files found!".colorize(:green)
+    end
   end
 
   def self.print_missing_helper_specs(options = {})(options = {})
+  if options[:specific_namespace]
+    files_list = Dir["app/helpers/**/#{options[:specific_namespace].gsub('app/helpers', '')}/**/*.rb"]
+  else
+    files_list = Dir["app/helpers/**/*.rb"]
+  end
+
+  puts "\n" << "## Searching for missing helper specs...".colorize(:light_blue)
+  missing = files_list.select { |file| !FileTest.exists?(file.gsub('app/', 'spec/').gsub('.rb', '_spec.rb')) }
+
+  missing.each do |file|
+    puts "Missing helper spec file for: #{file}".colorize(:red)
+  end
+
+  if missing.size == 0
+    puts "No missing helper spec files found!".colorize(:green)
+  end
+  end
+
+  def self.print_missing_view_specs(options = {})
     if options[:specific_namespace]
-      files_list = Dir["app/helpers/**/#{options[:specific_namespace].gsub('app/helpers', '')}/**/*.rb"]
+      files_list = Dir["app/views/**/#{options[:specific_namespace].gsub('app/views', '')}/**/*.erb"]
     else
-      files_list = Dir["app/helpers/**/*.rb"]
+      files_list = Dir["app/views/**/*.erb"]
     end
 
-    puts "\n" << "## Searching for missing helper specs..."
-    files_list.each do |file|
-      unless FileTest.exists?(file.gsub('app/', 'spec/').gsub('.rb', '_spec.rb'))
-        puts "Missing helper spec file for: #{file}"
-      end
+    puts "\n" << "## Searching for missing view specs...".colorize(:light_blue)
+    missing = files_list.select { |file| !FileTest.exists?("#{file.gsub('app/', 'spec/')}_spec.rb") }
+
+    missing.each do |file|
+      puts "Missing view spec file for: #{file}".colorize(:red)
     end
 
-    nil
+    if missing.size == 0
+      puts "No missing view spec files found!".colorize(:green)
+    end
   end
 
-  def self.print_missing_view_specs(options = {})
+  def self.print_missing_serializer_specs(options = {})
     if options[:specific_namespace]
-      files_list = Dir["app/views/**/#{options[:specific_namespace].gsub('app/views', '')}/**/*.erb"]
+      files_list = Dir["app/serializers/**/#{options[:specific_namespace].gsub('app/serializers', '')}/**/*.erb"]
     else
-      files_list = Dir["app/views/**/*.erb"]
+      files_list = Dir["app/serializers/**/*.erb"]
+    end
+
+    puts "\n" << "## Searching for missing serializers specs...".colorize(:light_blue)
+    missing = files_list.select { |file| !FileTest.exists?(file.gsub('app/', 'spec/').gsub('.rb', '_spec.rb')) }
+
+    missing.each do |file|
+      puts "Missing serializer spec file for: #{file}".colorize(:red)
     end
 
-    puts "\n" << "## Searching for missing view specs..."
-    files_list.each do |file|
-      unless FileTest.exists?("#{file.gsub('app/', 'spec/')}_spec.rb")
-        puts "Missing spec file for: #{file}"
+    if missing.size == 0
+      puts "No missing serializer spec files found!".colorize(:green)
+    end
+  end
+
+  def self.print_missing_route_specs(options = {})
+    routes = Rails.application.routes.routes.map do |route|
+      path = route.path.spec.to_s.gsub(/\(\.:format\)/, "")
+      verb = %W{ GET POST PUT PATCH DELETE }.grep(route.verb).first.downcase.to_sym
+      controller = route.defaults[:controller]
+      action = route.defaults[:action]
+
+      if controller.present? && !/^rails/.match(controller)
+        { :path => path, :verb => verb, :controller => controller, :action => action }
+      end
+    end.compact
+
+    puts "\n" << "## Searching for missing route specs...".colorize(:light_blue)
+    missing = []
+
+    routes.group_by { |route| route[:controller] }.each do |route_group|
+      unless File.exists?(Rails.root.join("spec/routing/#{route_group[0]}_routing_spec.rb"))
+        missing << "spec/routing/#{route_group[0]}_routing_spec.rb"
       end
     end
 
-    nil
+    missing.each do |file|
+      puts "Missing route spec file for: #{file}".colorize(:red)
+    end
+
+    if missing.size == 0
+      puts "No missing route spec files found!".colorize(:green)
+    end
   end
-end
+end

data/lib/spec_producer/missing_gems_module.rb

@@ -0,0 +1,77 @@
+require 'colorize'
+
+module SpecProducer::MissingGemsModule
+  def self.set_up_necessities
+    # TODO: Update spec_helper or rails helper with proper configurations
+    gemfiles = Dir.glob(Rails.root.join('Gemfile'))
+
+    if gemfiles.size > 0
+      contents = File.read(gemfiles.first)
+      gems = contents.scan(/gem \'(?<gem>\S*)\'/).flatten.uniq
+      missing_gems = []
+
+      missing_gems << 'rspec-rails' unless (gems.include? 'rspec-rails')
+      missing_gems << 'factory_girl_rails' unless (gems.include? 'factory_girl_rails')
+      missing_gems << 'shoulda-matchers' unless (gems.include? 'shoulda-matchers')
+      missing_gems << 'webmock' unless (gems.include? 'webmock')
+      missing_gems << 'rubocop' unless (gems.include? 'rubocop')
+
+      # No need for capybara if there are no views to parse
+      missing_gems << 'capybara' unless ((gems.include? 'capybara') && Dir["app/views/**/*.erb"] != [])
+
+      if missing_gems.size > 0
+        actions_needed = ""
+        useful_info = "\nGems installed:\n"
+        contents << "\n\ngroup :test do\n"
+
+        missing_gems.each do |gem|
+          contents << "  gem '#{gem}'\n"
+
+          if gem == 'rspec-rails'
+            useful_info << "# Rspec: https://github.com/rspec/rspec-rails\n"
+          elsif gem == 'factory_girl_rails'
+            useful_info << "# FactoryGirl: https://github.com/thoughtbot/factory_girl_rails\n"
+          elsif gem == 'shoulda-matchers'
+            useful_info << "# Shoulda Matchers: https://github.com/thoughtbot/shoulda-matchers\n"
+          elsif gem == 'webmock'
+            actions_needed << "# Add 'require \'webmock/rspec\'' in your spec_helper or rails_helper\n"
+            useful_info << "# Webmock: https://github.com/bblimke/webmock\n"
+          elsif gem == 'rubocop'
+            useful_info << "# RuboCop: https://github.com/bbatsov/rubocop\n"
+          end
+        end
+
+        contents << "end"
+
+        f = File.open(gemfiles.first, 'wb+')
+        f.write(contents)
+        f.close
+
+        if defined?(Bundler)
+          Bundler.with_clean_env do
+            puts "\n\nRunning bundle after setting list of gems in you Gemfile.".colorize(:yellow)
+
+            system 'bundle install'
+          end
+        end
+
+        if 'rspec-rails'.in? missing_gems
+          puts "\n\nInitializing Rspec files and helpers.".colorize(:yellow)
+
+          system 'rails generate rspec:install'
+        end
+
+        if actions_needed != ''
+          puts "\n\nYou will additionally need to:\n".colorize(:green)
+          puts actions_needed.colorize(:green)
+        end
+
+        puts useful_info.colorize(:light_blue)
+      else
+        puts 'Could not find anything missing!'.colorize(:light_blue)
+      end
+    else
+      puts "We couldn't find a Gemfile and setting up halted!".colorize(:red)
+    end
+  end
+end	

data/lib/spec_producer/producers.rb

@@ -0,0 +1,10 @@
+require 'spec_producer/producers/base'
+require 'spec_producer/producers/models_producer'
+require 'spec_producer/producers/views_producer'
+require 'spec_producer/producers/helpers_producer'
+require 'spec_producer/producers/controllers_producer'
+require 'spec_producer/producers/mailers_producer'
+require 'spec_producer/producers/jobs_producer'
+require 'spec_producer/producers/routes_producer'
+require 'spec_producer/producers/serializers_producer'
+require 'spec_producer/producers/registry'

data/lib/spec_producer/producers/base.rb

@@ -0,0 +1,129 @@
+require 'spec_producer/utils'
+# Base module that needs to be included and implemented by
+# corresponding producers. Note: This module should be prepended and
+# not included / extended.
+#
+# Concrete subclasses need to implement 2 methods: call and resources
+# We use the prepend and prepended callback in order to call Base#call
+# method first and the invoke super which will call the corresponding
+# concrete implementation to be executed. The #call method on every concrete
+# implementation will receive the resource that we currently iterate over.
+#
+# Conrete implementation need to prepend this module and to provide
+# #resources method which returns a collection of resources that
+# will be iterated in order to generate the specs for. the resource
+# object should respond to #name (ex. Some::User) and #type ('models', 'controllers' etc)
+# We need these values in order to generate the Describe 'Some::Person' in rspec files.
+#
+# A minimal implementation could be
+#
+#   class SomeSpecProducer
+#     prepend Base
+#
+#     def resources
+#       [Clas.new(Object), Class.new(Object)].map { |obj|
+#         Resource.new(obj, obj.name, 'models') 
+#       }
+#     end
+#
+#
+#     def call(resource)
+#       builder.context 'Some context' do |b|
+#         resource.attributes.each do |attr|
+#           b.responds_to(attr)
+#         end
+#       end
+#     end
+#   end
+#
+# The base class is also responsible to write for each spec file that we generate
+# the top static lines requiring 'spec_helper' and the beginning of spec file:
+#   
+#   require 'spec_helper'
+#   describe User, type: :model  do
+#     # Other code omitted
+#   end
+#
+# Each concrete instance is responsible to create the `body` of the spec file which includes
+# its basic validations if any or any other info that we might get from ActiveRecord, ActionController
+# etc.
+#
+# Finally this class is responsible to write the generated spec to the corresponsing
+# path (ex spec/models/user_spec.rb)
+#
+module SpecProducer
+  module Producers
+    module Base
+      class Resource < Struct.new(:obj, :name, :type)
+      end
+
+      module ClassMethods
+        def call(args)
+          new(args).call
+        end
+      end
+
+      def self.prepended(base)
+        base.extend(ClassMethods)
+      end
+
+      attr_reader :type
+      attr_reader :builder
+
+      def initialize(type)
+        @type = type
+        @builder = RspecBuilders::Base.new
+      end
+
+      def call
+        raise(NotImplementedError.new('Abstract method.')) unless defined?(super)
+        warn "No resources available" if resources.empty?
+
+        resources.each do |resource|
+          builder.build do |b|
+            b.write(helper_spec_file)
+            b.spec resource.name, resource.type do |b|
+              super(resource)
+            end
+          end
+
+          # Footer / Fils Close etc
+          if resource.type == 'routing'
+            Utils::FileUtils.try_to_create_spec_file(resource.type, "#{resource.name}_routing", builder)
+          else
+            Utils::FileUtils.try_to_create_spec_file(resource.type.pluralize, resource.name.underscore, builder)
+          end
+
+          builder.flush!
+        end
+
+        self
+      rescue StandardError => e
+        handle_exception(e)
+      end
+
+      # @Abstract method
+      def resources
+        raise(NotImplementedError.new('Abstract method.')) unless defined?(super)
+        super
+      end
+
+      #######
+      private
+      #######
+
+      def handle_exception(e)
+        raise e if SpecProducer.configuration.raise_errors
+        puts "Exception '#{e}' was raised. Skipping model specs production.".colorize(:red)
+      end
+
+      def helper_spec_file
+        "require \'#{require_helper_string}\'\n"
+      end
+
+      def rspec_describe(klass, type)
+        "describe #{klass}, :type => :#{type} do"
+      end
+    end
+  end
+end