factory_loader 0.1.0 → 0.1.1

data/Rakefile

@@ -10,7 +10,7 @@ desc "Generate RDoc documentation"
 Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_dir = 'rdoc'
   rdoc.title    = "FactoryLoader: intended to help scaling complex object creation with less pain and less refactoring." 
-  rdoc.rdoc_files.include('lib/**/*.rb', 'README','CHANGES','MIT-LICENSE')
+  rdoc.rdoc_files.include('lib/**/*.rb', 'README.txt','History.txt','MIT-LICENSE')
 end
 
 require 'rubygems'

data/lib/factory_loader.rb

@@ -3,63 +3,88 @@ require 'find'
 # FactoryLoader is intended to help scale object creation with less pain and less 
 # refactoring. 
 #
-# In the early stages of a project object creation is simple and object
+# In the early stages of a project object creation is simple and 
 # dependencies are kept to a minimum. As the project grows so does the
-# complexity of object dependencies and object creation. It doesn't make
+# complexity of object creation and dependencies. It doesn't make
 # sense to create custom factory classes upfront to deal with complex
 # object construction that may not exist yet. But when those custom
 # factories are needed it is usually painful and time consuming to update
 # the code base to use them. It's also easy for developers to give-in
 # due to time constraints and start making bad decisions.
 #
-# This is where FactoryLoader comes into play. It automaticaly creates a Factory
+# This is where FactoryLoader comes into play. It automatically creates a Factory
 # class for your objects and provides a Factory#create method which passes any arguments
 # along to your object's constructor.
 #
 # When you need to have custom factory behavior you can implement the factory
-# without having to update other code references (assuming you've used them
+# without having to update other code references (assuming you've used the factory
 # in the rest of your application rather then direct class references).
 #
-# For example given a directory structure like the below:
+#   project/
+#     init.rb
+#     lib/
+#      |--things/
+#             |-- foo.rb
+#             |-- bar.rb
+#      |--factories/
+#             |-- bar_factory.rb
 #
-#   init.rb
-#   lib/
-#    |--things/
-#           |-- foo.rb
-#           |-- bar.rb
-#    |--factories/
-#           |-- bar_factory.rb
-#
-# Given this project directory structure you could have the following code 
+# Given the above project directory structure you could have the following code 
 # in init.rb:
 #    factory_loader = FactoryLoader.new("lib/factories")
 #    factory_loader.load("lib/things")
 # 
 # The first call constructs a factory loader telling it which directory is used
-# to store custom factories. 
+# to store developer-written custom factories. 
 #
-# The second call will create a factory for each *.rb file in the lib/things/
-# directory. So for the foo.rb file a FooFactory class will be created
-# which can be used to wrap creation of Foo objects. The generated factory
+# The second call will create a in-memory factory class for each *.rb file 
+# in the lib/things/ directory. A FooFactory class will be created to
+# correspond with the foo.rb file. The generated factory
 # will provide a #create method which will pass along all arguments to
 # the constructor of the object it wraps. So...
 #    FooFactory.new.create :a => :b 
 # is the same as:
 #    Foo.new :a => :b
 #
-# A FooFactory will be created, but a BarFactory will not. This is because
+# A BarFactory will NOT be created. This is because
 # we told the FactoryLoader that custom factories are storied in lib/factories/
-# and a bar_factory.rb exists there, so FactoryLoader assumes you want to use
-# a custom factory.
+# and a bar_factory.rb file exists there, so FactoryLoader assumes you want to use
+# a custom factory. It also assumes that the class inside of bar_factory.rb is BarFactory.
+#
+# FactoryLoader dynamically creates the factory classes -- they are not written
+# to disk. FactoryLoader also uses file naming conventions to determine
+# what to do. For example: 
+#    foo.rb => FooFactory
+#    crazy_dolphins.rb => CrazyDolphinsFactory
+#
+# === Factory.new
+# The dynamically created factories are CLASSES and create is an INSTANCE method on them. You
+# have to construct a factory in order to use it. This is so the factories themselves can be easily used in dependency injection
+# frameworks. 
+#
+# === Public Git repository: 
+# git://github.com/zdennis/factory_loader.git
+# 
+# === Homepage: 
+# http://www.continuousthinking.com/factory_loader
+#
+# === Author: 
+# * Zach Dennis at Mutually Human Software (zach.dennis@gmail.com, zdennis@mutuallyhuman.com)
 #
-# Author: Zach Dennis, zdennis at mutuallyhuman dot com
+# === Special Thanks
+# * Dave Crosby at Atomic Object
+# * Ryan Fogle at Atomic Object
 class FactoryLoader
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
   
+  # Constructs a FactoryLoader. The passed in factory_paths are searched recursively.
   def initialize(*factory_paths)
     @factory_paths = factory_paths.map{ |f| File.expand_path(f) } 
   end
 
+  # Creates factory classes based on searching filenames in the passed in directory
+  # and comparing them against factory file names in the passed in factory_paths
+  # given to the constructor.
   def load(directory) # :nodoc:
     Dir[directory + "/**/*.rb"].each do |file|
       object_filename = File.basename(file, ".rb")

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: factory_loader
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors: 
 - Zach Dennis
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-03-17 00:00:00 -04:00
+date: 2008-03-18 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency