to_factory 0.0.3 → 0.1.0

data/spec/support/match_sexp.rb

@@ -0,0 +1,24 @@
+RSpec::Matchers.define :match_sexp do |expected|
+  match do |actual|
+    parser = RubyParser.new
+
+    begin
+      parser.process(expected) == parser.process(actual)
+    rescue Exception => e
+      @raised = e
+      false
+    end
+
+  end
+
+  failure_message do |actual|
+    message = "expected \n#{actual}\n\nto match expected sexp of\n\n#{expected}"
+
+    if @raised
+      message << "\nbut raised\n"
+      message << @raised.message
+    else
+      message
+    end
+  end
+end

data/spec/support/models/not_active_record.rb

@@ -0,0 +1,2 @@
+class ToFactory::NotActiveRecord
+end

data/spec/support/models/project.rb

@@ -0,0 +1,3 @@
+class ToFactory::Project < ActiveRecord::Base
+  self.table_name = "projects"
+end

data/spec/support/models/user.rb

@@ -0,0 +1,3 @@
+class ToFactory::User < ActiveRecord::Base
+  self.table_name = "users"
+end

data/spec/support/terse_expect_syntax.rb

@@ -0,0 +1,23 @@
+module TerseExpectSyntax
+  class Returner
+    def initialize(to_call)
+      @to_call=to_call
+    end
+    def r(*args)
+      @to_call.call(*args)
+    end
+  end
+
+  #x(     @a,            :b,      "c").r          d
+  #becomes
+  #expect(@a).to_receive(:b).with("c").and_return d
+  def x(target, expected_method, *received_args)
+    receiver = expect(target).to receive(expected_method)
+    if received_args.any?
+      receiver = receiver.with(*received_args)
+    end
+
+
+    Returner.new(lambda {|*return_args| receiver.and_return(*return_args) })
+  end
+end

data/spec/unit/collation_spec.rb

@@ -0,0 +1,35 @@
+describe ToFactory::Collation do
+  def perform
+    ToFactory::Collation.merge(a, b)
+  end
+
+  context "matching keys" do
+    let(:a) { {:A => {:a => 1}} }
+    let(:b) { {:B => {:a => 2}} }
+
+    it do
+      expect(lambda{perform}).to raise_error ToFactory::AlreadyExists
+    end
+  end
+
+  context "non matching keys" do
+    let(:a) { {:A => {:a => 1}} }
+    let(:b) { {:B => {:b => 2}} }
+
+    it do
+      result = {:A => {:a  => 1}, :B => {:b => 2}}.with_indifferent_access
+      expect(perform).to eq result
+    end
+  end
+
+  context "merging" do
+    let(:a) { {:A => {:a => 1}} }
+    let(:b) { {:A => {:b => 2}} }
+
+    it do
+      result = {:A => {:a  => 1, :b => 2}}.with_indifferent_access
+      expect(perform).to eq result
+    end
+  end
+end
+

data/spec/unit/definition_group_spec.rb

@@ -0,0 +1,19 @@
+describe ToFactory::DefinitionGroup do
+  let(:user) { create_user! }
+  let(:admin) { create_admin! }
+  let(:user_definition) { File.read "./spec/example_factories/#{version}_syntax/user.rb"}
+  let(:admin_definition) { File.read "./spec/example_factories/#{version}_syntax/admin.rb"}
+  let(:group) { ToFactory::DefinitionGroup.new }
+
+  it do
+    result = group.perform([[:"to_factory/user", user], [:admin, admin]])
+
+    expect(result.keys[0]).to eq ToFactory::User
+    expect(result.values[0][:"to_factory/user"]).to match_sexp user_definition
+    expect(result.values[0][:admin]).to match_sexp admin_definition
+  end
+
+  it "#calculate_name" do
+    expect(group.calculate_name(ToFactory::Project)).to eq "to_factory/project"
+  end
+end

data/spec/unit/file_writer_spec.rb

@@ -0,0 +1,28 @@
+describe ToFactory::FileWriter do
+  let(:fw) { ToFactory::FileWriter.new }
+
+  describe "#write" do
+    def user_file
+      File.read("tmp/factories/to_factory/user.rb")
+    end
+
+    def project_file
+      File.read("tmp/factories/to_factory/project.rb")
+    end
+
+    it "adds factories for all models" do
+      fw.write({ToFactory::User =>{:user => "factory a"},
+                ToFactory::Project => {:project =>"factory b"}
+      })
+
+      if ToFactory.new_syntax?
+        expect(user_file).to match /FactoryGirl.define do/
+      end
+      expect(user_file).to include "factory a"
+      expect(project_file).to include "factory b"
+    end
+  end
+
+
+
+end

