quick_shoulda 0.0.2

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.idea

data/.rdebugrc

@@ -0,0 +1,3 @@
+set autolist
+set autoeval
+set autoreload

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--debug
+-f documentation
+-p

data/.rvmrc

@@ -0,0 +1 @@
+rvm use 1.9.3-p194@quick-shoulda --create

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in quick_shoulda.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Tien Nguyen
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# QuickShoulda
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'quick_shoulda'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install quick_shoulda
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+task :install_mah_gem do
+  exec %{ 
+  	gem uninstall quick_shoulda; 
+  	gem build quick_shoulda.gemspec;
+  	gem install quick_shoulda-0.0.2.gem; }
+end

data/data/stored_strings.yml

@@ -0,0 +1,44 @@
+[
+	#URLs
+	'www.domain.com', 'www.domain.subdomain.com', 'http://www.domain.com', 'http://www.domain.subdomain.com', 
+	'http://www.domain.com/path/1',	'https://www.domain.com', 'https://www.domain.subdomain.com', 'domain.subdomain.com',
+	'domain.com/path/1', 'subdomain.domain.com/path/1',
+	#Emails
+	'us@gmail.com', 'us.vn@gmail.com', 'us_vn@gmail.com', 'us_vn@gmail.com.vn',
+	#IPS
+	'192.168.1.1', '192.168.1.2',
+	#Sex
+	'male', 'female', 'gay', 'les', 'other',
+	#Zip postal code
+	'10001', '10002', '10003',
+	#Phone numbers
+	'732-757-2923', '1732-757-2923',
+	#datestimes
+	'1999-01-01', '99-01-01', '1999/01/01', '99/01/01', '01/01/99', '03/10/1986', '01-01-1999', '01-01-99', 'January 07, 2013',
+	'monday', 'tuesday', 'wednesday', 'thursday', 'friday', 'saturday',
+	'january', 'february', 'march', 'april', 'may', 'june', 'july', 'august', 'september', 'october', 'november', 'december',
+	'am', 'pm',
+	#countries
+	'Vietnam', 'America', 'England',
+	'Vietnamese', 'American', 'English',
+	#cities
+	'New York', 'London', 'Ho Chi Minh',
+	#Status
+	'married', 'single', 'available', 'complicated',
+	#Files
+	'filename.txt', 'filename.jpg', 'filename.png', 'filename.jpeg',
+	#Extensions
+	'txt', 'jpg', 'png', 'jpeg', 'mp4', 'mp3', 'wmv',
+	#Videos
+	'filename.wmv', 'filename.mp4', 'filename.flv',
+	#credit cards number
+	'4111 1111 1111 1111', '5500 0000 0000 0004', '3400 0000 0000 009', '3000 0000 0000 04', '+84 121731845', '84 121731845', '(84) 121731845',
+	#some countries code
+	'84', '1', '39',
+	#ISO countries code
+	'US', 'USA', 'VN', 'VNM',
+	#services'
+	'yahoo', 'google', 'facebook', 'amazone', 'youtube', 'paypal', 'alchemy',
+	#marks
+	'excellent', 'good', 'bad'
+]

data/lib/generators/quick_shoulda/generate/generate_generator.rb

@@ -0,0 +1,11 @@
+module QuickShoulda
+	module Generators
+	  class GenerateGenerator < ::Rails::Generators::Base
+	  	argument :model_path, :type => :string
+
+	  	def generate_shoulda_testcases
+				QuickShoulda.process(model_path)
+	  	end
+	  end
+	end
+end

data/lib/quick_shoulda/errors.rb

