to_factory 2.1.0 → 3.0.0.pre.pre

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# CHANGELOG
+
+## master
+
+## 3.0.0 (2022-12-31)
+
+### Support FactoryBot
+
+* Add support for FactoryBot syntax
+* drop FactoryGirl support
+* drop any references to old or older FactoryGirl syntax

data/Gemfile

@@ -1,5 +1,10 @@
 source "https://rubygems.org"
 
-gem "codeclimate-test-reporter", :group => :test, :require => nil
+group :test do
+  gem 'simplecov', require: false
+  gem 'rspec-github', require: false
+  gem 'byebug'
+  gem 'pry'
+end
 
 gemspec

data/README.md

@@ -17,7 +17,7 @@ If you find yourself retro-fitting tests this gem will save you some of the legw
 * adhoc generate from existing records
 * unintrusively update factory files in place
 * display factory definition for a record
-* parse and write `FactoryGirl` syntax or older `Factory.define` syntax
+* parse and write `FactoryBot` syntax
 
 Tested against Ruby 1.8.7, 1.9.2, 1.9.3, 2.0.0,  2.1.x, 2.2.x
 
@@ -41,15 +41,6 @@ group :test, :development do
 end
 ```
 
-For Ruby < `2.x` and older `FactoryGirl` syntax etc
-
-```ruby
-group :test, :development do
-  gem "to_factory", "~> 0.2.1"
-end
-```
-
-
 
 ```bash
 git add spec/factories
@@ -77,7 +68,7 @@ ToFactory(exclude: [User, Project])
 ToFactory User.last
 
 #writes to spec/factories/user.rb
-FactoryGirl.define
+FactoryBot.define
   factory(:user) do |u|
     email "test@example.com"
     name "Mike"

data/Rakefile

@@ -1,34 +1,42 @@
 require "bundler/gem_tasks"
+require 'byebug'
 
 namespace :spec do
   def setup_db
-    require 'logger'
-    require 'active_record'
-    ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => "spec/db/test.sqlite3")
-    ActiveRecord::Base.logger = Logger.new(File.open('tmp/database.log', 'a'))
+    require "logger"
+    require "active_record"
+    ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: "spec/db/test.sqlite3")
+    ActiveRecord::Base.logger = Logger.new(File.open("tmp/database.log", "a"))
+    ActiveRecord::Migrator.migrations_paths = File.expand_path("./spec/db/migrate")
   end
 
   desc "Migrate the database through scripts in db/migrate. Target specific version with VERSION=x"
   task :migrate_db do
     setup_db
-    ActiveRecord::Migrator.migrate('spec/db/migrate')
+    ActiveRecord::Tasks::DatabaseTasks.migrate
   end
 
   desc "Migrate down"
   task :migrate_down do
     setup_db
-    ActiveRecord::Migrator.down('spec/db/migrate')
+    ActiveRecord::Migrator.new.migrate(:down)
   end
 end
 
 begin
-  require 'rspec/core/rake_task'
+  require "rspec/core/rake_task"
   RSpec::Core::RakeTask.new do |t|
     t.rspec_opts = ["-c", "-f progress", "-r ./spec/spec_helper.rb"]
-    t.pattern = 'spec/**/*_spec.rb'
+    t.pattern = "spec/**/*_spec.rb"
   end
-  task :default => :spec
+  task default: :spec
 rescue LoadError
 
 end
 
+begin
+  require "rubocop/rake_task"
+
+  RuboCop::RakeTask.new
+rescue LoadError
+end

data/lib/to_factory/collation.rb

@@ -2,11 +2,11 @@ module ToFactory
   AlreadyExists = Class.new ArgumentError
 
   class Collation
-    def self.organize(a,b)
+    def self.organize(a, b)
       new(a, b).organize
     end
 
-    def self.representations_from(a,b)
+    def self.representations_from(a, b)
       new(a, b).representations
     end
 
@@ -16,14 +16,14 @@ module ToFactory
     end
 
     def organize