data/spec/unit/finders/factory_spec.rb

@@ -0,0 +1,27 @@
+describe ToFactory::Finders::Factory do
+  describe "#call" do
+    before do
+      FileUtils.mkdir_p "./tmp/factories/to_factory"
+      FileUtils.cp "./spec/example_factories/#{version}_syntax/user_admin_with_header.rb",
+        "./tmp/factories/to_factory/user.rb"
+    end
+
+    let(:user_file_contents) { File.read "./spec/example_factories/#{version}_syntax/user.rb"}
+    let(:admin_file_contents){ File.read "./spec/example_factories/#{version}_syntax/admin.rb" }
+
+    it "reads all the factories" do
+      finder = ToFactory::Finders::Factory.new
+
+      result = finder.call
+      result = result[ToFactory::User]
+
+      expect(result[:"to_factory/user"]).
+        to match_sexp user_file_contents
+
+      expect(result[:admin]).
+        to match_sexp admin_file_contents
+    end
+  end
+
+end
+

data/spec/unit/finders/model_spec.rb

@@ -0,0 +1,28 @@
+describe ToFactory::Finders::Model do
+  before do
+    ToFactory.models = path
+  end
+
+  let(:finder) { ToFactory::Finders::Model.new }
+
+  describe "#call" do
+    let!(:user) { ToFactory::User.create! :name => "a user"}
+    let!(:project) { ToFactory::Project.create! :name => "a project"}
+
+    context "no match"do
+      let(:path) { "./tmp/doesnt_exist" }
+      it do
+        expect(finder.call).to eq []
+      end
+    end
+    context "with a match" do
+      let(:path) { "./spec/support/models" }
+      it do
+        expect(finder.call).to match_array [user, project]
+      end
+    end
+  end
+
+end
+
+

data/spec/unit/generator_spec.rb

@@ -0,0 +1,71 @@
+describe ToFactory::Generation::Factory do
+  before(:each) do
+    ToFactory::User.destroy_all
+    ActiveRecord::Base.connection.execute "delete from sqlite_sequence where name = 'users'"
+  end
+
+  let(:birthday) do
+    Time.find_zone("UTC").parse("2014-07-08T15:30Z") 
+  end
+
+  let!(:user) { create_user! }
+
+  let(:generator) { ToFactory::Generation::Factory.new user, :"to_factory/user"  }
+
+  describe ".new" do
+    it "requires an activerecord instance" do
+      expect(lambda{ToFactory::Generation::Factory.new "", ""}).to raise_error ToFactory::MissingActiveRecordInstanceException
+    end
+  end
+
+  describe "#header" do
+    it do
+      if ToFactory.new_syntax?
+      expect(generator.header{}).to match_sexp  <<-eof.strip_heredoc
+        factory(:"to_factory/user") do
+        end
+      eof
+      else
+      expect(generator.header{}).to match_sexp  <<-eof.strip_heredoc
+        Factory.define(:"to_factory/user") do |o|
+        end
+      eof
+      end
+    end
+  end
+
+  describe "#factory_attribute" do
+    it do
+      if ToFactory.new_syntax?
+        expect(generator.factory_attribute(:name, nil))   .to eq '    name nil'
+        expect(generator.factory_attribute(:name, "Jeff")).to eq '    name "Jeff"'
+        expect(generator.factory_attribute(:id, 8))       .to eq '    id 8'
+
+      else
+        expect(generator.factory_attribute(:name, nil))   .to eq '  o.name nil'
+        expect(generator.factory_attribute(:name, "Jeff")).to eq '  o.name "Jeff"'
+        expect(generator.factory_attribute(:id, 8))       .to eq '  o.id 8'
+      end
+    end
+    it "generates usable datetime strings" do
+      output = generator.factory_attribute(:birthday, birthday)
+      if ToFactory.new_syntax?
+        expect(output).to eq '    birthday "2014-07-08T15:30Z"'
+      else
+        expect(output).to eq '  o.birthday "2014-07-08T15:30Z"'
+      end
+    end
+  end
+
+  describe "#ToFactory" do
+    let(:expected) do
+      File.read "./spec/example_factories/#{version}_syntax/user.rb"
+    end
+
+    it do
+      expect(generator.to_factory).to match_sexp expected
+      result = ToFactory(user).values.first.values.first
+      expect(result).to match_sexp expected
+    end
+  end
+end

data/spec/unit/parsing/file_spec.rb