@@ -0,0 +1,33 @@
+module QuickShoulda
+	module Errors
+		class InvalidPathError < StandardError
+			def initialize(msg = 'Invalid path given')
+				super(msg)
+			end
+		end
+
+		class FileDoesNotExistError < StandardError
+			def initialize(msg = 'This file does not exist')
+				super(msg)
+			end
+		end
+
+		class NotAModelPathError < StandardError
+			def initialize(msg = 'file must located inside models directory')
+				super(msg)
+			end
+		end
+		
+		class NotRubyFileError < StandardError
+			def initialize(msg = 'Given file must have .rb extension')
+				super(msg)
+			end
+		end
+
+		class PathNotGivenError < StandardError
+			def initialize(msg = 'path to model file must be given')
+				super(msg)
+			end
+		end		
+	end
+end

data/lib/quick_shoulda/file_writer.rb

@@ -0,0 +1,58 @@
+require 'quick_shoulda/errors'
+
+module QuickShoulda
+	module FileWriter		
+		DescribeRegex = /^describe\s.+\sdo$/i
+
+		def create_file_and_write_init_content
+			FileUtils.mkdir_p(File.dirname(spec_file_path))
+			File.open(spec_file_path, 'w') do |file|
+				file.write(spec_init_content)
+			end
+		end
+
+		def clear_all_blocks
+			[:validation, :association].each do |block_name| 
+				clear_block block_describe_header(block_name)
+			end
+		end
+
+		def write_block(shoulda_content)	
+			file_content = ''
+			File.open(spec_file_path, 'a+') do |file|				
+				inserted = false
+				while( line = file.gets )
+					file_content << line										
+					if !inserted && line.strip.gsub(/[\t\n]/,'') =~ DescribeRegex						
+					file_content << shoulda_content
+						inserted = true
+					end
+				end				
+			end
+
+			File.open(spec_file_path, 'w') { |file | file.write( file_content ) }
+		end
+
+		def clear_block(block)
+			file_content = ""
+			File.open(spec_file_path, 'r') do | file |
+				
+				delete_mode = false				
+
+				while( line = file.gets )
+					filtered_line = line.gsub(/[\n\t]/,'')
+
+					if filtered_line == block || delete_mode
+						delete_mode = true if filtered_line == block
+						delete_mode = false if filtered_line == 'end'
+						next
+					end
+
+					file_content << line
+				end
+			end
+
+			File.open(spec_file_path, 'w') { |file | file.write( file_content ) }
+		end		
+	end
+end

data/lib/quick_shoulda/generator/association.rb

@@ -0,0 +1,46 @@
+module QuickShoulda
+  module Generator
+    module Association
+      MappedMacros = {
+        :has_one                  => 'have_one',
+        :has_many                 => 'have_many',
+        :belongs_to               => 'belong_to',
+        :has_and_belongs_to_many  => 'have_and_belong_to_many'
+      }
+
+      OptionMethods = {
+        :dependent   => 'dependent',
+        :through     => 'through',
+        :class_name  => 'class_name',
+        :touch       => 'touch',
+        :validate    => 'validate',
+        :order       => 'order',
+        :foreign_key => 'with_foreign_key'
+      }
+
+      SingleQuoteMethods = ['order', 'class_name']
+
+      def generate_associations(model)
+        model.reflect_on_all_associations.map { |association| generate_for_association(association) }.compact.flatten
+      end
+
+      private
+
+        def generate_for_association(association)
+          shoulda_method_name = MappedMacros[association.macro.to_sym]
+          "it { should #{shoulda_method_name}(:#{association.name})#{shoulda_assciation_option_methods_chain(association.options)} }"
+        end
+
+        def shoulda_assciation_option_methods_chain(options)
+          options.map do |option, value|
+            shoulda_option_method_with_value(option, value)
+          end.compact.join
+        end
+
+        def shoulda_option_method_with_value(option, value)    
+          method_name = OptionMethods[option.to_sym]          
+          ".#{method_name}#{value_transform(value)}" if method_name
+        end
+    end
+  end
+end

data/lib/quick_shoulda/generator/spec_content.rb

@@ -0,0 +1,31 @@
+module QuickShoulda
+	module Generator
+		module SpecContent
+			def block_describe_header(block_name)
+				case block_name.to_sym
+					when :association 
+						"describe '#Associations' do"
+					when :validation 
+						"describe '#Validations' do"
+				end
+			end
+			
+			def shoulda_content(block_name, shoulda_lines)
+				return "" unless shoulda_lines.size > 0
+				
+				block = block_describe_header(block_name)
+				shoulda_lines.map! { |line| "\t#{line}"}
+				shoulda_lines.insert(0, "#{block}")
+				shoulda_lines << "end\n"
+
+				shoulda_lines.map { |line| "\t#{line}"}.join("\n")	
+			end
+
+			def spec_init_content
+				content = "require 'spec_helper'\n\n"
+				content << "describe '#{model_full_namespace}' do\n"
+				content << "end"				
+			end
+		end
+	end
+end

data/lib/quick_shoulda/generator/validation.rb

@@ -0,0 +1,144 @@
+require 'quick_shoulda/random_string'
+
+module QuickShoulda
+  module Generator
+    module Validation
+      AllowsValidators = [
+        'presence', 'uniqueness', 'acceptance', 'confirmation', 'exclusion', 'format', 'inclusion', 'length', 'numericality'
+      ]
+
+      InclusionOptions = {
+        :range      => 'in_range',
+        :array      => 'in_array'
+      }
+
+      OptionMethods = {
+        :minimum          => 'is_at_least',
+        :maximum          => 'is_at_most',
+        :is               => 'is_equal_to',
+        :scope            => 'scoped_to',
+        :too_short        => 'with_short_message',
+        :too_long         => 'with_long_message',
+        :message          => 'with_message',        
+        :only_integer     => 'only_integer',
+        :case_insensitive => 'case_insensitive',
+        :allow_nil        => 'allow_nil',
+        :allow_blank      => 'allow_blank',        
+        :in               => InclusionOptions,
+        :within           => InclusionOptions
+      }
+
+      Filters = {
+        :allow_blank      => ['inclusion'],
+        :allow_nil        => ['inclusion', 'uniqueness'],
+        :case_insensitive => ['uniqueness']
+      }
+
+      AttrsFilters = ['friendly_id']
+
+      def self.included(base)
+        base.class_eval do
+          attr_accessor :validation_type
+        end
+      end
+      
+      def generate_validations(model)
+        model.validators.map { |validator| generate_for_validator(validator) }.compact.flatten
+      end
+
+      private
+
+        def generate_for_validator(validator)          
+          if @validation_type = _validation_type(validator)            
+            return if ( attrs = attrs_filter(validator.attributes) ).empty?
+            generate_shouldas(attrs, validator.options)
+          end
+        end
+
+        def attrs_filter(attrs)
+          attrs.select { |attr| !(AttrsFilters.include? attr.to_s) }
+        end
+
+        def _validation_type(validator)
+          validation_type = validator.class.to_s.scan(/([^:]+)Validator/)
+          unless validation_type.empty?
+            validator = validation_type.first.first.downcase
+            validator if AllowsValidators.include? validator
+          end          
+        end
+
+        def generate_shouldas(attributes, options)
+          attributes.map { |attribute| generate_shoulda(attribute, options) }.flatten
+        end
+
+        def generate_shoulda(attribute, options)
+          unless validation_type == 'format'
+            [ "it { should #{shoulda_matcher_method}(:#{attribute})#{shoulda_option_methods_chain(options)} }" ]
+          else
+            generate_shouldas_for_format_validation(attribute, options)
+          end
+        end
+
+        def generate_shouldas_for_format_validation(attribute, options)          
+          RandomString.generate(options[:with]).map { |type, strings| generate_allow_shouldas(type, strings, attribute) }.flatten
+        end
+
+        def generate_allow_shouldas(type, strings, attribute)          
+          should_suffix = type.to_s == 'matched_strings' ? '' : '_not'
+          strings.map { |string| "it { should#{should_suffix} allow_value('#{string}').for(:#{attribute}) }" }
+        end
+
+        def shoulda_matcher_method
+          prefix = ('exclusion|inclusion|length' =~ /#{validation_type}/) ? 'ensure' : 'validate'
+          "#{prefix}_#{validation_type}_of"
+        end
+
+        #.is_at_least(50).is_at_max(100)
+        def shoulda_option_methods_chain(options)
+          options.map { |option, value| shoulda_option_method(option, value) }.compact.join
+        end
+        
+        def shoulda_option_method(option, value)          
+          method = shoulda_option_method_name(option, value)          
+          return unless method
+
+          case method
+            when OptionMethods[:scope] 
+              shoulda_scope_to_method(value)
+            when OptionMethods[:only_integer], OptionMethods[:case_insensitive]
+              shoulda_method_without_value(method)
+            else 
+              shoulda_normal_option_method(method, value)
+            end          
+        end
+
+        #.is_at_least
+        #.is_at_most
+        def shoulda_option_method_name(option, value)
+          return unless pass_filter?(option)
+          option_method = OptionMethods[option.to_sym]
+          option_method = option_method[value.class.to_s.downcase.to_sym] if option_method.is_a?(Hash)
+          option_method
+        end
+
+        def pass_filter?(option)
+          !Filters[option.to_sym] || Filters[option.to_sym].include?(validation_type)
+        end
+
+        #.is_at_least(50)        
+        def shoulda_normal_option_method(method, value)
+          ".#{method}#{value_transform(value)}"
+        end
+
+        def shoulda_method_without_value(method)
+          ".#{method}"
+        end
+
+        #.scoped_to(:username).scoped_to(:account)
+        def shoulda_scope_to_method(value)
+          method = OptionMethods[:scope]
+          ([] << value).flatten.map { | v | ".#{method}#{value_transform(v)}" }.join
+        end
+    end
+  end
+end

data/lib/quick_shoulda/generator.rb

@@ -0,0 +1,11 @@
+require 'quick_shoulda/generator/validation'
+require 'quick_shoulda/generator/association'
+require 'quick_shoulda/generator/spec_content'
+
+module QuickShoulda
+	module Generator
+		include Validation
+		include Association
+		include SpecContent
+	end
+end

data/lib/quick_shoulda/helpers/string_helpers.rb

@@ -0,0 +1,18 @@
+module QuickShoulda
+  module StringHelpers
+    def camelize(str)
+      return str if str !~ /_/ && str =~ /[A-Z]+.*/
+      str.split("_").map{|e| e.capitalize}.join
+    end
+
+    def value_transform(value)
+ 	  	if value.is_a? String
+        "('#{value}')"
+      elsif value.is_a? Symbol
+        "(:#{value})"
+      else
+        "(#{value})"
+      end
+    end
+  end
+end

data/lib/quick_shoulda/main.rb

@@ -0,0 +1,39 @@
+module QuickShoulda
+	module Main
+		def self.included(base)
+			base.class_eval do
+				attr_accessor :path, :spec_folder, :model_full_namespace, :spec_file_path, :validations_block, :associations_block
+			end
+		end
+
+		def configure_and_generate(path, spec_folder)
+			configure(path, spec_folder)
+			generate
+		end
+
+		private
+
+			def configure(path, spec_folder)
+				@path = path
+				@spec_folder = spec_folder[-1] != '/' ? "#{spec_folder}/" : spec_folder
+				@model_full_namespace = _model_full_namespace
+				@spec_file_path = _spec_file_path
+			end
+
+			def generate
+				generate_shoulda_content
+				create_and_write_to_file
+			end
+
+			def generate_shoulda_content
+				@validations_block = shoulda_content(:validation, generate_validations(model_full_namespace))
+				@associations_block = shoulda_content(:association, generate_associations(model_full_namespace))
+			end
+
+			def create_and_write_to_file
+				create_file_and_write_init_content unless spec_file_exist?
+				clear_all_blocks
+				write_block(validations_block + associations_block)
+			end	
+	end
+end

data/lib/quick_shoulda/path_resolver.rb

@@ -0,0 +1,31 @@
+require 'quick_shoulda/helpers/string_helpers'
+
+module QuickShoulda
+	module PathResolver
+		include StringHelpers
+
+		private
+		
+			def spec_file_exist?
+				File.file? spec_file_path
+			end
+			
+			def _model_full_namespace				
+				eval "::#{_model_full_namespace_in_str}"
+			end
+
+			def _spec_file_path
+				model_path = path.split(/\/?models\//)[1]			
+				file_name = "#{File.basename(model_path, ".rb")}_spec.rb"
+				dir_name = File.dirname(model_path) == '.' ? spec_folder : "#{spec_folder}#{File.dirname(model_path)}/"		
+				"#{dir_name}#{file_name}"
+			end
+
+			# given models/namespace/modelname.rb
+			# return Namespace::ModelName
+			def _model_full_namespace_in_str
+				model_path = path.split(/\/?models\//)[1].gsub('.rb','')
+				model_path.split('/').map { |token| camelize(token) }.join('::')				
+			end	
+		end
+	end

data/lib/quick_shoulda/random_string.rb

@@ -0,0 +1,51 @@
+module QuickShoulda
+	class RandomString
+		class << self
+			Size = 3
+			LowerCaseChars = ('a'..'z').to_a
+			UpperCaseChars = ('A'..'Z').to_a
+			Digits 				 = (0..9).to_a
+
+			def sample_strings
+				stored_strings + random_digits_strings + random_chars_strings
+			end
+
+			def stored_strings				
+				@stored_strings ||= YAML.load File.new(File.join(File.dirname(__FILE__),'..','..','data','stored_strings.yml'))
+			end
+
+			def random_digits_strings
+				random_strings(Digits)
+			end
+
+			def random_chars_strings
+				random_strings(LowerCaseChars + UpperCaseChars)
+			end
+
+			def random_strings(base)
+				(1..50).map { |length| length.times.inject('') { |initial, n| initial + base[rand(10)].to_s } }
+			end
+
+			def generate(pattern)
+				matched_strings = []
+				unmatched_strings = []
+				RandomString.sample_strings.each do |sample_string|
+					break if matched_strings.size == Size && unmatched_strings.size == Size
+
+					if sample_string =~ pattern
+						matched_strings << sample_string if matched_strings.size < Size
+					else
+						unmatched_strings << sample_string if unmatched_strings.size < Size
+					end
+				end
+
+				{
+					matched_strings:   matched_strings,
+					unmatched_strings: unmatched_strings
+				}
+			end
+
+			alias_method :gen, :generate
+		end
+	end
+end

data/lib/quick_shoulda/version.rb

@@ -0,0 +1,3 @@
+module QuickShoulda
+  VERSION = "0.0.2"
+end

data/lib/quick_shoulda.rb

@@ -0,0 +1,26 @@
+require "quick_shoulda/version"
+require "quick_shoulda/errors"
+require "quick_shoulda/path_resolver"
+require "quick_shoulda/file_writer"
+require "quick_shoulda/generator"
+require "quick_shoulda/main"
+require 'fileutils'
+
+module QuickShoulda
+	class << self
+		include StringHelpers
+		include PathResolver
+		include FileWriter
+		include Generator
+		include Main
+		include Errors
+		
+		def process(path, spec_folder = 'spec/models/')
+			raise PathNotGivenError unless path
+			raise NotAModelPathError unless path =~ /models\//
+			raise FileDoesNotExistError unless File.file?(path)
+			raise NotRubyFileError unless File.extname(path) == '.rb'
+			configure_and_generate(path, spec_folder)
+	 	end
+	end
+end