traver 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ed508040aa612bbd6bd5755a5078ef5e2254abb0
-  data.tar.gz: 0aba48d5e505bc9bf9541ad84d3d993400392ecc
+  metadata.gz: 009d9a2721da257a5d9bb38e0196d84668b6dc35
+  data.tar.gz: 4a8aef2efb71d6f859b61e9fd21e52a8f8da2873
 SHA512:
-  metadata.gz: 1f99785aef8bf9e7ff8a4dd4f31c4a0d423465e4f023065037964f6f3b81dbb59a9946415569514cfb4c472cfb336905027419acc89f1cac5330cfb355ec46a4
-  data.tar.gz: 276b82bd4f7b1f3954dfbc7c14076c17784aadc08f3539c865b9ce55df5b7adb63a46792019e4a2331f79f3164af52681c282c1dabee541cf75acc58e98d80b5
+  metadata.gz: 7b866419d6f2dddb32299145968d1f6374d5b5966edad94ba61665c6fbd846ecb05d531ca0c6ebb6ab29a8dede324f1f10205e92961d6e56ef03adca765adc0f
+  data.tar.gz: 5736f5f8b098dcff077586255cfb9b211b2f97017df3521c9783a9359ab4e4b4e6c39a2026adca5e7df409c3727bf96fc8ebe888012d4ac4a031573fe2053a69

data/README.md

@@ -18,7 +18,7 @@ and run `bundle install` from your shell.
 
 ## Usage
 
-Create an object with attributes:
+Create object with attributes:
 
 ```ruby
 blog = Traver.create(blog: { title: "Blog" }) #=> #<Blog @title="Blog">
@@ -27,15 +27,26 @@ blog = Traver.create(blog: { title: "Blog" }) #=> #<Blog @title="Blog">
 Define and use factories:
 
 ```ruby