@@ -0,0 +1,83 @@
+describe ToFactory::Parsing::File do
+  let(:user_contents) { File.read "spec/example_factories/#{version}_syntax/user.rb" }
+  let(:admin_contents) { File.read "spec/example_factories/#{version}_syntax/admin.rb"}
+
+  let(:parser) { ToFactory::Parsing::File.from_file(filename) }
+
+  describe "#multiple_factories? and #header?" do
+    context "new syntax" do
+      tests = if ToFactory.new_syntax?
+
+                #file,                      multiple, header
+                [
+                  ["user",                   false,   false],
+                  ["user_with_header",       false,   true],
+                  ["user_admin",             true,    false],
+                  ["user_admin_with_header", true,    true]
+                ]
+              else
+                [
+                  ["user",                   false,   false],
+                  ["user_admin",             true,    false],
+                ]
+              end
+
+      tests.each do |file, multiple, header|
+        context "with #{header ? 'header' : 'no header'} and #{multiple ? 'multiple factories' : 'one factory'}" do
+          context "file: #{file}" do
+            let(:filename) { "spec/example_factories/#{version}_syntax/#{file}.rb"}
+
+            it { expect(parser.multiple_factories?).to eq multiple }
+            it { expect(parser.header?).to eq header }
+          end
+        end
+      end
+    end
+  end
+
+  describe "#parse" do
+    context "file: user" do
+      let(:filename) { "spec/example_factories/#{version}_syntax/#{'user'}.rb"}
+
+      it do
+        result = parser.parse[ToFactory::User]
+
+        expect(result[:"to_factory/user" ]).to match_sexp user_contents
+      end
+    end
+
+    context "file: user_with_header" do
+      let(:filename) { "spec/example_factories/#{version}_syntax/#{'user_with_header'}.rb"}
+
+      it do
+        result = parser.parse[ToFactory::User]
+
+        expect(result[:"to_factory/user" ]).to match_sexp user_contents
+      end
+    end
+
+    context "file: user_admin" do
+      let(:filename) { "spec/example_factories/#{version}_syntax/#{'user_admin'}.rb"}
+
+      it do
+        result = parser.parse
+
+        expect(result.keys).to match_array [ToFactory::User]
+        users = result[ToFactory::User]
+
+        expect(users[:"to_factory/user" ]).to match_sexp user_contents
+        expect(users[:admin]).to match_sexp admin_contents
+      end
+    end
+
+    context "file: user_admin_with_header" do
+      let(:filename) { "spec/example_factories/#{version}_syntax/#{'user_admin_with_header'}.rb"}
+
+      it do
+        result = parser.parse[ToFactory::User]
+
+        expect(result[:"to_factory/user" ]).to match_sexp user_contents
+      end
+    end
+  end
+end

data/to_factory.gemspec

@@ -1,23 +1,50 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "to_factory/version"
-
-Gem::Specification.new do |s|
-  s.name        = "to_factory"
-  s.version     = ToFactory::VERSION
-  s.authors     = ["Mark Burns"]
-  s.email       = ["markthedeveloper@gmail.com"]
-  s.homepage    = ""
-  s.summary     = %q{Turn ActiveRecord instances into factories}
-  s.add_dependency('factory_girl_rails')
-  s.add_dependency('rails', '~>3.0')
-
-  s.description = %q{This gem gives the object.to_factory method to give a formatted string version of an ActiveRecord object that can be used by factory_girl}
-
-  s.rubyforge_project = "to_factory"
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'to_factory/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "to_factory"
+  spec.version       = ToFactory::VERSION
+  spec.authors       = ["Mark Burns"]
+  spec.email         = ["markthedeveloper@gmail.com"]
+  spec.summary     = %q{Turn ActiveRecord instances into factories}
+  spec.description = %q{ActiveRecord::Base#to_factory method to create factory_girl definitions from real data}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}){ |f| File.basename(f) }.reject{|f| f== "spec" || f =="ci" }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "sqlite3" , "~> 1.3.6"
+
+  if RUBY_VERSION =~ /^1\.8/
+    spec.add_development_dependency "ruby-debug"
+    spec.add_development_dependency "database_cleaner", "~> 0.3"
+  else
+    spec.add_development_dependency "database_cleaner", "~> 1.4.0"
+  end
+
+  if RUBY_VERSION =~ /^2\.\d/
+    spec.add_development_dependency "pry-byebug"
+  end
+
+  old_active_record = RUBY_VERSION =~ /^1\.8|^1.9\.[1|2]/
+
+  spec.add_dependency "ruby2ruby"
+  spec.add_dependency "deep_merge"
+
+  if old_active_record
+    spec.add_dependency  'activerecord', ">2.0", "< 4.0"
+    spec.add_dependency  'i18n', "< 0.7"
+    spec.add_development_dependency "factory_girl", "< 2.0"
+  else
+    spec.add_dependency  'activerecord', ">3.0"
+    spec.add_development_dependency "factory_girl", "~> 4.5"
+  end
+
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rake", "~> 10.0"
 end