to_factory 2.0.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,9 +17,17 @@ 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
+
+## Warning :warning:
+`ToFactory` writes into the `spec/factories` folder. Whilst it
+is tested and avoids overwriting existing factories,
+it is recommended that you execute after committing or when in a known
+safe state.
+
 
-Tested against Ruby 1.8.7, 1.9.2, 1.9.3, 2.0.0,  2.1.x, 2.2.0
 
 
 ## Installation :file_folder:
@@ -33,13 +41,6 @@ group :test, :development do
 end
 ```
 
-## Warning :warning:
-`ToFactory` writes into the `spec/factories` folder. Whilst it
-is tested and avoids overwriting existing factories,
-it is recommended that you execute after committing or when in a known
-safe state.
-
-
 
 ```bash
 git add spec/factories
@@ -67,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(&:hierarchy_order)
+      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=[])
-      instances = @model_finder.call(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,9 +23,25 @@ module ToFactory
     end
 
     def wrap_factories(definitions)
-      out =  "FactoryGirl.define do\n"
-      out << definitions.join("\n\n")
+      out =  "FactoryBot.define do\n"
+      out << indent(definitions).join("\n\n")
+      out << "\n" unless out[-1] == "\n"
       out << "end"
+      out << "\n" unless out[-1] == "\n"
+    end
+
+    def indent(definitions)
+      definitions.map do |d|
+        if d[/\A\s\s/]
+          d
+        else
+          lines = d.split("\n").map do |l|
+            "  #{l}"
+          end
+
+          lines.join("\n")
+        end
+      end
     end
 
     def mkdir(name)

data/lib/to_factory/finders/factory.rb

@@ -15,8 +15,14 @@ module ToFactory
 
       def parsed_files
         Dir.glob(File.join(ToFactory.factories, "**/*.rb")).map do |f|
-          ToFactory::Parsing::File.parse(f)
-        end
+          parse_file(f)
+        end.compact
+      end
+
+      def parse_file(f)
+        ToFactory::Parsing::File.parse(f)
+      rescue ToFactory::Parsing::File::EmptyFileException => e
+        # ignore empty files
       end
     end
   end

data/lib/to_factory/finders/model.rb

@@ -1,10 +1,11 @@
 module ToFactory
   module Finders
     class Model
-      def call(exclusions=[])
+      def call(exclusions: [], klasses: nil)
         instances = []
+        klasses ||= find_klasses(exclusions)
 
-        each_klass(exclusions) do |klass|
+        klasses.each do |klass|
           if instance = get_active_record_instance(klass)
             instances << instance
           end
@@ -15,14 +16,17 @@ module ToFactory
 
       private
 
-      def each_klass(exclusions)
+      def find_klasses(exclusions)
+        klasses = []
         models.each do |file|
           matching_lines(file) do |match|
             klass = rescuing_require(file, match)
 
-            break if exclusions.include?(klass) || yield(klass)
+            klasses << klass unless exclusions.include?(klass)
           end
         end
+
+        klasses
       end
 
       def models
@@ -48,15 +52,9 @@ module ToFactory
       end
 
       def get_active_record_instance(klass)
-        if klass && klass.ancestors.include?(ActiveRecord::Base)
-          begin
-            klass.first
-          rescue
-            klass.find(:first)
-          end
-        end
-      rescue Exception => e
-        warn "Failed to get record from #{klass} #{e.message}"
+        klass.first if klass && klass.ancestors.include?(ActiveRecord::Base)
+      rescue StandardError => e
+        warn "Failed to get record from #{klass} #{e.message.inspect}"
       end
     end
   end

data/lib/to_factory/generation/attribute.rb

@@ -1,6 +1,8 @@
 module ToFactory
   module Generation
     class Attribute
+      attr_writer :parser
+
       def initialize(attribute, value)
         @attribute = attribute
         @value = value
@@ -11,24 +13,22 @@ 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)
         when Date
           value.to_s.inspect
         when BigDecimal
-          value.to_f.inspect
+          "BigDecimal.new(#{value.to_s.inspect})"
         when Hash
           inspect_hash(value, nested)
         when Array
@@ -45,7 +45,7 @@ module ToFactory
       def validate_parseable!(value)
         return value if parse(value)
 
-        "ToFactory: RubyParser exception parsing this attribute after factory generation"
+        "ToFactory: RubyParser exception parsing this attribute"
       end
 
       def parse(value)
@@ -65,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
 
@@ -87,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,33 +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
-    class File
-      delegate :multiple_factories?, :header?, :parse, :to => :parser
-      attr_reader :contents
+    ParseException = Class.new ::StandardError
+
+    class CouldNotInferClassException < ParseException
+      attr_reader :sexp
 
-      def self.parse(filename)
-        from_file(filename).parse
+      def initialize(sexp)
+        @sexp = sexp
       end
+    end
+
+    class File
+      EmptyFileException = Class.new ArgumentError
+
+      include Parsing::RubyParsingHelpers
+      attr_accessor :contents
 
-      def self.from_file(filename)
-        contents = ::File.read filename rescue nil
-        raise ArgumentError.new "Invalid file #{filename}"  if contents.to_s.length == 0
+      class << self
+        def parse(filename)
+          from_file(filename).parse
+        end
 
-        new(contents)
+        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)
+        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.0.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
@@ -59,12 +58,3 @@ def ToFactory(args=nil)
 
   sync.perform(exclusions)
 end
-
-if defined?(Rails)
-  unless Rails.respond_to?(:configuration)
-    #FactoryGirl 1.3.x expects this method, but it isn't defined in Rails 2.0.2
-    def Rails.configuration
-      OpenStruct.new
-    end
-  end
-end