to_factory 0.0.3 → 0.1.0

data/.gitignore

@@ -3,3 +3,9 @@
 pkg/*
 *.swp
 tmp/database.log
+Gemfile.lock
+coverage/
+spec/db/test.sqlite3
+tmp/*
+!tmp/.keep
+*.sqlite3

data/.rspec

@@ -1 +1,2 @@
---drb
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,23 @@
+language: ruby
+rvm:
+  - 2.2.0
+  - 2.1.5
+  - 2.1.4
+  - 2.1.3
+  - 2.1.2
+  - 2.1.1
+  - 2.1.0
+
+  - 2.0.0
+
+  - 1.9.3
+  - 1.9.2
+
+  - 1.8.7
+script: "./bin/ci"
+
+branches:
+  only:
+    - master
+    - stable
+

data/Gemfile

@@ -1,16 +1,6 @@
-source "http://rubygems.org"
-source "http://gems.github.com"
+source "https://rubygems.org"
 
-group :development, :test do
-  gem 'factory_girl_rails'
-  gem 'rspec'
-  gem 'wirble'
-  gem 'spork'
-  gem 'activesupport', "~>3.0"
-  gem 'sqlite3'
-  gem 'ruby-debug'
-  gem 'activerecord'
+if RUBY_VERSION != "1.8.7"
+  gem "codeclimate-test-reporter", :group => :test, :require => nil
 end
-
-# Specify your gem's dependencies in to_factory.gemspec
 gemspec

data/README.md

@@ -1,41 +1,80 @@
 ToFactory
 =========
-This is a little convenience gem for the scenario where
-you find yourself writing factories for a pre-existing project.
 
-E.g. they didn't have tests or they were using Test:Unit with fixtures but you prefer
-RSpec and FactoryGirl.
+[![Build Status](https://travis-ci.org/markburns/to_factory.svg)](https://travis-ci.org/markburns/to_factory)
+[![Dependency Status](http://img.shields.io/gemnasium/markburns/to_factory.svg)](https://gemnasium.com/markburns/to_factory)
+[![Code Climate](http://img.shields.io/codeclimate/github/markburns/to_factory.svg)](https://codeclimate.com/github/markburns/to_factory)
+[![Test Coverage](https://codeclimate.com/github/markburns/to_factory/badges/coverage.svg)](https://codeclimate.com/github/markburns/to_factory)
+[![Gem Version](http://img.shields.io/gem/v/to_factory.svg)](https://rubygems.org/gems/to_factory)
+[![License](http://img.shields.io/:license-mit-blue.svg)](http://markburns.mit-license.org)
+[![Badges](http://img.shields.io/:badges-6/6-ff6799.svg)](https://github.com/badges/badgerbadgerbadger)
 
-Installation
-___________
+Easily add factories with valid data for an existing project.
+
+If you find yourself working on a project without tests/factories or only using fixtures,
+then use this gem to quickly generate a factory from an existing object.
+
+Tested against Ruby 1.8.7, 1.9.2, 1.9.3, 2.0.0,  2.1.x
+
+Reads and writes both new `FactoryGirl`, syntax or older `Factory.define` syntax
 
-I've only tried this out with a Rails 3, Ruby 1.8.7 project.
+#Installation
+___________
 
 ```ruby
 
 #Gemfile
-group =>[:test, :development] do
+#add to whichever environments you want to generate data from
+group :test, :development do
   gem 'to_factory'
 end
 ```
 
+#Usage
 
-```bash
-bundle install
-```
+```ruby
+#Generate all factories
+ToFactory()
 
-Usage
-_____
+#outputs the first record of each ActiveRecord::Base subclass in the models folder
+#to spec/factories
 
-```ruby
-#rails console
+#Choose input/output directories
+ToFactory.models    = "models/this/subfolder/only" #default "./app/models"
+ToFactory.factories = "spec/support/factories"     #default "./spec/factories"
+ToFactory()
 
-> puts User.first.to_factory
+#Exclude classes
+ToFactory(exclude: [User, Project])
 
-#=>
-Factory.define :user do |u|
-  u.email "test@example.com"
-  u.name "Mike"
+#Use Adhoc instances from the console
+ToFactory User.last
+
+#writes to spec/factories/user.rb
+FactoryGirl.define
+  factory(:user) do |u|
+    email "test@example.com"
+    name "Mike"
+  end
 end
 
+#doesn't overwrite existing factories
+ToFactory User.last
+#Exception =>
+#ToFactory::AlreadyExists: an item for each of the following keys :user already exists
+
+#Choose specific name
+ToFactory :admin => User.last
+#appends to spec/factories/user.rb
+
 ```
+
+#Other useful projects
+
+If you are adding specs to an existing project you may want to look at:
+
+* [rspec-kickstarter](https://github.com/seratch/rspec-kickstarter) (auto generate specs)
+* [rspec-kickstarter-vintage](https://github.com/ifad/rspec-kickstarter-vintage) (for Ruby 1.8/Rspec 1.x)
+* [hash_syntax](https://github.com/michaeledgar/hash_syntax) (convert 1.8 syntax to 1.9 and vice-versa)
+* [transpec](https://github.com/yujinakayama/transpec) (convert old rspec syntax to new expect syntax)
+

data/Rakefile

@@ -1,18 +1,24 @@
-require 'bundler/gem_tasks'
-require 'logger'
-require 'active_record'
-require 'yaml'
+require "bundler/gem_tasks"
 
-namespace :test do
-  namespace :db do
-    desc "Migrate the database through scripts in db/migrate. Target specific version with VERSION=x"
-    task :migrate => :environment do
-      ActiveRecord::Migrator.migrate('spec/db/migrate', ENV["VERSION"] ? ENV["VERSION"].to_i : nil )
-    end
+namespace :spec do
+  desc "Migrate the database through scripts in db/migrate. Target specific version with VERSION=x"
+  task :migrate_db do
+    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.migrate('spec/db/migrate')
+  end
+end
 
-    task :environment do
-      ActiveRecord::Base.establish_connection(YAML::load(File.read('spec/config/database.yml')))
-      ActiveRecord::Base.logger = Logger.new(File.open('tmp/database.log', 'a'))
-    end
+begin
+  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'
   end
+  task :default => :spec
+rescue LoadError
+
 end
+

data/bin/ci

@@ -0,0 +1,2 @@
+mkdir tmp/
+CODECLIMATE_REPO_TOKEN=7ed88deb7375c6d5a3c87f7744987e3e5631bee4ff85c0599db2949d23158568 ./bin/spec

data/bin/spec

@@ -0,0 +1,2 @@
+bundle exec rake spec:migrate_db
+bundle exec rake

data/lib/to_factory/collation.rb

@@ -0,0 +1,34 @@
+module ToFactory
+  AlreadyExists = Class.new ArgumentError
+
+  class Collation
+    def self.merge(a, b)
+      c = new
+
+      c.merge_without_collisions(a.with_indifferent_access, b.with_indifferent_access)
+    end
+
+    def merge_without_collisions(a,b)
+      nested_detect_collisions!(a, b)
+
+      a.deep_merge(b)
+    end
+
+    def nested_detect_collisions!(a,b)
+      a.each do |a_klass, _|
+        b.each do |b_klass, _|
+          detect_collisions!(a[a_klass] || {}, b[b_klass] || {})
+        end
+      end
+    end
+
+    def detect_collisions!(a, b)
+      overlapping = a.keys & b.keys
+      raise_already_exists!(overlapping) if overlapping.any?
+    end
+
+    def raise_already_exists!(keys)
+      raise ToFactory::AlreadyExists.new "an item for each of the following keys #{keys} already exists"
+    end
+  end
+end

data/lib/to_factory/config.rb

@@ -0,0 +1,18 @@
+module ToFactory
+  class << self
+    attr_accessor :factories, :models
+
+    def reset_config!
+      @factories = nil
+      @models = nil
+    end
+
+    def factories
+      @factories ||= "./spec/factories"
+    end
+
+    def models
+      @models ||= "./app/models"
+    end
+  end
+end

data/lib/to_factory/definition_group.rb

@@ -0,0 +1,47 @@
+module ToFactory
+  class DefinitionGroup
+    def self.perform(instances)
+      new.perform(instances)
+    end
+
+    def perform(instances)
+      instances.inject({}) do |result, record|
+        klass, name, definition = define_factory(record)
+        result[klass] ||= {}
+        result[klass][name] = definition
+        result
+      end
+    end
+
+    def define_factory(record)
+      name, item, parent_klass = extract_details(record)
+
+      definition = ToFactory::Generation::Factory.new(item, name).to_factory(parent_klass)
+
+      [item.class, name, definition]
+    end
+
+    def calculate_name(klass)
+      klass.name.to_s.underscore
+    end
+
+    private
+
+    def extract_details(record)
+      if record.is_a?(ActiveRecord::Base)
+        name = calculate_name record.class
+
+        [name, record, nil]
+      elsif record.is_a?(Array)
+        name, item = record
+        parent_klass_name = calculate_name(item.class)
+        parent_klass_name = nil if parent_klass_name.to_s == name.to_s
+        [name, item, parent_klass_name]
+      else
+        raise NotImplemented
+      end
+    end
+  end
+end
+
+

data/lib/to_factory/file_sync.rb

@@ -0,0 +1,48 @@
+module ToFactory
+  class FileSync
+    def initialize(m  = ToFactory::Finders::Model.new,
+                   fw = ToFactory::FileWriter.new,
+                   ff = ToFactory::Finders::Factory.new)
+      @model_finder = wrap_model(m)
+      @file_writer  = fw
+      @factory_finder = ff
+    end
+
+    def perform(exclusions=[])
+      definitions = Collation.merge(new_definitions(exclusions), pre_existing)
+
+      @file_writer.write(definitions)
+    end
+
+    def new_definitions(exclusions=[])
+      return {} if exclusions == [:all]
+
+      instances = @model_finder.call(exclusions)
+
+      DefinitionGroup.perform(instances)
+    end
+
+    private
+
+    def pre_existing
+      @factory_finder.call
+    end
+
+    def wrap_model(m)
+      if m.respond_to?(:call)
+        m
+      else
+        lambda{|exclusions|
+          exclusions ||= []
+          records = if m.is_a?(ActiveRecord::Base)
+            Array m
+          else
+            m
+          end
+
+          records.reject{|o,_| exclusions.include?(o.class)}
+        }
+      end
+    end
+  end
+end

data/lib/to_factory/file_writer.rb

@@ -0,0 +1,39 @@
+module ToFactory
+  class FileWriter
+    def initialize
+      FileUtils.mkdir_p(ToFactory.factories)
+    end
+
+    def write(definitions)
+      definitions.each do |klass, factories|
+        name = klass.name.underscore.gsub /^"|"$/, ""
+        mkdir(name) if name.to_s["/"]
+
+        File.open(File.join(ToFactory.factories, "#{name}.rb"), "w") do |f|
+          f << wrap_factories(factories.values)
+        end
+      end
+    end
+
+    private
+
+    def wrap_factories(factories)
+      if ToFactory.new_syntax?
+        modern_header(factories)
+      else
+        factories.join("\n\n")
+      end
+    end
+
+    def modern_header(factories)
+      out = "FactoryGirl.define do\n"
+      out << factories.join("\n")
+      out << "\nend\n"
+    end
+
+    def mkdir(name)
+      dir = name.to_s.split("/")[0..-2]
+      FileUtils.mkdir_p File.join(ToFactory.factories, dir)
+    end
+  end
+end

data/lib/to_factory/finders/factory.rb

@@ -0,0 +1,17 @@
+module ToFactory
+  module Finders
+    class Factory
+      def call
+        all_factories = {}
+
+        Dir.glob(File.join(ToFactory.factories, "**/*.rb")).each do |f|
+          factories = ToFactory::Parsing::File.parse(f)
+
+          all_factories = Collation.merge(all_factories, factories)
+        end
+
+        all_factories
+      end
+    end
+  end
+end