-Traver.factory(:post, {
+Traver.define_factory(:user, {
+  full_name: "Walter White"
+})
+
+Traver.define_factory(:post, {
   title: "Hello"
 })
 
-Traver.factory(:published_post, :post, {
+Traver.create(:user) #=> #<User @full_name="Walter White">
+Traver.create(:post) #=> #<Post @title="Hello">
+```
+
+Define child factories:
+
+```ruby
+Traver.define_factory(:published_post, :post, {
   published: true
 })
 
-Traver.factory(:draft_post, :post, {
+Traver.define_factory(:draft_post, :post, {
   published: false
 })
 
@@ -43,7 +54,7 @@ Traver.create(:published_post) #=> #<Post @title="Hello", @published=true>
 Traver.create(:draft_post)     #=> #<Post @title="Hello", @published=false>
 ```
 
-Create associated object:
+Create associated objects:
 
 ```ruby
 blog = Traver.create(blog: {
@@ -54,56 +65,57 @@ blog = Traver.create(blog: {
 blog.user #=> #<User @name="Mike">
 ```
 
-Create object collections:
+Create associated objects using factory names:
 
 ```ruby
+Traver.define_factory(:mike, :user, {
+  name: "Mike"
+})
+
 blog = Traver.create(blog: {
   title: "Hello",
-  posts: [
-    { title: "Post #1" },
-    { title: "Post #2" }
-  ]
+  user: :mike
 })
 
-blog.posts #=> [#<Post @title="Post #1">, #<Post @title="Post #2">]
+```
 
-# More concise syntax
+Create associated collections:
+
+```ruby
 blog = Traver.create(blog: {
   title: "Hello",
-  posts: [2, title: "Post #${n}"]
+  posts: [
+    { title: "Post #1" },
+    { title: "Post #2" }
+  ]
 })
 
 blog.posts #=> [#<Post @title="Post #1">, #<Post @title="Post #2">]
 
-# Having defined factory
-Traver.factory(post: { title: "Post #${n}"})
-
-# Even more concise
-blog = Traver.create(blog: { title: "Hello", posts: 2 })
+```
 
-blog.posts #=> [#<Post @title="Post #1">, #<Post @title="Post #2">]
+Create associated collections using numbers:
 
+```ruby
+Traver.create(blog: { title: "Hello", posts: 2 })
+Traver.create(blog: { title: "Hello", posts: [2, title: "Post #${n}"] })
+Traver.create(blog: { title: "Hello", posts: [2, :published_post] })
 ```
 
-Any level of nesting:
+Create associated collections using factory names:
 
 ```ruby
-blog = Traver.create(blog: {
-  title: "Blog",
-  posts: [{
-    title: "Hello",
-    tags: [{ name: "Happy" }]
-  }]
-})
-
-blog.posts.first.tag.first #=> #<Tag @name="Happy">
+Traver.create(blog: { title: "Hello", posts: [:published_post, :draft_post] })
 ```
 
-Create lists:
+Create lists with sequences:
 
 ```ruby
-users = Traver.create_list(:user, 2, email: "user${n}@mail.me")
+users = Traver.create_list(2, user: { email: "user${n}@mail.me" })
 #=> [#<User @email="user1@mail.me">, #<User @email="user2@mail.me">]
+
+users = Traver.create_list(2, :published_post)
+#=> [#<Post @published=true>, #<User @published=true>]
 ```
 
 Graph is a convenient way to reference created objects:
@@ -121,6 +133,34 @@ graph.tag2  #=> #<Tag>
 blog, post = Traver.create_graph(blog: { posts: 1 })[:blog, :post]
 ```
 
+Reference already created objects:
+
+```ruby
+blog = Traver.create(blog: {
+  post: { tags: 1 }
+  tags: [-> (graph) { graph.tag1 }]
+})
+```
+
+## Rails
+
+By default Traver loads factories from`test/factories.rb` or `spec/factories.rb` for rspec users.
+
+Objects for `belongs_to` associations are created automatically:
+
+```ruby
+class Blog < ActiveRecord::Base
+  has_many :blogs
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :blog
+end
+
+post = Traver.create(:post) #=> #<Post>
+post.blog #=> #<Blog>
+```
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/lib/traver/attributes_resolver.rb

@@ -0,0 +1,27 @@
+module Traver
+  class AttributesResolver
+    def select_attributes_params(params, object_class)
+      params.select { |name, value| regular_attribute?(object_class, name, value) }
+    end
+    
+    def select_objects_params(params, object_class)
+      params.select { |name, value| nested_object?(object_class, name, value) }
+    end
+    
+    def select_has_one_objects_params(params, object_class)
+      params.select { |name, value| has_one_object?(object_class, name, value) }
+    end
+    
+    def select_collections_params(object, factory, params)
+      params.select { |name, value| nested_collection?(factory.object_class, name, value) }
+    end
+    
+    private
+    
+    def regular_attribute?(object_class, name, value)
+      !nested_object?(object_class, name, value) &&
+      !nested_collection?(object_class, name, value) &&
+      !has_one_object?(object_class, name, value)
+    end
+  end
+end

data/lib/traver/attributes_resolvers/active_record_attributes_resolver.rb

@@ -0,0 +1,21 @@
+module Traver
+  class ActiveRecordAttributesResolver < AttributesResolver
+    
+    private
+    
+    def nested_object?(object_class, name, value)
+      reflection = object_class.reflect_on_association(name)
+      reflection && reflection.macro == :belongs_to
+    end
+    
+    def has_one_object?(object_class, name, value)
+      reflection = object_class.reflect_on_association(name)
+      reflection && reflection.macro == :has_one
+    end
+    
+    def nested_collection?(object_class, name, value)
+      reflection = object_class.reflect_on_association(name)
+      reflection && reflection.collection?
+    end
+  end
+end

data/lib/traver/attributes_resolvers/poro_attributes_resolver.rb

@@ -0,0 +1,24 @@
+module Traver
+  class PoroAttributesResolver < AttributesResolver
+    
+    private
+    
+    def nested_object?(object_class, name, value)
+      Object.const_defined?(name.to_s.camelize)
+    end
+    
+    def has_one_object?(object_class, name, value)
+      nested_object?(object_class, name, value)
+    end
+    
+    def nested_collection?(object_class, name, value)
+      if plural?(name)
+        Object.const_defined?(name.to_s.singularize.camelize)
+      end
+    end
+    
+    def plural?(val)
+      val.to_s.pluralize == val.to_s
+    end
+  end
+end

data/lib/traver/default_params_creators/active_record_default_params_creator.rb

@@ -0,0 +1,11 @@
+module Traver
+  class ActiveRecordDefaultParamsCreator
+    def default_params(object_class)
+      associations = object_class.reflect_on_all_associations(:belongs_to)
+      
+      associations.each_with_object({}) do |association, result|
+        result[association.name] = :__ref__
+      end
+    end
+  end
+end

data/lib/traver/default_params_creators/poro_default_params_creator.rb

@@ -0,0 +1,7 @@
+module Traver
+  class PoroDefaultParamsCreator
+    def default_params(object_class)
+      {}
+    end
+  end
+end

data/lib/traver/factories_loader.rb

@@ -0,0 +1,30 @@
+module Traver
+  class FactoriesLoader
+    attr_reader :base_dir, :folder_name
+    attr_reader :factories_loaded
+    
+    FILE_NAME = "factories.rb"
+    
+    def initialize(base_dir, folder_name = "test")
+      @base_dir = base_dir
+      @folder_name = folder_name
+      
+      @factories_loaded = false
+    end
+    
+    def load_factories
+      unless factories_loaded
+        factories_file_path = File.join(base_dir, folder_name, FILE_NAME)
+    
+        require factories_file_path
+        
+        @factories_loaded = true
+      end
+    end
+  end
+  
+  class NilFactoriesLoader
+    def load_factories
+    end
+  end
+end

data/lib/traver/factory.rb

@@ -0,0 +1,35 @@
+module Traver
+  class Factory
+    attr_reader :name, :params, :parent_factory
+    
+    def initialize(name, params, parent_factory)
+      @name   = name
+      @params = params
+      @parent_factory = parent_factory
+    end
+    
+    def root_factory
+      parent_factory ? parent_factory.root_factory : self
+    end
+
+    def inherited_params
+      if parent_factory
+        parent_factory.inherited_params.merge(params)
+      else
+        params
+      end
+    end
+    
+    def root_name
+      root_factory.name
+    end
+    
+    def object_class_name
+      root_factory.name.to_s.camelize
+    end
+    
+    def object_class
+      Object.const_get(object_class_name)
+    end
+  end
+end

data/lib/traver/factory_definer.rb

@@ -1,51 +1,45 @@
 module Traver
   class FactoryDefiner
-    attr_reader :defined_factories
-    
     def initialize
-      @defined_factories = {}
+      undefine_all_factories
     end
     
-    def self.instance
-      @instance ||= FactoryDefiner.new
+    def define_factory(factory_name, parent_name, params)
+      factories[factory_name] = Factory.new(factory_name, params, factory_by_name(parent_name))
     end
     
-    def define_factory(factory_name, *options)
-      parent_name = nil
-      
-      if options.size == 1
-        params = options.first
-      elsif options.size == 2
-        parent_name, params = options
-      end
-      
-      defined_factories[factory_name] = { params: params, parent: parent_name }
+    alias :factory :define_factory
+    
+    def factory_params(factory_name)
+      factory_by_name(factory_name).params
     end
     
-    def get_object_class(factory_name)
-      if defined_factories[factory_name] && parent_name = defined_factories[factory_name][:parent]
-        get_object_class(parent_name)
-      else
-        Object.const_get(camelize(factory_name.to_s))
-      end
+    def parent_factory_name(factory_name)
+      factory_by_name(factory_name).parent_factory &&
+        factory_by_name(factory_name).parent_factory.name
+    end
+
+    def parent_factory_params(factory_name)
+      factory_by_name(factory_name).parent_factory.params
     end
     
-    def apply_factory_params(factory_name, params)
-      factory_params = get_factory_params(factory_name)
-      
-      factory_params.merge(params)
+    def factory_by_name(factory_name)
+      factories[factory_name] || default_factory(factory_name) if factory_name
     end
     
-    private
+    def undefine_all_factories
+      @factories = {}
+    end
     
-    def get_factory_params(factory_name)
-      if factory = defined_factories[factory_name]
-        get_factory_params(factory[:parent]).merge(factory[:params])
-      end || {}
+    def factories_count
+      factories.keys.length
     end
     
-    def camelize(str)
-      str.split('_').map(&:capitalize).join
+    private
+    attr_reader :factories
+    
+    def default_factory(factory_name)
+      Factory.new(factory_name, {}, nil)
     end
   end
 end

data/lib/traver/graph.rb

@@ -13,7 +13,7 @@ module Traver
       key = key.to_s
       
       if plural?(key)
-        vertices[singularize(key).to_sym]
+        vertices[key.singularize.to_sym]
       else
         name, index = key.split(/(\d+)$/)
         index = (index || 1).to_i
@@ -30,11 +30,7 @@ module Traver
     attr_reader :vertices
     
     def plural?(value)
-      value.end_with?("s")
-    end
-    
-    def singularize(value)
-      value.chomp("s")
+      value == value.pluralize
     end
   end
 end

data/lib/traver/graph_creator.rb

@@ -1,20 +1,28 @@
 module Traver
   class GraphCreator
-    attr_reader :params
+    attr_reader :factory_name, :params, :factory_definer, :sequencer
     attr_reader :graph
     
-    def initialize(params = {})
-      @params = params
+    def initialize(factory_name, params, factory_definer, sequencer)
+      @factory_name    = factory_name
+      @params          = params
+      @factory_definer = factory_definer
+      @sequencer       = sequencer
+      
+      @object_creator = ObjectCreator.new(factory_name, params, factory_definer, sequencer)
+      
       @graph = Graph.new
     end
     
     def create_graph
-      object_creator = ObjectCreator.new(params)
       object_creator.after_create = lambda do |creator|
-        graph.add_vertex(creator.factory_name, creator.created_object)
+        graph.add_vertex(creator.factory_name, creator.object)
       end
       
       object_creator.create_object
     end
+    
+    private
+    attr_reader :object_creator
   end
 end

data/lib/traver/list_creator.rb

@@ -0,0 +1,26 @@
+module Traver
+  class ListCreator
+    attr_reader :num, :factory_name, :params, :factory_definer, :sequencer
+    attr_reader :list
+    
+    def initialize(num, factory_name, params, factory_definer, sequencer)
+      @num             = num
+      @factory_name    = factory_name
+      @params          = params
+      @factory_definer = factory_definer
+      @sequencer       = sequencer
+    end
+    
+    def create_list
+      @list = num.times.map do
+        object_creator.create_object(factory_name, params, factory_definer, sequencer)
+      end
+    end
+    
+    private
+    
+    def object_creator
+      ObjectCreator
+    end
+  end
+end

data/lib/traver/object_creator.rb

@@ -1,92 +1,220 @@
+require "forwardable"
+
 module Traver
   class ObjectCreator
-    attr_reader :factory_name, :params
+    extend Forwardable
+    
+    attr_reader :factory_name, :params, :factory_definer, :sequencer, :cache, :nesting
+    attr_reader :object
+    
     attr_accessor :after_create
-    attr_reader :created_object
     
-    def initialize(options)
-      options = { options => {} } if options.is_a?(Symbol)
+    def_delegators :settings, :object_persister,
+                              :attributes_resolver,
+                              :default_params_creator
+    
+    def self.create_object(factory_name, params, factory_definer, sequencer, cache = {}, nesting = 1)
+      creator = new(factory_name, params, factory_definer, sequencer, cache, nesting)
+      creator.create_object
       
-      @factory_name, @params = options.first
-      @factory_definer = FactoryDefiner.instance
+      creator.object
+    end
+    
+    def initialize(factory_name, params, factory_definer, sequencer, cache = {}, nesting = 1)
+      @factory_name    = factory_name
+      @params          = params
+      @factory_definer = factory_definer
+      @sequencer       = sequencer
+      @cache           = cache
+      @nesting         = nesting
     end
     
     def create_object
-      instantiate_object
-      set_object_state
-      persist_object
-      call_after_create_hook
+      obtain_factory
+      
+      if obtain_object_from_cache?
+        obtain_object_from_cache
+      else
+        # puts "#{'-' * nesting} #{factory_name}<br/>"
+        
+        change_ref_to_be_empty_hash
+        merge_factory_params
+        merge_default_params
+        instantiate_object
+        set_nested_objects
+        set_attributes
+        persist_object
+        set_has_one_objects
+        set_nested_collections
+        call_after_create_hook
+      end
     end
     
     private
-    attr_reader :factory_definer
+    attr_reader :factory
+    
+    def obtain_factory
+      @factory = factory_definer.factory_by_name(factory_name)
+    end
+    
+    def obtain_object_from_cache?
+      params == :__ref__ && cache.has_key?(factory.root_name)
+    end
+    
+    def obtain_object_from_cache
+      @object = cache[factory.root_name]
+    end
+    
+    def change_ref_to_be_empty_hash
+      @params = {} if params == :__ref__
+    end
+    
+    def merge_factory_params
+      @params = factory.inherited_params.merge(params)
+    end
+    
+    def merge_default_params
+      @params = default_params_creator.default_params(factory.object_class).merge(params)
+    end
     
     def instantiate_object
-      @created_object = get_class.new
+      @object = factory.object_class.new
     end
     
-    def get_class
-      factory_definer.get_object_class(factory_name)
+    # Attributes
+    
+    def set_attributes
+      attributes_resolver.select_attributes_params(params, factory.object_class).each do |name, value|
+        set_attribute(name, value)
+      end
     end
     
-    def set_object_state
-      factory_params.each do |attribute, value|
-        if nested_params?(value)
-          create_nested_object(attribute, value)
-        elsif collection_params?(value)
-          create_collection(attribute, value)
-        else
-          set_attribute(attribute, value)
+    def set_attribute(attribute, value)
+      if value.is_a?(Proc)
+        value = object.instance_exec(&value)
+      elsif value.is_a?(String)
+        if sequencer.value_has_sequence?(value)
+          value = sequencer.interpolate_sequence(attribute, value)
         end
       end
+      
+      object.public_send("#{attribute}=", value)
     end
-
-    def factory_params
-      factory_definer.apply_factory_params(factory_name, params)
-    end
     
-    def nested_params?(params)
-      params.is_a?(Hash)
+    # Nested Objects
+    
+    def set_nested_objects
+      attributes_resolver.select_objects_params(params, factory.object_class).each do |name, value|
+        set_nested_object(name, value)
+      end
     end
     
-    def create_nested_object(k, v)
-      set_attribute(k, do_create_object(k => v))
+    def set_nested_object(name, value)
+      if value.is_a?(Integer)
+        set_attribute(name, create_nested_object(name, {}))
+      elsif value.is_a?(Hash) || value == :__ref__
+        set_attribute(name, create_nested_object(name, value))
+      elsif value.is_a?(Symbol)
+        set_attribute(name, create_nested_object(value, {}))
+      else
+        set_attribute(name, value)
+      end
     end
     
-    def do_create_object(params)
-      object_creator = ObjectCreator.new(params)
+    def create_nested_object(factory_name, params)
+      object_creator = ObjectCreator.new(factory_name, params, factory_definer, sequencer, cache, nesting + 1)
       object_creator.after_create = after_create
       object_creator.create_object
       
-      object_creator.created_object
+      object_creator.object
     end
     
-    def set_attribute(attribute, value)
-      created_object.public_send("#{attribute}=", value)
-    end
     
-    def collection_params?(params)
-      params.is_a?(Array)
+    # Has one objects
+    
+    def set_has_one_objects
+      attributes_resolver.select_has_one_objects_params(params, factory.object_class).each do |name, value|
+        set_nested_object(name, value)
+      end
     end
     
-    def create_collection(attribute, collection_params)
-      collection = collection_params.map do |params|
-        do_create_object(singularize(attribute) => params)
+    # Nested Collections
+    
+    def set_nested_collections
+      attributes_resolver.select_collections_params(object, factory, params).each do |collection_name, params_array|
+        set_nested_collection(collection_name, params_array)
       end
+    end
+    
+    def set_nested_collection(collection_name, params_array)
+      factory_name = collection_name.to_s.singularize.to_sym
       
-      set_attribute(attribute, collection)
+      set_attribute(collection_name, create_nested_collection(factory_name, params_array))
     end
     
-    def singularize(val)
-      val.to_s.chomp("s").to_sym
+    def create_nested_collection(factory_name, params_array)
+      if params_array.is_a?(Integer)
+        params_array = [{}] * params_array
+        
+        params_array.map do |params|
+          create_nested_object(factory_name, params)
+        end
+      elsif params_array.first.is_a?(Symbol)
+        params_array.map do |factory_name|
+          create_nested_object(factory_name, {})
+        end
+      else
+        if params_array.first.is_a?(Integer)
+          num, hash_or_symbol = params_array
+        
+          if hash_or_symbol.nil?
+            params_array = [{}] * num
+          elsif (hash = hash_or_symbol).is_a?(Hash)
+            params_array = [hash] * num
+          elsif hash_or_symbol.is_a?(Symbol)
+            factory_name = hash_or_symbol
+          
+            params_array = [{}] * num
+          else
+            raise "Wrong collection params #{params_array}"
+          end
+        end
+      
+        params_array.map do |params|
+          create_nested_object(factory_name, params)
+        end
+      end
+    end
+    
+    # Settings
+    
+    
+    def settings
+      @settings ||=
+        if object_is_active_record?
+          ActiveRecordSettings.new
+        else
+          PoroSettings.new
+        end
     end
     
+    def object_is_active_record?
+      factory.object_class < ActiveRecord::Base
+    end
+    
+    
+    # Persist Object
+    
     def persist_object
-      created_object.save if defined?(Rails)
+      object_persister.persist_object(object)
+      cache[factory.root_name] = object
     end
     
+    
+    # Hooks
+    
     def call_after_create_hook
       after_create.call(self) if after_create
     end
   end
-end
+end

data/lib/traver/object_persisters/active_record_object_persister.rb

@@ -0,0 +1,9 @@
+module Traver
+  class ActiveRecordObjectPersister
+    def persist_object(object)
+      unless object.save
+        raise "Unable to save #{object.class}: #{object.errors.full_messages}"
+      end
+    end
+  end
+end

data/lib/traver/object_persisters/poro_object_persister.rb

@@ -0,0 +1,6 @@
+module Traver
+  class PoroObjectPersister
+    def persist_object(object)
+    end
+  end
+end

data/lib/traver/sequencer.rb

@@ -0,0 +1,24 @@
+class Sequencer
+  attr_reader :sequence_store
+  
+  def initialize
+    @sequence_store = {}
+  end
+  
+  def value_has_sequence?(value)
+    !!(value =~ /\$\{n\}/)
+  end
+  
+  def interpolate_sequence(name, value)
+    value.sub("${n}", next_sequence_value_for(name).to_s)
+  end
+  
+  private
+  
+  def next_sequence_value_for(name)
+    sequence_store[name] ||= 0 
+    sequence_store[name] += 1
+    
+    sequence_store[name]
+  end
+end

data/lib/traver/settings/active_record_settings.rb

@@ -0,0 +1,13 @@
+require "traver/settings"
+
+module Traver
+  class ActiveRecordSettings < Settings
+    def initialize
+      super
+      
+      @object_persister       = ActiveRecordObjectPersister.new
+      @attributes_resolver    = ActiveRecordAttributesResolver.new
+      @default_params_creator = ActiveRecordDefaultParamsCreator.new
+    end
+  end
+end

data/lib/traver/settings/poro_settings.rb

@@ -0,0 +1,13 @@
+require "traver/settings"
+
+module Traver
+  class PoroSettings < Settings
+    def initialize
+      super
+      
+      @object_persister       = PoroObjectPersister.new
+      @attributes_resolver    = PoroAttributesResolver.new
+      @default_params_creator = PoroDefaultParamsCreator.new
+    end
+  end
+end

data/lib/traver/settings.rb

@@ -0,0 +1,7 @@
+module Traver
+  class Settings
+    attr_reader :object_persister,
+                :attributes_resolver,
+                :default_params_creator
+  end
+end

data/lib/traver/traver_constructor.rb

@@ -0,0 +1,93 @@
+module Traver
+  class TraverConstructor
+    attr_reader :factory_definer, :sequencer
+    
+    def initialize
+      @factory_definer = FactoryDefiner.new
+      @sequencer       = Sequencer.new
+    end
+    
+    def create(*options)
+      factory_name, params = parse_create_options(options)
+      
+      ObjectCreator.create_object(factory_name, params, factory_definer, sequencer)
+    end
+    
+    def create_graph(*options)
+      factory_name, params = parse_create_options(options)
+    
+      graph_creator = GraphCreator.new(factory_name, params, factory_definer, sequencer)
+      graph_creator.create_graph
+    
+      graph_creator.graph
+    end
+    
+    def create_list(num, *options)
+      factory_name, params = parse_create_options(options)
+      
+      list_creator = ListCreator.new(num, factory_name, params, factory_definer, sequencer)
+      list_creator.create_list
+      
+      list_creator.list
+    end
+    
+    def define_factories(&block)
+      instance_exec(&block)
+    end
+    
+    alias :factories :define_factories
+    
+    def define_factory(factory_name, *options)
+      parent_factory_name, params = parse_factory_options(options)
+    
+      factory_definer.define_factory(factory_name, parent_factory_name, params)
+    end
+    
+    alias :factory :define_factory
+    
+    def undefine_all_factories
+      factory_definer.undefine_all_factories
+    end
+    
+    def factories_count
+      factory_definer.factories_count
+    end
+    
+    private
+    
+    def parse_create_options(options)
+      if factory_girl_options?(options)
+        parse_factory_girl_options(options)
+      else
+        parse_traver_options(options)
+      end
+    end
+    
+    def factory_girl_options?(options)
+      options.first.is_a?(Symbol)
+    end
+    
+    def parse_factory_girl_options(options)
+      factory_name, params = options
+      params ||= {}
+      
+      [factory_name, params]
+    end
+    
+    def parse_traver_options(options)
+      options.first.first
+    end
+    
+    def parse_factory_options(options)
+      parent_factory_name = nil
+    
+      if options.size == 1
+        params = options.first
+      elsif options.size == 2
+        parent_factory_name, params = options
+      end
+      
+      [parent_factory_name, params]
+    end
+  end
+end

data/lib/traver/version.rb

@@ -1,3 +1,3 @@
 module Traver
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

data/lib/traver.rb

@@ -1,28 +1,67 @@
-require "traver/version"
-require "traver/factory_definer"
-require "traver/object_creator"
-require "traver/graph"
-require "traver/graph_creator"
+require "active_support/inflector"
+
+Dir["#{File.dirname(__FILE__)}/traver/**/*.rb"].each { |file| require file }
 
 module Traver
   class Error < Exception; end
   
-  def self.factory(factory_name, *options)
-    factory_definer = FactoryDefiner.instance
-    factory_definer.define_factory(factory_name, *options)
-  end
+  class << self
+    attr_reader :factories_loaded
+    
+    def create(*options)
+      load_factories
+      
+      traver_constructor.create(*options)
+    end
   
-  def self.create(options)
-    object_creator = ObjectCreator.new(options)
-    object_creator.create_object
+    def create_graph(*options)
+      load_factories
+      
+      traver_constructor.create_graph(*options)
+    end
     
-    object_creator.created_object
-  end
+    def create_list(num, *options)
+      load_factories
+      
+      traver_constructor.create_list(num, *options)
+    end
+    
+    def define_factory(factory_name, *options)
+      traver_constructor.define_factory(factory_name, *options)
+    end
+
+    alias :factory :define_factory
+    
+    def define_factories(&block)
+      traver_constructor.define_factories(&block)
+    end
+    
+    alias :factories :define_factories
   
-  def self.create_graph(params = {})
-    graph_creator = GraphCreator.new(params)
-    graph_creator.create_graph
+    def undefine_all_factories
+      traver_constructor.undefine_all_factories
+    end
+    
+    private
+    
+    def traver_constructor
+      @traver_constructor ||= TraverConstructor.new
+    end
+    
+    def load_factories
+      unless factories_loaded
+        factories_loader.load_factories
+
+        @factories_loaded = true
+      end
+    end
     
-    graph_creator.graph
+    def factories_loader
+      if defined?(Rails)
+        FactoriesLoader.new(Rails.root, "spec")
+      else
+        NilFactoriesLoader.new
+      end
+    end
   end
 end

data/traver.gemspec

@@ -18,7 +18,9 @@ Gem::Specification.new do |spec|
   spec.bindir        = "exe"
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-
+  
+  spec.add_runtime_dependency "activesupport"
+  
   spec.add_development_dependency "bundler", "~> 1.11"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest", "~> 5.0"

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: traver
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Yuri Kaspervich
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-03-10 00:00:00.000000000 Z
+date: 2016-04-04 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -96,10 +110,25 @@ files:
 - bin/console
 - bin/setup
 - lib/traver.rb
+- lib/traver/attributes_resolver.rb
+- lib/traver/attributes_resolvers/active_record_attributes_resolver.rb
+- lib/traver/attributes_resolvers/poro_attributes_resolver.rb
+- lib/traver/default_params_creators/active_record_default_params_creator.rb
+- lib/traver/default_params_creators/poro_default_params_creator.rb
+- lib/traver/factories_loader.rb
+- lib/traver/factory.rb
 - lib/traver/factory_definer.rb
 - lib/traver/graph.rb
 - lib/traver/graph_creator.rb
+- lib/traver/list_creator.rb
 - lib/traver/object_creator.rb
+- lib/traver/object_persisters/active_record_object_persister.rb
+- lib/traver/object_persisters/poro_object_persister.rb
+- lib/traver/sequencer.rb
+- lib/traver/settings.rb
+- lib/traver/settings/active_record_settings.rb
+- lib/traver/settings/poro_settings.rb
+- lib/traver/traver_constructor.rb
 - lib/traver/version.rb
 - traver.gemspec
 homepage: http://github.com/yukas/traver