lazy_fixtures 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ee9e13f450b9456b2a3b44be2581ef9ee8052513
+  data.tar.gz: 74a2bd5481e952ed8f0ccdb4cb294ccf046ab427
+SHA512:
+  metadata.gz: 21ac1dbc12c3fa363ae4161a56d13fc98a018bfaeb85c45a47f65ea6172def1226e071dd1b177b28e3fc621f38f30fa4f545ad79aafaf65bf7d0dd96f86ba893
+  data.tar.gz: c3d01fabd019fdaa37d4c796992f48e6f14267896b6e9042394b8330aab61a476a41597e2415fb697d8e4920ddc2a697fc5a6b9de9aa160f6d2fbf3f622a7168

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+.idea
+*.DS_Store
+mkmf.log

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.0
+script: "bundle exec rspec spec"

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 GustavoCaso
+
+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,84 @@
+# LazyFixtures
+[![Build Status](https://travis-ci.org/GustavoCaso/lazy_fixtures.svg?branch=master)](https://travis-ci.org/GustavoCaso/lazy_fixtures)
+
+Generator to create factory girl fixtures, just with a simple ActiveRecord object
+from your current database.
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'lazy_fixtures'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install lazy_fixtures
+
+## Usage
+
+Inside your console simple type `LazyFixtures.generate()` inside the parenthesis place an ActiveRecord object, and this command will generate the corresponding file inside your project.
+
+## Initialisation
+
+If you are using this gem inside a rails project you can use the initialise folder you can add a file to configure some attributes that will help the gem work properly.
+
+```ruby
+require 'factory_girl'
+
+FactoryGirl.factories.clear
+FactoryGirl.find_definitions
+
+LazyFixtures.configure do |config|
+  config.factory_directory = "#{specify which folder are your fixtures save}"
+  config.factory_names = FactoryGirl.factories.map(&:name)
+end
+```
+
+This lines will tell the gem where to store the files and it will give them a list with your actual Factory Girl fixtures, with this it will avoid factory girl exceptions.
+
+## Options
+
+There are several options you can pass to the generator, the method will receive these options as a hash so the order is not redundant.
+
+1. **nested** => by default is set to false, set this to true and will traverse all the associations from your object and will create does fixtures for you as well.
+2. **overwrite** => by default is set to false, set this to true and will overwrite does file with same name inside the fixtures folder that you specify. If for some reason it find a file with the same name and the option is set to false it will ask you if you want to overwrite. That choice is up to you :-)
+3. **create** => by default  is set to true, this options tell the generator to create the file, if is set to false it will not generate any file.
+4. **skip_attr** => this accept an array of string which will remove those attributes from the object.
+5. **change_attr** => this accepts a hash with new values for the fixture you want to set.
+
+## Examples
+
+###This will create a switch fixture:
+
+`LazyFixtures.generate(Switch.last)`
+
+###This will create a switch fixture and traverse all the associations:
+
+`LazyFixtures.generate(Switch.last, nested: true)`
+
+###This will create a switch fixture with skipped attributes:
+
+`LazyFixtures.generate(Switch.last, skip_attr:['age', 'name'])`
+
+###This will create a switch fixture with custom values:
+
+`LazyFixtures.generate(Switch.last, change_attr:{'age' => 34, 'name' => 'John'})`
+
+##Notes
+This version is the first version, I want to add more functionality to it, skipping and changing nested attributes from the object, and many more.
+If you use the gem I see any errors or some functionality that might be useful please let me know.
+Thanks.
+
+
+## Contributing
+
+1. Fork it ( https://github.com/GustavoCaso/lazy_fixtures/fork )
+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 a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lazy_fixtures.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'lazy_fixtures/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "lazy_fixtures"
+  spec.version       = LazyFixtures::VERSION
+  spec.authors       = ["GustavoCaso"]
+  spec.email         = ["gustavocaso@gmail.com"]
+  spec.summary       = %q{Easy generator to save time when creating them}
+  spec.description   = %q{With this gem you will save time creating factory model,
+                          with different options you will be able to create a full compatible
+                          factory tree from your database
+                          }
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "activerecord"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "rspec"
+end

data/lib/lazy_fixtures/association_manager.rb

@@ -0,0 +1,45 @@
+module LazyFixtures
+  class AssociationManager
+    def initialize(item)
+      @item = item
+      @klass = @item.class.name.constantize
+    end
+
+    def columns_info
+      return_hash = {}
+      @klass.reflections.keys.map do |x|
+        reflection = @klass.reflections[x]
+        return_hash[x.to_s]= {
+            method: x,
+            macro: reflection.macro,
+            klass: reflection.class_name
+        }
+      end
+      return_hash
+    end
+
+    def determine_association(association_info, class_name, method)
+      relation = association_info[:macro]
+      text = if relation == :belongs_to
+               create_belongs_to_association(association_info[:klass], class_name, method)
+             elsif relation == :has_many || relation == :has_and_belongs_to_many
+               create_has_many_associations(association_info[:klass])
+             end
+      <<-EOF
+    #{text}
+      EOF
+    end
+
+    def create_belongs_to_association(klass, class_name, method)
+      method = method == klass.downcase ? klass.downcase : method
+      class_name = klass == class_name ? klass : class_name
+      "association :#{method}, factory: :#{class_name.downcase}"
+    end
+
+    def create_has_many_associations(klass)
+      %Q(after(:create) do |x|
+      create_list(:#{klass.downcase}, 1, #{@item.class.name.downcase}: x)
+    end)
+    end
+  end
+end

data/lib/lazy_fixtures/attributes_manager.rb

@@ -0,0 +1,36 @@
+module LazyFixtures
+  class AttributesManager
+
+    attr_reader :attributes
+
+    def initialize(object, options={})
+      @object = object
+      @attributes = @object.attributes
+      @options    = options
+    end
+
+    def add_attributes
+      return_value = ''
+      attributes.each do |k,v|
+        value =  ValueMapper.new(@object, k.to_s.dup, v).map_values
+        key = ValueMapper.remove_encrypted(k.to_s.dup)
+        return_value += "    #{key} #{value}\n"
+      end
+      return_value
+    end
+
+    def manipulate_attributes
+      @options[:skip_attr].each { |x|  attributes.delete(x)} unless @options[:skip_attr].empty?
+      attributes.merge!(@options[:change_attr]) unless @options[:change_attr].empty?
+      attributes
+    end
+
+    def delete_association_attributes(method)
+      attributes.delete_if {|k,v| k =~ Regexp.new(method) && !v.nil?}
+    end
+
+    def each
+      attributes
+    end
+  end
+end

data/lib/lazy_fixtures/file_manager.rb

@@ -0,0 +1,40 @@
+module LazyFixtures
+    class FileManager
+      def initialize(name, options)
+        @name = name
+        @options = options
+        @title = "#{@name}.rb"
+        @file_path = File.join(LazyFixtures.configuration.factory_directory, @title)
+      end
+
+    def create_file
+      return unless @options[:create]
+      if check_existence? && !@options[:overwrite]
+        puts "There is a file already inside that folder with the same name #{@name}"
+        puts "Would you like to overwrite that file? (yes/no)"
+        answer = gets.chomp
+        if answer ==  'yes'
+          puts 'The generator is overwriting your file'
+          File.new(@file_path, "w")
+          true
+        else
+          puts 'Exiting the program'
+          false
+        end
+      end
+      puts "creating new file under #{LazyFixtures.configuration.factory_directory}/#{@name}"
+      File.new(@file_path, "w")
+      true
+    end
+
+    def check_existence?
+      File.file?(@file_path)
+    end
+
+    def write_file(text)
+      File.open(@file_path, 'w') do |f|
+        f.write text
+      end
+    end
+  end
+end

data/lib/lazy_fixtures/generator.rb

@@ -0,0 +1,95 @@
+module LazyFixtures
+  class Generator
+
+    attr_reader :factory_body, :attributes, :options
+
+    DEFAULT_OPTIONS = {
+        nested:      false,
+        overwrite:   false,
+        create:      true,
+        parent:      [],
+        skip_attr:   [],
+        change_attr: {}
+    }
+
+    def initialize(object, options = {})
+      @options = DEFAULT_OPTIONS.merge(options)
+      @object = get_object(object)
+      @class_name = @object.class.name
+      @attributes = @object.attributes
+      @factory_body = ''
+    end
+
+    def generate
+      # In this first implementation of the gem it only allow to manipulate the
+      # first object
+      attribute_manager.manipulate_attributes
+      add_associations if @options[:nested]
+      @factory_body += attribute_manager.add_attributes
+      text = generate_factory
+      if create_file
+        @file.write_file(text)
+      end
+      self
+    end
+
+    def generate_factory
+      factory_name = get_factory_name
+      <<-EOF
+FactoryGirl.define do
+  factory :#{factory_name}, class: #{@class_name.constantize} do
+#{@factory_body}
+  end
+end
+      EOF
+    end
+
+    def add_associations
+      association.columns_info.keys.each do |method|
+        begin
+          object =  @object.send(method)
+          object = get_object(object)
+          object_class = object.class.name
+          next if invalid_object?(object)
+          parent_included = @options[:parent].include? object_class
+          (@options[:parent] << object_class).uniq!
+          self.class.new(object, nested: true, parent: @options[:parent]).generate unless parent_included
+          @factory_body += association.determine_association(association.columns_info[method], object_class, method)
+          attribute_manager.delete_association_attributes(method)
+        rescue => e
+          puts "There was an error creating the association #{e} => #{e.backtrace}"
+          next
+        end
+      end
+    end
+
+    def get_object(object)
+      object.respond_to?('first') ? object.first : object
+    end
+
+    def invalid_object?(object)
+      object.nil? || (object.respond_to?('first') && object.empty?)
+    end
+
+    def create_file
+      @file ||= FileManager.new(@object.class.name.downcase, @options)
+      @file.create_file
+    end
+
+    def association
+      AssociationManager.new(@object)
+    end
+
+    def attribute_manager
+      @attribute_manager ||= AttributesManager.new(@object, @options)
+    end
+
+    def get_factory_name
+      if LazyFixtures.configuration.factory_names.include?(@class_name.downcase)
+        "#{@class_name.downcase}_new"
+      else
+        @class_name.downcase
+      end
+    end
+  end
+end

data/lib/lazy_fixtures/value_mapper.rb

@@ -0,0 +1,38 @@
+module LazyFixtures
+  class ValueMapper
+    def initialize(object, key, value)
+      @object = object
+      @object_class = @object.class.name.constantize
+      @key = key
+      @value = value
+      remove_encrypted_attributes
+    end
+
+    def remove_encrypted_attributes
+       if @key =~ /(encrypted_)/
+         key = @key.dup
+         key.slice!($1)
+         @value = @object.send(key)
+       end
+    end
+
+    def map_values
+      type = @object_class.columns_hash[@key].type
+      value =  if @value.nil?
+                 "nil"
+               elsif type == :string || type == :datetime || type == :text || type == :date
+                 "\'#{@value}\'"
+               else
+                 @value
+               end
+    end
+
+    def self.remove_encrypted(key)
+      return_key = key
+      if key =~ /(encrypted_)/
+        return_key.slice!($1)
+      end
+      return_key
+    end
+  end
+end

data/lib/lazy_fixtures/version.rb

@@ -0,0 +1,3 @@
+module LazyFixtures
+  VERSION = "0.0.1"
+end

data/lib/lazy_fixtures.rb

@@ -0,0 +1,30 @@
+require 'lazy_fixtures/version'
+require 'lazy_fixtures/generator'
+require 'lazy_fixtures/association_manager'
+require 'lazy_fixtures/file_manager'
+require 'lazy_fixtures/value_mapper'
+require 'lazy_fixtures/attributes_manager'
+
+module LazyFixtures
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration)
+  end
+
+  class Configuration
+    attr_accessor :factory_directory, :factory_names
+
+    def initialize
+      @factory_directory = ''
+      @factory_names = []
+    end
+  end
+
+  def self.generate(object, options = {})
+    LazyFixtures::Generator.new(object, options).generate
+  end
+end

data/spec/association_manager_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe LazyFixtures::AssociationManager do
+
+  before(:each) do
+    @user = User.create(name:'Evaristo', age: 67)
+    @post = Post.create(title:'Post title', post_body: 'This is not important', user_id: 3)
+  end
+
+  describe '#columns_info' do
+    it 'will return hash with reflections information' do
+      return_value = LazyFixtures::AssociationManager.new(@user).columns_info
+      expect(return_value).to eq({'posts' => {method: :posts, macro: :has_many, klass: 'Post'}})
+    end
+
+    it 'will return hash with reflections information' do
+      return_value = LazyFixtures::AssociationManager.new(@post).columns_info
+      expect(return_value).to eq('user' => {method: :user, macro: :belongs_to, klass: 'User'})
+    end
+  end
+
+  describe '#determine_association' do
+    it 'will return text for belongs to association' do
+      user_association_info = LazyFixtures::AssociationManager.new(@post).columns_info['user']
+      return_value = LazyFixtures::AssociationManager.new(@post).determine_association(user_association_info, 'User', 'user')
+      expect(return_value).to eq "    association :user, factory: :user\n"
+    end
+
+    it 'will return text for belongs to association with right association' do
+      user_association_info = LazyFixtures::AssociationManager.new(@post).columns_info['user']
+      return_value = LazyFixtures::AssociationManager.new(@post).determine_association(user_association_info, 'User', 'writter')
+      expect(return_value).to eq "    association :writter, factory: :user\n"
+    end
+
+    it 'will return text for belongs to association with right factory' do
+      user_association_info = LazyFixtures::AssociationManager.new(@post).columns_info['user']
+      return_value = LazyFixtures::AssociationManager.new(@post).determine_association(user_association_info, 'Writter', 'user')
+      expect(return_value).to eq "    association :user, factory: :writter\n"
+    end
+
+
+    it 'will return text for has_many to association' do
+      post_association_info = LazyFixtures::AssociationManager.new(@user).columns_info['posts']
+      return_value = LazyFixtures::AssociationManager.new(@user).determine_association(post_association_info, 'Post', 'post')
+      expect(return_value).to eq "    after(:create) do |x|\n      create_list(:post, 1, user: x)\n    end\n"
+    end
+  end
+end

data/spec/attributes_manager_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe LazyFixtures::AttributesManager do
+
+  it 'will return has with attributes' do
+    user = User.create(name: 'Caita', age: 57)
+    attributes_manager = LazyFixtures::AttributesManager.new(user,
+                         LazyFixtures::Generator::DEFAULT_OPTIONS)
+    expect_return = {'id' => user.id, 'name' => user.name,
+                     'age' => user.age, 'created_at' => user.created_at,
+                     'updated_at' => user.updated_at}
+    expect(attributes_manager.each).to eq expect_return
+  end
+
+  it 'will return string with all the value from the object' do
+    user = User.create(name: 'Caita', age: 57)
+    attributes_manager = LazyFixtures::AttributesManager.new(user,
+                          LazyFixtures::Generator::DEFAULT_OPTIONS)
+    expected_attributes = "    id #{user.id}\n    name 'Caita'\n    age 57\n    created_at '1986-09-29T00:00:00+00:00'\n    updated_at '1986-09-29T00:00:00+00:00'\n"
+    expect(attributes_manager.add_attributes).to eq expected_attributes
+  end
+
+  it 'will return string with all value from the object removing the encrypted part' do
+    user = UserWithEncrypted.create(name: 'Eduardo', age: 60,
+                                    encrypted_password: 'retvbhj')
+    attributes_manager = LazyFixtures::AttributesManager.new(user,
+                          LazyFixtures::Generator::DEFAULT_OPTIONS)
+
+    expected_attributes = "    id #{user.id}\n    name 'Eduardo'\n    age 60\n    password 'retvbhj'\n"
+    expect(attributes_manager.add_attributes).to eq expected_attributes
+  end
+
+  it 'will skip attributes from the options hash' do
+    user = User.create(name: 'Caita', age: 57)
+    options = LazyFixtures::Generator::DEFAULT_OPTIONS.merge({skip_attr: ['age']})
+    attributes_manager = LazyFixtures::AttributesManager.new(user, options)
+    expected_attributes = {'id' => user.id, 'name' => user.name,
+                           'created_at' => user.created_at,
+                           'updated_at' => user.updated_at}
+    expect(attributes_manager.manipulate_attributes).to eq expected_attributes
+  end
+
+  it 'will modify attributes value from the options hash' do
+    user = User.create(name: 'Caita', age: 57)
+    options = LazyFixtures::Generator::DEFAULT_OPTIONS.merge({change_attr: {'age' => 109}})
+    attributes_manager = LazyFixtures::AttributesManager.new(user, options)
+    expected_attributes = {'id' => user.id, 'name' => user.name,
+                           'age' => 109, 'created_at' => user.created_at,
+                           'updated_at' => user.updated_at}
+    expect(attributes_manager.manipulate_attributes).to eq expected_attributes
+  end
+
+  it 'will remove attributes from association which are not nill' do
+    user = User.create(name: 'Caita', age: 57)
+    post = Post.create(title:'Post title', post_body: 'This is not important', user_id: user.id)
+    options = LazyFixtures::Generator::DEFAULT_OPTIONS
+    attributes_manager = LazyFixtures::AttributesManager.new(post, options)
+    expected_attributes = {'id' => post.id, 'title' => post.title,
+                           'post_body' => post.post_body}
+    expect(attributes_manager.delete_association_attributes('user')).to eq expected_attributes
+  end
+end

data/spec/generator_spec.rb

@@ -0,0 +1,111 @@
+require 'spec_helper'
+
+describe LazyFixtures::Generator do
+
+  describe 'attr_reader' do
+    before(:each) do
+      @user = User.create(name: 'Gustavo', age: 26)
+      @factory = LazyFixtures::Generator.new(@user, create: false).generate
+    end
+
+    it '#attributes' do
+      attributes = {
+        "id"         => @user.id,
+        "name"       => 'Gustavo',
+        "age"        => 26,
+        "created_at" => DateTime.new(1986,9,29),
+        "updated_at" => DateTime.new(1986,9,29)
+      }
+
+      expect(@factory.attributes).to eq attributes
+    end
+
+    it '#factory_body' do
+      text = <<-EOF
+    id #{@user.id}
+    name 'Gustavo'
+    age 26
+    created_at '1986-09-29T00:00:00+00:00'
+    updated_at '1986-09-29T00:00:00+00:00'
+      EOF
+
+      factory_body = @factory.factory_body
+      expect(factory_body).to eq text
+    end
+
+    it '#options' do
+      options = {
+        nested: false,
+        overwrite: false,
+        create: false,
+        parent: [],
+        skip_attr: [],
+        change_attr: {}
+      }
+      expect(@factory.options).to eq options
+
+    end
+  end
+
+  describe 'generator methods' do
+    before(:each) do
+      @user = User.create(name: 'Gustavo', age: 26)
+    end
+
+    describe 'getter object and determine validity of object methods' do
+
+      before(:each) do
+        @factory = LazyFixtures::Generator.new(@user, create: false)
+      end
+
+      it '#invalid_object? will return true with nil value' do
+        return_value = @factory.invalid_object?(nil)
+        expect(return_value).to eq true
+      end
+
+      it '#invalid_object? will return true with empty value' do
+        return_value = @factory.invalid_object?([])
+        expect(return_value).to eq true
+      end
+
+      it '#invalid_object? will return false with valid value' do
+        return_value = @factory.invalid_object?(@user)
+        expect(return_value).to eq false
+      end
+
+      it '#get_object will return the object' do
+        return_value = @factory.get_object(@user)
+        expect(return_value).to eq @user
+      end
+
+      it '#get_object will return the object' do
+        return_value = @factory.get_object(nil)
+        expect(return_value).to eq nil
+      end
+
+      it '#get_object will return the object' do
+        return_value = @factory.get_object([])
+        expect(return_value).to eq nil
+      end
+
+      it '#get_object will return the object' do
+        user2 = User.new(name: 'Test', age: 30)
+        return_value = @factory.get_object([user2, @user])
+        expect(return_value).to eq user2
+      end
+
+      it '#get_factory_name will return the name with appended string' do
+        LazyFixtures.configuration.factory_names = ['user']
+        return_value = @factory.get_factory_name
+        expect(return_value).to eq 'user_new'
+      end
+
+      it '#get_factory_name will return the name' do
+        LazyFixtures.configuration.factory_names = ['switch']
+        return_value = @factory.get_factory_name
+        expect(return_value).to eq 'user'
+      end
+
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require 'active_record'
+require 'lazy_fixtures'
+
+ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ':memory:'
+load File.dirname(__FILE__) + '/support/schema.rb'
+require File.dirname(__FILE__) +'/support/models'
+
+LazyFixtures.configure do |config|
+  config.factory_directory = '.'
+  config.factory_names = []
+end
+
+RSpec.configure do |config|
+  config.before(:each) do
+    User.destroy_all
+  end
+
+  config.after(:each) do
+    User.destroy_all
+  end
+end

data/spec/support/models.rb

@@ -0,0 +1,21 @@
+class User < ActiveRecord::Base
+  has_many :posts
+  before_save :create_timestamps
+
+  def create_timestamps
+    self.created_at = DateTime.new(1986,9,29)
+    self.updated_at = DateTime.new(1986,9,29)
+  end
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :user
+end
+
+class UserWithEncrypted < ActiveRecord::Base
+
+  def password
+    encrypted_password
+  end
+
+end

data/spec/support/schema.rb

@@ -0,0 +1,21 @@
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :users, force: true do |t|
+    t.string :name
+    t.integer :age
+    t.timestamps
+  end
+
+  create_table :posts, force: true do |t|
+    t.string :title
+    t.string :post_body
+    t.integer :user_id
+  end
+
+  create_table :user_with_encrypteds, force: true do |t|
+    t.string :name
+    t.integer :age
+    t.string :encrypted_password
+  end
+end

data/spec/value_mapper_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe LazyFixtures::ValueMapper do
+  describe '#map_values' do
+    before(:each) do
+      @user = User.create(name: 'Gustavo', age: 26)
+      allow(@user).to receive(:columns_hash).and_return({})
+    end
+
+    it 'return correct value format for integer' do
+      allow({}).to receive(:type).and_return(:integer)
+      value = LazyFixtures::ValueMapper.new(@user, 'id', 6).map_values
+      expect(value).to eq 6
+    end
+
+    it 'return correct format for datetime' do
+      allow({}).to receive(:type).and_return(:datetime)
+      value = LazyFixtures::ValueMapper.new(@user, 'created_at', '1986-09-29T00:00:00+00:00').map_values
+      expect(value).to eq "'1986-09-29T00:00:00+00:00'"
+    end
+
+    it 'return correct format for string' do
+      allow({}).to receive(:type).and_return(:string)
+      value = LazyFixtures::ValueMapper.new(@user, 'name', 'Gustavo').map_values
+      expect(value).to eq "'Gustavo'"
+    end
+
+    it 'return correct format for float' do
+      allow({}).to receive(:type).and_return(:float)
+      value = LazyFixtures::ValueMapper.new(@user, 'id', 1.5).map_values
+      expect(value).to eq 1.5
+    end
+
+    it 'return correct format for nil' do
+      allow({}).to receive(:type).and_return(:string)
+      value = LazyFixtures::ValueMapper.new(@user, 'name', nil).map_values
+      expect(value).to eq "nil"
+    end
+  end
+
+  describe '#remove_encrypted_attributes' do
+    it 'return non encrypted values' do
+      dummy = Struct.new('User', :encrypted_name, :age, :name)
+      test_user = dummy.new('dueucvwuevcbwbcw', 23, 'gustavo')
+      value = LazyFixtures::ValueMapper.new(test_user, 'encrypted_name', 'dueucvwuevcbwbcw').remove_encrypted_attributes
+      expect(value).to eq 'gustavo'
+    end
+  end
+
+  describe 'self#remove_encrypted' do
+    it 'return key without encrypted in it' do
+      key = 'encrypted_password'
+      return_value = LazyFixtures::ValueMapper.remove_encrypted(key)
+      expect(return_value).to eq 'password'
+    end
+  end
+
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: lazy_fixtures
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- GustavoCaso
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "With this gem you will save time creating factory model,\n                          with
+  different options you will be able to create a full compatible\n                          factory
+  tree from your database\n                          "
+email:
+- gustavocaso@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lazy_fixtures.gemspec
+- lib/lazy_fixtures.rb
+- lib/lazy_fixtures/association_manager.rb
+- lib/lazy_fixtures/attributes_manager.rb
+- lib/lazy_fixtures/file_manager.rb
+- lib/lazy_fixtures/generator.rb
+- lib/lazy_fixtures/value_mapper.rb
+- lib/lazy_fixtures/version.rb
+- spec/association_manager_spec.rb
+- spec/attributes_manager_spec.rb
+- spec/generator_spec.rb
+- spec/spec_helper.rb
+- spec/support/models.rb
+- spec/support/schema.rb
+- spec/value_mapper_spec.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Easy generator to save time when creating them
+test_files:
+- spec/association_manager_spec.rb
+- spec/attributes_manager_spec.rb
+- spec/generator_spec.rb
+- spec/spec_helper.rb
+- spec/support/models.rb
+- spec/support/schema.rb
+- spec/value_mapper_spec.rb