data/lib/to_factory/finders/model.rb

@@ -0,0 +1,47 @@
+module ToFactory
+  module Finders
+    class Model
+      def call(exclusions=[])
+        instances = []
+
+        Dir.glob("#{ToFactory.models}/**/*.rb").each do |file|
+          File.readlines(file).each do |f|
+            if match = f.match(/class (.*) ?</)
+              klass = rescuing_require file, match
+              break if exclusions.include?(klass)
+              instance = get_active_record_instance(klass)
+              instances << instance if instance
+              break
+            end
+          end
+        end
+
+        instances
+      end
+
+      private
+
+      def rescuing_require(file, match)
+        require file
+        klass = eval(match[1])
+        klass
+
+      rescue Exception => e
+        warn "Failed to eval #{file}"
+        warn e.message
+      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}"
+      end
+    end
+  end
+end

data/lib/to_factory/generation/attribute.rb

@@ -0,0 +1,52 @@
+module ToFactory
+  module Generation
+    class Attribute
+      def initialize(attribute, value)
+        @attribute = attribute
+        @value = value
+      end
+
+      def to_s
+        attribute = "#{@attribute} #{inspect_value(@value)}"
+
+        if ToFactory.new_syntax?
+          "    #{attribute}"
+        else
+          "  o.#{attribute}"
+        end
+      end
+
+      def <=>(other)
+        @attribute <=> other
+      end
+
+      def ==(other)
+        to_s == other.to_s
+      end
+
+      private
+
+      def inspect_value(value)
+        case value
+        when Time, DateTime
+          time = in_utc(value).strftime("%Y-%m-%dT%H:%M%Z").inspect
+          time.gsub(/UTC"$/, "Z\"").gsub(/GMT"$/, "Z\"")
+        when BigDecimal
+          value.to_f.inspect
+        when Hash
+          hash = value.inject({}){|result, (k, v)| result[k] = inspect_value(v); result}
+        when Array
+          value.map{|v| inspect_value(v)}
+        else
+          value.inspect
+        end
+      end
+
+      def in_utc(time)
+        time.utc
+      end
+    end
+  end
+end
+
+