-      representations.group_by{|i| i.klass.name.underscore}.inject({}) do |o, (klass_name,r)|
-        o[klass_name] = r.sort_by{|r| [r.hierarchy_order, r.name]}
+      representations.group_by { |i| i.klass.name.underscore }.inject({}) do |o, (klass_name, r)|
+        o[klass_name] = r.sort_by { |r| [r.hierarchy_order, r.name] }
         o
       end
     end
 
     def representations
-      detect_collisions!(@a,@b)
+      detect_collisions!(@a, @b)
 
       inference = KlassInference.new(merged)
 
@@ -36,7 +36,7 @@ module ToFactory
       merged
     end
 
-    def detect_collisions!(a,b)
+    def detect_collisions!(a, b)
       collisions = []
       a.each do |x|
         b.each do |y|
@@ -53,8 +53,8 @@ module ToFactory
       @merged ||= @a + @b
     end
 
-   def raise_already_exists!(keys)
-     raise ToFactory::AlreadyExists.new "an item for each of the following keys #{keys.inspect} already exists"
-    end
+    def raise_already_exists!(keys)
+      fail ToFactory::AlreadyExists.new "an item for each of the following keys #{keys.inspect} already exists"
+     end
   end
 end

data/lib/to_factory/file_sync.rb

@@ -8,20 +8,20 @@ module ToFactory
       @factory_finder = ff
     end
 
-    def perform(exclusions=[])
+    def perform(exclusions = [])
       @file_writer.write(all_representations exclusions)
     end
 
-    def all_representations(exclusions=[])
+    def all_representations(exclusions = [])
       Collation.organize(
         new_representations(exclusions),
         existing_representations)
     end
 
-    def new_representations(exclusions=[])
+    def new_representations(exclusions = [])
       instances = @model_finder.call(exclusions: exclusions)
 
-      instances.map{|r| Representation.from(r) }
+      instances.map { |r| Representation.from(r) }
     end
 
     private
@@ -34,16 +34,16 @@ module ToFactory
       if m.respond_to?(:call)
         m
       else
-        lambda{|exclusions|
+        lambda do|exclusions|
           exclusions ||= []
           records = if m.is_a?(ActiveRecord::Base)
-            Array m
-          else
-            m
+                      Array m
+                    else
+                      m
           end
 
-          records.reject{|o,_| exclusions.include?(o.class)}
-        }
+          records.reject { |o, _| exclusions.include?(o.class) }
+        end
       end
     end
   end

data/lib/to_factory/file_writer.rb

@@ -23,7 +23,7 @@ module ToFactory
     end
 
     def wrap_factories(definitions)
-      out =  "FactoryGirl.define do\n"
+      out =  "FactoryBot.define do\n"
       out << indent(definitions).join("\n\n")
       out << "\n" unless out[-1] == "\n"
       out << "end"

data/lib/to_factory/finders/factory.rb

@@ -22,7 +22,7 @@ module ToFactory
       def parse_file(f)
         ToFactory::Parsing::File.parse(f)
       rescue ToFactory::Parsing::File::EmptyFileException => e
-        #ignore empty files
+        # ignore empty files
       end
     end
   end

data/lib/to_factory/finders/model.rb

@@ -22,7 +22,7 @@ module ToFactory
           matching_lines(file) do |match|
             klass = rescuing_require(file, match)
 
-            klasses << klass unless exclusions.include?(klass) 
+            klasses << klass unless exclusions.include?(klass)
           end
         end
 
@@ -52,9 +52,7 @@ module ToFactory
       end
 
       def get_active_record_instance(klass)
-        if klass && klass.ancestors.include?(ActiveRecord::Base)
-          klass.first
-        end
+        klass.first if klass && klass.ancestors.include?(ActiveRecord::Base)
       rescue StandardError => e
         warn "Failed to get record from #{klass} #{e.message.inspect}"
       end

data/lib/to_factory/generation/attribute.rb

@@ -13,17 +13,15 @@ module ToFactory
         "    #{setter}"
       end
 
-      def inspect_value(value, nested=false)
+      def inspect_value(value, nested = false)
         formatted = format(value, nested)
 
-        if !value.is_a?(Hash) && !nested
-          formatted = " #{formatted}"
-        end
+        formatted = " { #{formatted} }" if !value.is_a?(Hash) && !nested
 
         formatted
       end
 
-      def format(value, nested=false)
+      def format(value, nested = false)
         case value
         when Time, DateTime
           inspect_time(value)
@@ -67,17 +65,17 @@ module ToFactory
       def inspect_hash(value, nested)
         formatted = value.keys.inject([]) do |a, key|
           a << key_value_pair(key, value)
-        end.join(', ')
+        end.join(", ")
 
         if nested
           "{#{formatted}}"
         else
-          "({#{formatted}})"
+          " { {#{formatted}} }"
         end
       end
 
       def inspect_array(value, nested)
-        values = value.map{|v| format(v, nested)}.join(", ")
+        values = value.map { |v| format(v, nested) }.join(", ")
         "[#{values}]"
       end
 
@@ -89,5 +87,3 @@ module ToFactory
     end
   end
 end
-
-

data/lib/to_factory/generation/factory.rb

@@ -28,7 +28,7 @@ module ToFactory
       def attributes
         to_skip = [:id, :created_at, :created_on, :updated_at, :updated_on]
 
-        @representation.attributes.delete_if{|key, _| key.nil? || to_skip.include?(key.to_sym)}
+        @representation.attributes.delete_if { |key, _| key.nil? || to_skip.include?(key.to_sym) }
       end
 
       private
@@ -37,14 +37,14 @@ module ToFactory
         @representation.parent_name
       end
 
-      def generic_header(factory_start, block_arg, ending, &block)
+      def generic_header(factory_start, block_arg, ending, &_block)
         out =  "#{factory_start}(:#{name}#{parent_clause}) do#{block_arg}\n"
         out << yield.to_s
         out << "#{ending}\n"
       end
 
       def parent_clause
-        has_parent? ?  ", :parent => :#{add_quotes parent_name}" : ""
+        has_parent? ? ", :parent => :#{add_quotes parent_name}" : ""
       end
 
       def has_parent?

data/lib/to_factory/klass_inference.rb

@@ -14,14 +14,12 @@ module ToFactory
       end
     end
 
-    def infer(factory_name, count=0)
-      count = count + 1
-      result  = @mapping[factory_name]
+    def infer(factory_name, count = 0)
+      count += 1
+      result = @mapping[factory_name]
       return [result, count] if result.is_a? Class
 
-      if result.nil?
-        raise CannotInferClass.new(factory_name)
-      end
+      fail CannotInferClass.new(factory_name) if result.nil?
 
       infer(result, count)
     end

data/lib/to_factory/options_parser.rb

@@ -6,10 +6,10 @@ module ToFactory
 
     def get_instance
       args = case @options
-      when ActiveRecord::Base
-        from_record(@options)
-      when Array
-        from_array(*@options)
+             when ActiveRecord::Base
+               from_record(@options)
+             when Array
+               from_array(*@options)
       end
 
       Representation.new(*args)

data/lib/to_factory/parsing/file.rb

@@ -1,35 +1,106 @@
-require 'ruby2ruby'
-require 'ruby_parser'
+require "ruby2ruby"
+require "ruby_parser"
 require "to_factory/parsing/ruby_parsing_helpers"
-require 'to_factory/parsing/syntax'
 
 module ToFactory
   module Parsing
+    ParseException = Class.new ::StandardError
+
+    class CouldNotInferClassException < ParseException
+      attr_reader :sexp
+
+      def initialize(sexp)
+        @sexp = sexp
+      end
+    end
+
     class File
       EmptyFileException = Class.new ArgumentError
 
-      delegate :multiple_factories?, :header?, :parse, :to => :parser
-      attr_reader :contents
+      include Parsing::RubyParsingHelpers
+      attr_accessor :contents
 
