fill 0.1.0

data/Manifest

@@ -0,0 +1,12 @@
+Manifest
+README.rdoc
+Rakefile
+VERSION
+fill.gemspec
+lib/fill.rb
+lib/fill/configure.rb
+lib/fill/presenter.rb
+lib/fill/procedure.rb
+spec/fill_spec.rb
+spec/spec.opts
+spec/spec_helper.rb

data/README.rdoc

@@ -0,0 +1,131 @@
+= Fill
+
+Rails 2.3.4 introduced db/seeds. Basically that means that the rake task
+"rake db:seed" will run db/seeds.rb, so you can have a centralized place
+to prepare your database by adding seed data.
+
+"Fill" takes this one step further and provides methods to easily define
+data in db/seeds.rb. Here's how:
+
+  Fill.database do  |db|
+
+    db.produce :projects do
+      10.times { Factory(:project) }
+    end
+
+  end
+
+(I use factory_girl here, do whatever you like off course)
+
+Now, when running "rake db:seed", it'll delete all records in the Project
+model and run the contents off the produce block. It'll also measure how
+long it took, resulting in this output:
+
+  +-------+--------+---------+----------+
+  | After | Before | Models  | Time     |
+  +-------+--------+---------+----------+
+  | 10    | 0      | Project | 0.018627 |
+  +-------+--------+---------+----------+
+
+You'll need to install hirb for this pretty output. Otherwise it won't print
+out this pretty table. I recommend using Hirb anyway. Find it at
+http://github.com/cldwalker/hirb
+
+== Why?
+
+At my company, we taught testers, customers and developers to use
+webistrano and run the db:seed" rake task themselves. This way, they can 
+test and experiment as much as they want, and they easily reset the
+database when they fucked it up.
+
+== Usage
+
+=== db.produce
+
+By specifying a block, do whatever you need to fill a model.
+
+Example:
+
+  db.produce :users, :memberships do
+    10.times do
+      user = Factory(:user)
+      membership = Factory(:membership, :user => user)
+    end
+  end
+
+Specify the models that you want. The models that you specified will be
+emptied, which is handy if you're building relational models, like users
+and their memberships.
+
+The models are named *plural*.
+
+=== db.fill
+
+Provide a simple list of values.
+
+Example
+
+  db.fill :projects, :name, "Foo", "Bar", "Baz", "etc"
+
+For simple models with only one distinct attribute, you can just specify
+the model, attribute and the values.
+
+See also the iain/root_table plugin if you have many of these.
+
+=== db.invoke
+
+Invoke a rake task.
+
+  db.invoke "some:task", :projects
+
+I use a seperate rake task whenever I need to import files. Of course you
+can do that in the +db.produce+, but that clutters your seeds.rb.
+
+=== Global options
+
+These options work on all above mentioned methods.
+
+==== :needs
+
+Specify one or many dependencies, tables to be filled before filling the ones
+you're specifying now.
+
+Example
+
+  db.produce :memberships, :needs => :users do
+    User.all.each { |user| Factory(:membership, :user => user) }
+  end
+
+==== :delete
+
+Set to false if you don't want to delete all records before filling it.
+
+Example:
+
+  db.invoke "import:zipcodes", :zips, :delete => false
+
+In this example, the zipcodes import takes a long time to complete, so it
+doesn't insert them when the database is already filled.
+
+==== :name
+
+The output uses Rails i18n methods to determine how the output calls the
+models filled, but if you want to specify your own name, use this option.
+
+Example:
+
+  db.produce :users, :name => "Accounts" do
+    ....
+  end
+
+== Installation
+
+Add this to config/environment.rb:
+
+  config.gem "iain-fill", :lib => "fill", :source => "http://gems.github.com"
+
+And run "+rake gems:install+" and you're done.
+
+---
+
+Made by Iain, http://iain.nl/, Released under the MIT License

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rake'
+require 'rake/rdoctask'
+
+require 'spec/rake/spectask'
+desc "Run all specs in spec directory"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = ['--options spec/spec.opts']
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+
+begin
+  require 'echoe'
+  Echoe.new('fill', File.read('VERSION').chomp) do |p|
+    p.description = "Simple DSL for filling (seeding) your database"
+    p.url = "http://github.com/iain/fill"
+    p.author = "iain"
+    p.email = "iain@iain.nl"
+    p.ignore_pattern = [ "pkg/*" ]
+    p.development_dependencies = []
+    p.runtime_dependencies = []
+  end
+rescue LoadError
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/fill.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{fill}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["iain"]
+  s.date = %q{2009-09-25}
+  s.description = %q{Simple DSL for filling (seeding) your database}
+  s.email = %q{iain@iain.nl}
+  s.extra_rdoc_files = ["README.rdoc", "lib/fill.rb", "lib/fill/configure.rb", "lib/fill/presenter.rb", "lib/fill/procedure.rb"]
+  s.files = ["Manifest", "README.rdoc", "Rakefile", "VERSION", "fill.gemspec", "lib/fill.rb", "lib/fill/configure.rb", "lib/fill/presenter.rb", "lib/fill/procedure.rb", "spec/fill_spec.rb", "spec/spec.opts", "spec/spec_helper.rb"]
+  s.homepage = %q{http://github.com/iain/fill}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Fill", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{fill}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Simple DSL for filling (seeding) your database}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/lib/fill.rb

@@ -0,0 +1,39 @@
+require 'activesupport'
+require File.dirname(__FILE__) + '/fill/configure'
+require File.dirname(__FILE__) + '/fill/presenter'
+require File.dirname(__FILE__) + '/fill/procedure'
+
+module Fill
+
+  VERSION = File.read(File.dirname(__FILE__) + '/../VERSION').chomp
+
+  class << self
+
+
+    attr_writer :out
+    def out
+      @out ||= STDOUT
+    end
+
+    def database
+      db = Configure.new
+      yield db
+      perform!(db)
+    end
+
+    def perform!(configuration)
+      bm = time { configuration.perform! }
+      out.puts Presenter
+      out.puts "Database filled in %.2f seconds" % bm
+      Presenter.clear!
+    end
+
+    def time
+      started_at = Time.now
+      yield
+      Time.now - started_at
+    end
+
+  end
+
+end

data/lib/fill/configure.rb

@@ -0,0 +1,69 @@
+module Fill
+
+  class Configure
+
+    def produce(*models, &block)
+      options = models.extract_options!
+      needs = options.delete(:needs) || []
+      register models, Procedure.new(models, options, &block)
+      dependent models, needs
+    end
+
+    def fill(model, field, *values)
+      options = values.extract_options!
+      self.produce model, options do
+        values.each do |value|
+          model.to_s.singularize.camelize.constantize.create!(field => value)
+        end
+      end
+    end
+
+    def invoke(task, *models)
+      self.produce *models do
+        Rake::Task[task].invoke
+      end
+    end
+
+    def environment(env, which, options = {})
+
+    end
+
+    def perform!
+      registered.each_key { |model| perform(model) }
+    end
+
+    private
+
+    def results
+      results = registered.values.uniq.compact.map { |data| data.to_hash }
+    end
+
+    def perform(model)
+      raise "No fill data provided for #{model}" unless registered.has_key? model
+      dependencies[model].each { |dep| perform(dep) } if dependencies.has_key? model
+      registered[model].perform!
+    end
+
+    def register(models, data)
+      models.each do |model|
+        registered.update model => data
+      end
+    end
+
+    def dependent(models, dependent)
+      models.each do |model|
+        dependencies.update model => [dependent].flatten
+      end
+    end
+
+    def registered
+      @registered ||= {}
+    end
+
+    def dependencies
+      @dependencies ||= {}
+    end
+
+  end
+
+end

data/lib/fill/presenter.rb

@@ -0,0 +1,67 @@
+module Fill
+
+  class Presenter
+
+    def self.present(data)
+      presenter.add(data)
+    end
+
+    def self.presenter
+      @presenter ||= new
+    end
+
+    def self.to_s
+      presenter.to_s
+    end
+
+    def self.hirb?
+      require 'hirb'
+      true
+    rescue LoadError
+      false
+    end
+
+    def self.clear!
+      @presenter = nil
+    end
+
+    def add(data)
+      presented.push(data) if data && !presented.include?(data)
+    end
+
+    def hirb?
+      self.class.hirb?
+    end
+
+    def presented
+      @presented ||= []
+    end
+
+    def presentable
+      presented.map(&:to_hash)
+    end
+
+    def present_with_hirb
+      Hirb::Helpers::Table.render(presentable, :description => false)
+    end
+
+    def to_s
+      hirb? ? present_with_hirb : present_hash.join("\n")
+    end
+
+    def present_hash
+      presentable.map do |row|
+        format_row(row).join(" - ")
+      end
+    end
+
+    def format_row(row)
+      row.map do |key, value|
+        value = "%.2f" % value if key == "Time"
+        "#{key}: #{value}"
+      end
+    end
+
+  end
+
+end

data/lib/fill/procedure.rb

@@ -0,0 +1,55 @@
+module Fill
+
+  class Procedure
+
+    attr_accessor :block, :options
+
+    def initialize(models, options = {}, &block)
+      @block   = block
+      @options = { :delete => true }.merge(options)
+      @models  = models
+    end
+
+    def perform!
+      @performed ||= perform
+    end
+
+    def to_hash
+      { "Models" => human_models, "Before" => @before.join(', '), "After" => @after.join(', '), "Time" => @time }
+    end
+
+    def human_models
+      @human_models ||= (options[:name] || humanize_models)
+    end
+
+    def humanize_models
+      models.map { |model| i18n_name(model) }.join(', ')
+    end
+
+    def i18n_name(model)
+      model.respond_to?(:human_name) ? model.human_name : model.to_s
+    end
+
+    def delete_all
+      models.map { |model| model.delete_all }
+    end
+
+    def models
+      @models.map { |model| model.to_s.singularize.camelize.constantize }
+    end
+
+    def count
+      models.map { |model| model.count }
+    end
+
+    def perform
+      @before = options[:delete] ? delete_all : count
+      @time   = Fill.time { block.call }
+      @after  = count
+      Presenter.present self
+      true
+    end
+
+  end
+
+end

data/spec/fill_spec.rb

@@ -0,0 +1,249 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Fill do
+
+  before  do
+    Output.output = []
+  end
+
+  describe "the the internal workings of db.produce" do
+
+    it "should perform the content only after the block is closed" do
+      # This is so that all dependencies can be initialized
+      # before anything is executed.
+      lambda {
+        Fill.database do |db|
+          lambda {
+            db.produce :projects do
+              throw :fill_executed
+            end
+          }.should_not throw_symbol(:fill_executed)
+        end
+      }.should throw_symbol(:fill_executed)
+    end
+
+    it "should count the records" do
+      mock(Project).count
+      produce!
+    end
+
+    it "should delete all the records" do
+      mock(Project).delete_all
+      produce!
+    end
+
+    it "should get the human name of a model" do
+      mock(Project).human_name
+      produce!
+    end
+
+    it "should report the total time" do
+      produce!
+      Output.output.last.should =~ /\ADatabase filled in (.*) seconds\Z/
+    end
+
+    context "without hirb" do
+
+      before { mock(Fill::Presenter).hirb? { false } }
+
+      describe "output per model" do
+
+        before do
+          stub(Project).human_name { "FOOBAR" }
+          stub(Project).delete_all { 123456789 }
+          stub(Project).count      { 987654321 }
+          produce!
+        end
+
+        subject { Output.output.first }
+
+        it { should =~ /Time: ([0-9.]+)/ }
+        it { should include("Before: 123456789") }
+        it { should include("After: 987654321") }
+        it { should include("Models: FOOBAR") }
+
+      end
+
+      it "should count the time of the block" do
+
+        # Fill itself shouldn't take up more than 1 second
+        # so this test should return just about 1 second
+        # I _am_ sorry about this crude example ;)
+
+        produce! { sleep 1 } # zzzzzzzzzz
+
+        Output.output.first =~ /Time: ([0-9.]+)/
+        $1.to_i.should == 1
+
+        # Test total time, not in a seperate example to shorten testrun
+        Output.output.last =~ /([0-9.]+) seconds/
+        $1.to_i.should == 1
+      end
+
+    end
+
+    it "should use hirb when possible" do
+      out = "---HIRB OUTPUT---"
+      mock(Fill::Presenter).hirb? { true }
+      mock(Hirb::Helpers::Table).render(is_a(Array), :description => false) { out }
+      produce!
+      Output.output.first.should == out
+    end
+
+  end
+
+  describe "arguments for db.produce" do
+
+    describe "multiple models" do
+
+      after do
+        produce! :projects, :users, :memberships do
+          User.create
+        end
+      end
+
+      it "calls delete_all on all models" do
+        mock(Project).delete_all
+        mock(User).delete_all
+        mock(Membership).delete_all
+      end
+
+      it "calls count on all models" do
+        mock(Project).count
+        mock(User).count
+        mock(Membership).count
+      end
+
+      it "calls human_name on all models" do
+        mock(Project).human_name
+        mock(User).human_name
+        mock(Membership).human_name
+      end
+
+      it "should only execute the procedure once" do
+        mock(User).create.times(1)
+      end
+
+    end
+
+    describe "dependencies" do
+
+      it "should run dependencies first" do
+        # This works because the dont_allow should be executed AFTER
+        # the call was actually done! Similarly, the mock should be
+        # defined BEFORE it was done.
+        Fill.database do |db|
+          db.produce :users, :needs => :projects do
+            dont_allow(Project).create
+            User.create
+          end
+          db.produce :projects do
+            Project.create
+            mock(User).create
+          end
+        end
+      end
+
+      it "should execute once, even with multiple dependencies" do
+        mock(User).create.times(1)
+        Fill.database do |db|
+          db.produce(:memberships, :needs => :users) {}
+          db.produce(:projects, :needs => :users) {}
+          db.produce(:users) { User.create }
+        end
+      end
+
+      it "should handle multiple dependencies" do
+        Fill.database do |db|
+          db.produce(:memberships, :needs => [:users, :projects]) do
+            # Again, don't allow, because these should already have
+            # been executed before this block is executed.
+            dont_allow(Project).create
+            dont_allow(User).create
+            Membership.create # twice because mocked twice
+            Membership.create
+          end
+          db.produce(:projects, :needs => :users) do
+            Project.create
+            mock(Membership).create
+            dont_allow(User).create
+          end
+          db.produce(:users) do
+            User.create
+            mock(Project).create
+            mock(Membership).create
+          end
+        end
+      end
+
+      context "without hirb" do
+
+        before { stub(Fill::Presenter).hirb? { false } }
+
+        it "should join model names" do
+          mock(Project).human_name  { "Projects" }
+          mock(User).human_name     { "Accounts" }
+          produce! :projects, :users
+          Output.output.first.should include("Models: Projects, Accounts")
+        end
+
+        it "should join before counts" do
+          mock(Project).delete_all { 1234 }
+          mock(User).delete_all    { 4321 }
+          produce! :projects, :users
+          Output.output.first.should include("Before: 1234, 4321")
+        end
+
+        it "should join before counts" do
+          mock(Project).count { 789 }
+          mock(User).count    { 456 }
+          produce! :projects, :users
+          Output.output.first.should include("After: 789, 456")
+        end
+
+        it "should add up times" do
+          produce! :projects, :users
+          Output.output.first.should =~ /Time: [0-9.][^,]/ # no comma, no join(',')
+        end
+
+      end
+
+    end
+
+    describe "names" do
+
+      before { stub(Fill::Presenter).hirb? { false } }
+
+      it "should override name" do
+        name = ":::MYNAME:::"
+        dont_allow(Project).human_name
+        produce! :projects, :name => name
+        Output.output.first.should include("Models: #{name}")
+      end
+
+      it "should override name with multiple models" do
+        name = ":::FOOBAR:::"
+        dont_allow(Project).human_name
+        dont_allow(User).human_name
+        dont_allow(Membership).human_name
+        produce! :projects, :users, :memberships, :name => name
+        Output.output.first.should include("Models: #{name}")
+      end
+
+    end
+
+    describe "delete option" do
+
+      it "should not delete with delete option to false" do
+        dont_allow(Project).delete_all
+        dont_allow(User).delete_all
+        mock(Project).count.times(2) # before and after
+        mock(User).count.times(2) # before and after
+        produce! :users, :projects, :delete => false
+      end
+
+    end
+
+  end
+
+end

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+require File.dirname(__FILE__) + '/../lib/fill'
+
+Spec::Runner.configure do |config|
+  config.mock_with :rr
+end
+
+def produce!(*args)
+  args = [:projects] if args.empty?
+  Fill.database do |db|
+    db.produce *args do
+      yield if block_given?
+    end
+  end
+end
+
+class ActiveRecordMimic
+  class << self
+    attr_reader :delete_all, :count, :create, :human_name
+  end
+end
+
+class Output
+  class << self
+    attr_accessor :output
+    def puts(string)
+      @output ||= []
+      @output << string.to_s
+    end
+  end
+end
+Fill.out = Output
+
+class User       < ActiveRecordMimic; end
+class Project    < ActiveRecordMimic; end
+class Membership < ActiveRecordMimic; end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: fill
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- iain
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-25 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Simple DSL for filling (seeding) your database
+email: iain@iain.nl
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- lib/fill.rb
+- lib/fill/configure.rb
+- lib/fill/presenter.rb
+- lib/fill/procedure.rb
+files: 
+- Manifest
+- README.rdoc
+- Rakefile
+- VERSION
+- fill.gemspec
+- lib/fill.rb
+- lib/fill/configure.rb
+- lib/fill/presenter.rb
+- lib/fill/procedure.rb
+- spec/fill_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/iain/fill
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Fill
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "1.2"
+  version: 
+requirements: []
+
+rubyforge_project: fill
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Simple DSL for filling (seeding) your database
+test_files: []
+