data/lib/to_factory/generation/factory.rb

@@ -0,0 +1,74 @@
+module ToFactory
+  module Generation
+
+    class Factory
+      def initialize(object, name)
+        unless object.is_a? ActiveRecord::Base
+          message = "Generation::Factory requires initializing with an ActiveRecord::Base instance"
+          message << "\n  but received #{object.inspect}"
+          raise ToFactory::MissingActiveRecordInstanceException.new(message)
+        end
+
+        @name = add_quotes name
+        @attributes = object.attributes
+      end
+
+      def to_factory(parent_name=nil)
+        header(parent_name) do
+          to_skip = [:id, :created_at, :updated_at]
+          attributes = @attributes.delete_if{|key, _| to_skip.include? key.to_sym}
+
+          attributes.map do |attr, value|
+            factory_attribute(attr, value)
+          end.sort.join("\n") << "\n"
+        end
+      end
+
+      def header(parent_name=nil, &block)
+        if ToFactory.new_syntax?
+          modern_header parent_name, &block
+        else
+          header_factory_girl_1 parent_name, &block
+        end
+      end
+
+      def modern_header(parent_name=nil, &block)
+        generic_header(parent_name, "factory", "", &block)
+      end
+
+      def header_factory_girl_1(parent_name=nil, &block)
+        generic_header(parent_name, "Factory.define", "|o|", &block)
+      end
+
+      def factory_attribute(attr, value)
+        Attribute.new(attr, value).to_s
+      end
+
+      private
+
+      def generic_header(parent_name, factory_start, block_arg, &block)
+        out =  "  #{factory_start}(:#{@name}#{parent_clause(parent_name)}) do#{block_arg}\n"
+        out << yield.to_s
+        out << "  end\n"
+      end
+
+      def parent_clause(name)
+        name ?  ", :parent => :#{add_quotes name}" : ""
+      end
+
+      def add_quotes(name)
+        name = name.to_s
+
+        if name["/"]
+          if name[/^".*"$/]
+            name
+          else
+            "\"#{name}\""
+          end
+        else
+          name
+        end
+      end
+    end
+  end
+end