-      def self.parse(filename)
-        from_file(filename).parse
-      end
+      class << self
+        def parse(filename)
+          from_file(filename).parse
+        end
 
-      def self.from_file(filename)
-        contents = ::File.read filename rescue nil
-        raise EmptyFileException.new "Invalid file #{filename}"  if contents.to_s.strip.length == 0
+        def from_file(filename)
+          begin
+            contents = ::File.read filename
+          rescue
+            nil
+          end
+          fail EmptyFileException.new "Invalid file #{filename}" if contents.to_s.strip.length == 0
 
-        new(contents)
+          new(contents)
+        end
       end
 
       def initialize(contents)
         @contents = contents
       end
 
-      def parser
-        @parser ||= Syntax.new(@contents)
+      def multiple_factories?
+        factories_sexp[0] == :block
       end
 
+      def parse
+        factories.map do |x|
+          representation_from(x)
+        end
+
+      rescue Racc::ParseError, StringScanner::Error => e
+        raise ParseException.new("Original exception: #{e.message}\n #{e.backtrace.join("\n")}\nToFactory Error parsing \n#{@contents}\n o")
+      end
+
+      def header?
+        sexp[1][1][1] == :FactoryBot
+      rescue
+        false
+      end
+
+      private
+
+      def representation_from(x)
+        Representation.new(name_from(x), parent_from(x), to_ruby(x))
+      rescue CouldNotInferClassException => e
+        ruby = to_ruby(e.sexp)
+        Kernel.warn "ToFactory could not parse\n#{ruby}"
+        NullRepresentation.new(e.sexp)
+      end
+
+      def factories
+        if multiple_factories?
+          factories_sexp[1..-1]
+        else
+          [factories_sexp]
+        end
+      end
+
+      def factories_sexp
+        header? ? sexp[3] : sexp
+      end
+
+      def name_from(sexp)
+        sexp[1][3][1]
+      rescue NoMethodError
+        raise CouldNotInferClassException.new(sexp)
+      end
+
+      def parent_from(x)
+        # e.g.
+        # s(:call, nil, :factory, s(:lit, :admin), s(:hash, s(:lit, :parent), s(:lit, :"to_factory/user")))
+        x[1][4][2][1]
+      rescue NoMethodError
+        # e.g.
+        # s(:call, nil, :factory, s(:lit, :"to_factory/user"))
+        x[1][3][1]
+      end
+
+      def sexp
+        @sexp ||= ruby_parser.process(@contents)
+      end
     end
   end
 end

data/lib/to_factory/representation.rb

@@ -19,18 +19,19 @@ module ToFactory
     end
   end
 
-
   class Representation
-    delegate :attributes, :to => :record
+    delegate :attributes, to: :record
     attr_accessor :klass, :name, :parent_name, :definition, :hierarchy_order, :record
 
     def self.from(options)
       OptionsParser.new(options).get_instance
     end
 
-    def initialize(name, parent_name, definition=nil, record=nil)
-      @name, @parent_name, @definition, @record =
-        name.to_s, parent_name.to_s, definition, record
+    def initialize(name, parent_name, definition = nil, record = nil)
+      @name = name.to_s
+      @parent_name = parent_name.to_s
+      @definition = definition
+      @record = record
     end
 
     def inspect
@@ -38,7 +39,9 @@ module ToFactory
     end
 
     def klass_name_inspect
-      @klass.name.inspect rescue "nil"
+      @klass.name.inspect
+    rescue
+      "nil"
     end
 
     def definition

data/lib/to_factory/version.rb

@@ -1,3 +1,3 @@
 module ToFactory
-  VERSION = "2.1.0"
+  VERSION = "3.0.0-pre"
 end

data/lib/to_factory.rb

@@ -1,4 +1,4 @@
-require 'fileutils'
+require "fileutils"
 
 require "to_factory/version"
 require "to_factory/config"
@@ -13,22 +13,21 @@ require "to_factory/parsing/file"
 require "to_factory/representation"
 require "to_factory/klass_inference"
 require "to_factory/options_parser"
-require "factory_girl"
+#require "factory_bot"
 
 module ToFactory
-  class MissingActiveRecordInstanceException < Exception;end
-  class NotFoundError < Exception;end
+  class MissingActiveRecordInstanceException < Exception; end
+  class NotFoundError < Exception; end
 
   class << self
-
     def definition_for(item)
       if item.is_a? ActiveRecord::Base
         Representation.from(item).definition
       else
-        if found = representations.find{|r| r.name.to_s == item.to_s }
+        if found = representations.find { |r| r.name.to_s == item.to_s }
           found.definition
         else
-          raise NotFoundError.new "No definition found for #{item}"
+          fail NotFoundError.new "No definition found for #{item}"
         end
       end
     end
@@ -45,7 +44,7 @@ end
 
 public
 
-def ToFactory(args=nil)
+def ToFactory(args = nil)
   exclusions = if args.is_a?(Hash)
                  exclusions = Array(args.delete(:exclude) || [])
                  args = nil if args.keys.length == 0

data/spec/db/migrate/1_create_users.rb

@@ -1,13 +1,13 @@
-class CreateUsers < ActiveRecord::Migration
-  def self.up
+class CreateUsers < ActiveRecord::Migration[6.1]
+  def up
     create_table :users do |t|
-      t.column :name, :string, :null => false
+      t.column :name, :string, null: false
       t.column :email, :string
       t.integer :some_id
     end
   end
 
-  def self.down
+  def down
     drop_table :users
   end
 end

data/spec/db/migrate/2_create_projects.rb

@@ -1,13 +1,13 @@
-class CreateProjects < ActiveRecord::Migration
-  def self.up
+class CreateProjects < ActiveRecord::Migration[6.1]
+  def up
     create_table :projects do |t|
-      t.column :name, :string, :null => false
+      t.column :name, :string, null: false
       t.column :objective, :string
       t.integer :some_id
     end
   end
 
-  def self.down
+  def down
     drop_table :projects
   end
 end

data/spec/db/migrate/3_create_not_namespaced.rb

@@ -1,11 +1,11 @@
-class CreateNotNamespaced < ActiveRecord::Migration
-  def self.up
+class CreateNotNamespaced < ActiveRecord::Migration[6.1]
+  def up
     create_table :not_namespaced_active_record_class_but_long_enough_it_shouldnt_cause_conflicts do |t|
-      t.column :name, :string, :null => false
+      t.column :name, :string, null: false
     end
   end
 
-  def self.down
+  def down
     drop_table :not_namespaced_active_record_class_but_long_enough_it_shouldnt_cause_conflicts
   end
 end

data/spec/db/migrate/4_add_birthday_to_users.rb

@@ -1,9 +1,9 @@
-class AddBirthdayToUsers < ActiveRecord::Migration
-  def self.up
+class AddBirthdayToUsers < ActiveRecord::Migration[6.1]
+  def up
     add_column :users, :birthday, :datetime
   end
 
-  def self.down
+  def down
     remove_column :users, :birthday
   end
 end

data/spec/db/migrate/5_add_serialized_attributes_to_users.rb

@@ -1,9 +1,9 @@
-class AddSerializedAttributesToUsers < ActiveRecord::Migration
-  def self.up
+class AddSerializedAttributesToUsers < ActiveRecord::Migration[6.1]
+  def up
     add_column :users, :some_attributes, :text
   end
 
-  def self.down
+  def down
     remove_column :users, :some_attributes
   end
 end

data/spec/example_factories/admin.rb

@@ -1,7 +1,7 @@
-factory(:admin, :parent => :"to_factory/user") do
-  birthday "2014-07-08T15:30 UTC"
-  email "admin@example.com"
-  name "Admin"
-  some_attributes({:a => 1})
-  some_id 9
+factory(:admin, parent: :"to_factory/user") do
+  birthday { "2014-07-08T15:30 UTC" }
+  email {"admin@example.com"}
+  name {"Admin"}
+  some_attributes {{a: 1}}
+  some_id { 9 }
 end