data/lib/to_factory/parsing/file.rb

@@ -0,0 +1,38 @@
+require 'ruby2ruby'
+require 'ruby_parser'
+require 'to_factory/parsing/syntax'
+require 'to_factory/parsing/new_syntax'
+require 'to_factory/parsing/old_syntax'
+
+module ToFactory
+  module Parsing
+    class File
+      delegate :multiple_factories?, :header?, :parse, :to => :parser
+
+      def self.parse(filename)
+        from_file(filename).parse
+      end
+
+      def self.from_file(filename)
+        contents = ::File.read filename rescue nil
+        raise ArgumentError.new "Invalid file #{filename}"  if contents.to_s.length == 0
+
+        new(contents)
+      end
+
+      def initialize(contents)
+        @contents = contents
+      end
+
+      def parser
+        @parser ||= parser_klass.new(@contents)
+      end
+
+      private
+
+      def parser_klass
+        ToFactory.new_syntax? ? NewSyntax : OldSyntax
+      end
+    end
+  end
+end

data/lib/to_factory/parsing/new_syntax.rb

@@ -0,0 +1,9 @@
+module ToFactory
+  module Parsing
+    class NewSyntax < Syntax
+      def header?
+        sexp[1][1][1] == :FactoryGirl rescue false
+      end
+    end
+  end
+end

data/lib/to_factory/parsing/old_syntax.rb

@@ -0,0 +1,9 @@
+module ToFactory
+  module Parsing
+    class OldSyntax < Syntax
+      def header?
+        false
+      end
+    end
+  end
+end