amoeba 2.1.0 → 3.0.0

data/lib/amoeba/macros/has_many.rb

@@ -0,0 +1,42 @@
+module Amoeba
+  module Macros
+    class HasMany < ::Amoeba::Macros::Base
+      def follow(relation_name, association)
+        if @cloner.amoeba.clones.include?(relation_name.to_sym)
+          follow_with_clone(relation_name)
+        else
+          follow_without_clone(relation_name, association)
+        end
+      end
+
+      def follow_with_clone(relation_name)
+        # This  is  a  M:M  "has many  through"  where  we
+        # actually copy  and reassociate the  new children
+        # rather than only maintaining the associations
+        @old_object.__send__(relation_name).each do |old_obj|
+          relation_name = remapped_relation_name(relation_name)
+          # associate this new child to the new parent object
+          @new_object.__send__(relation_name) << old_obj.amoeba_dup
+        end
+      end
+
+      def follow_without_clone(relation_name, association)
+        # This is a regular 1:M "has many"
+        #
+        # copying the children of the regular has many will
+        # effectively do what is desired anyway, the through
+        # association is really just for convenience usage
+        # on the model
+        return if association.is_a?(ActiveRecord::Reflection::ThroughReflection)
+
+        @old_object.__send__(relation_name).each do |old_obj|
+          copy_of_obj = old_obj.amoeba_dup(@options)
+          copy_of_obj[:"#{association.foreign_key}"] = nil
+          relation_name = remapped_relation_name(relation_name)
+          # associate this new child to the new parent object
+          @new_object.__send__(relation_name) << copy_of_obj
+        end
+      end
+    end
+  end
+end

data/lib/amoeba/macros/has_one.rb

@@ -0,0 +1,15 @@
+module Amoeba
+  module Macros
+    class HasOne < ::Amoeba::Macros::Base
+      def follow(relation_name, association)
+        return if association.is_a?(::ActiveRecord::Reflection::ThroughReflection)
+        old_obj = @old_object.__send__(relation_name)
+        return unless old_obj
+        copy_of_obj = old_obj.amoeba_dup(@options)
+        copy_of_obj[:"#{association.foreign_key}"] = nil
+        relation_name = remapped_relation_name(relation_name)
+        @new_object.__send__(:"#{relation_name}=", copy_of_obj)
+      end
+    end
+  end
+end

data/lib/amoeba/version.rb

@@ -1,3 +1,3 @@
 module Amoeba
-  VERSION = "2.1.0"
+  VERSION = '3.0.0'
 end

data/spec/lib/amoeba_spec.rb

@@ -1,15 +1,17 @@
-require 'active_record'
 require 'spec_helper'
 
-describe "amoeba" do
-  context "dup" do
-    it "duplicates associated child records" do
+describe 'amoeba' do
+  context 'dup' do
+    before :each do
+      require ::File.dirname(__FILE__) + '/../support/data.rb'
+    end
+    it 'duplicates associated child records' do
       # Posts {{{
-      old_post = Post.find(1)
-      old_post.comments.map(&:contents).include?("I love it!").should be true
+      old_post = ::Post.find(1)
+      expect(old_post.comments.map(&:contents).include?('I love it!')).to be_truthy
 
       old_post.class.amoeba do
-        prepend :contents => "Here's a copy: "
+        prepend contents: "Here's a copy: "
       end
 
       new_post = old_post.amoeba_dup
@@ -28,12 +30,12 @@ describe "amoeba" do
       start_postwidget_count = PostWidget.all.count
       start_superkitten_count = Superkitten.all.count
       rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS tag_count FROM posts_tags')
-      start_posttag_count = rs["tag_count"]
+      start_posttag_count = rs['tag_count']
       rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS note_count FROM notes_posts')
-      start_postnote_count = rs["note_count"]
+      start_postnote_count = rs['note_count']
 
-      new_post.save
-      new_post.errors.messages.length.should == 0
+      expect(new_post.save!).to be_truthy
+      expect(new_post.title).to eq("Copy of #{old_post.title}")
 
       end_account_count = Account.all.count
       end_history_count = History.all.count
@@ -49,140 +51,231 @@ describe "amoeba" do
       end_postwidget_count = PostWidget.all.count
       end_superkitten_count = Superkitten.all.count
       rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS tag_count FROM posts_tags')
-      end_posttag_count = rs["tag_count"]
+      end_posttag_count = rs['tag_count']
       rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS note_count FROM notes_posts')
-      end_postnote_count = rs["note_count"]
-
-      end_tag_count.should         == start_tag_count
-      end_cat_count.should         == start_cat_count
-      end_account_count.should     == start_account_count * 2
-      end_history_count.should     == start_history_count * 2
-      end_supercat_count.should    == start_supercat_count * 2
-      end_post_count.should        == start_post_count * 2
-      end_comment_count.should     == (start_comment_count * 2) + 2
-      end_rating_count.should      == start_rating_count * 2
-      end_postconfig_count.should  == start_postconfig_count * 2
-      end_posttag_count.should     == start_posttag_count * 2
-      end_widget_count.should      == start_widget_count * 2
-      end_postwidget_count.should  == start_postwidget_count * 2
-      end_note_count.should        == start_note_count * 2
-      end_postnote_count.should    == start_postnote_count * 2
-      end_superkitten_count.should == start_superkitten_count * 2
-
-      new_post.supercats.map(&:ramblings).include?("Copy of zomg").should be true
-      new_post.supercats.map(&:other_ramblings).uniq.length.should == 1
-      new_post.supercats.map(&:other_ramblings).uniq.include?("La la la").should be true
-      new_post.title.should == "Copy of #{old_post.title}"
-      new_post.contents.should == "Here's a copy: #{old_post.contents.gsub(/dog/, 'cat')} (copied version)"
-      new_post.comments.length.should == 5
-      new_post.comments.select{ |c| c.nerf == 'ratatat' && c.contents.nil? }.length.should == 1
-      new_post.comments.select{ |c| c.nerf == 'ratatat' }.length.should == 2
-      new_post.comments.select{ |c| c.nerf == 'bonk' }.length.should == 1
-      new_post.comments.select{ |c| c.nerf == 'bonkers' && c.contents.nil? }.length.should == 1
+      end_postnote_count = rs['note_count']
+
+      expect(end_tag_count).to         eq(start_tag_count)
+      expect(end_cat_count).to         eq(start_cat_count)
+      expect(end_account_count).to     eq(start_account_count * 2)
+      expect(end_history_count).to     eq(start_history_count * 2)
+      expect(end_supercat_count).to    eq(start_supercat_count * 2)
+      expect(end_post_count).to        eq(start_post_count * 2)
+      expect(end_comment_count).to     eq((start_comment_count * 2) + 2)
+      expect(end_rating_count).to      eq(start_rating_count * 2)
+      expect(end_postconfig_count).to  eq(start_postconfig_count * 2)
+      expect(end_posttag_count).to     eq(start_posttag_count * 2)
+      expect(end_widget_count).to      eq(start_widget_count * 2)
+      expect(end_postwidget_count).to  eq(start_postwidget_count * 2)
+      expect(end_note_count).to        eq(start_note_count * 2)
+      expect(end_postnote_count).to    eq(start_postnote_count * 2)
+      expect(end_superkitten_count).to eq(start_superkitten_count * 2)
+
+      expect(new_post.supercats.map(&:ramblings).include?('Copy of zomg')).to be true
+      expect(new_post.supercats.map(&:other_ramblings).uniq.length).to eq(1)
+      expect(new_post.supercats.map(&:other_ramblings).uniq.include?('La la la')).to be true
+      expect(new_post.contents).to eq("Here's a copy: #{old_post.contents.gsub(/dog/, 'cat')} (copied version)")
+      expect(new_post.comments.length).to eq(5)
+      expect(new_post.comments.select { |c| c.nerf == 'ratatat' && c.contents.nil? }.length).to eq(1)
+      expect(new_post.comments.select { |c| c.nerf == 'ratatat' }.length).to eq(2)
+      expect(new_post.comments.select { |c| c.nerf == 'bonk' }.length).to eq(1)
+      expect(new_post.comments.select { |c| c.nerf == 'bonkers' && c.contents.nil? }.length).to eq(1)
 
       new_post.widgets.map(&:id).each do |id|
-        old_post.widgets.map(&:id).include?(id).should_not be true
+        expect(old_post.widgets.map(&:id).include?(id)).not_to be true
       end
 
-      new_post.custom_things.length.should == 3
-      new_post.custom_things.select{ |ct| ct.value == [] }.length.should == 1
-      new_post.custom_things.select{ |ct| ct.value == [1,2]}.length.should == 1
-      new_post.custom_things.select{ |ct| ct.value == [78]}.length.should == 1
+      expect(new_post.custom_things.length).to eq(3)
+      expect(new_post.custom_things.select { |ct| ct.value == [] }.length).to eq(1)
+      expect(new_post.custom_things.select { |ct| ct.value == [1, 2] }.length).to eq(1)
+      expect(new_post.custom_things.select { |ct| ct.value == [78] }.length).to eq(1)
       # }}}
       # Author {{{
       old_author = Author.find(1)
       new_author = old_author.amoeba_dup
-      new_author.save
-      new_author.errors.messages.length.should == 0
-      new_author.posts.first.custom_things.length.should == 3
-      new_author.posts.first.custom_things.select{ |ct| ct.value == [] }.length.should == 1
-      new_author.posts.first.custom_things.select{ |ct| ct.value == [1,2]}.length.should == 1
-      new_author.posts.first.custom_things.select{ |ct| ct.value == [78]}.length.should == 1
+      new_author.save!
+      expect(new_author.errors.messages.length).to eq(0)
+      expect(new_author.posts.first.custom_things.length).to eq(3)
+      expect(new_author.posts.first.custom_things.select { |ct| ct.value == [] }.length).to eq(1)
+      expect(new_author.posts.first.custom_things.select { |ct| ct.value == [1, 2] }.length).to eq(1)
+      expect(new_author.posts.first.custom_things.select { |ct| ct.value == [78] }.length).to eq(1)
       # }}}
       # Products {{{
       # Base Class {{{
       old_product = Product.find(1)
 
-      start_image_count = Image.where(:product_id => old_product.id).count
+      start_image_count = Image.where(product_id: old_product.id).count
       start_section_count = Section.all.length
       rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS section_count FROM products_sections WHERE product_id = ?', old_product.id)
-      start_prodsection_count = rs["section_count"]
+      start_prodsection_count = rs['section_count']
 
       new_product = old_product.amoeba_dup
       new_product.save
-      new_product.errors.messages.length.should == 0
+      expect(new_product.errors.messages.length).to eq(0)
 
-      end_image_count = Image.where(:product_id => old_product.id).count
-      end_newimage_count = Image.where(:product_id => new_product.id).count
+      end_image_count = Image.where(product_id: old_product.id).count
+      end_newimage_count = Image.where(product_id: new_product.id).count
       end_section_count = Section.all.length
       rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS section_count FROM products_sections WHERE product_id = ?', 1)
-      end_prodsection_count = rs["section_count"]
+      end_prodsection_count = rs['section_count']
       rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS section_count FROM products_sections WHERE product_id = ?', new_product.id)
-      end_newprodsection_count = rs["section_count"]
+      end_newprodsection_count = rs['section_count']
 
-      end_image_count.should == start_image_count
-      end_newimage_count.should == start_image_count
-      end_section_count.should == start_section_count
-      end_prodsection_count.should == start_prodsection_count
-      end_newprodsection_count.should == start_prodsection_count
+      expect(end_image_count).to eq(start_image_count)
+      expect(end_newimage_count).to eq(start_image_count)
+      expect(end_section_count).to eq(start_section_count)
+      expect(end_prodsection_count).to eq(start_prodsection_count)
+      expect(end_newprodsection_count).to eq(start_prodsection_count)
       # }}}
 
       # Inherited Class {{{
       # Shirt {{{
       old_product = Shirt.find(2)
 
-      start_image_count = Image.where(:product_id => old_product.id).count
+      start_image_count = Image.where(product_id: old_product.id).count
       start_section_count = Section.all.length
       rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS section_count FROM products_sections WHERE product_id = ?', old_product.id)
-      start_prodsection_count = rs["section_count"]
+      start_prodsection_count = rs['section_count']
 
       new_product = old_product.amoeba_dup
       new_product.save
-      new_product.errors.messages.length.should == 0
+      expect(new_product.errors.messages.length).to eq(0)
 
-      end_image_count = Image.where(:product_id => old_product.id).count
-      end_newimage_count = Image.where(:product_id => new_product.id).count
+      end_image_count = Image.where(product_id: old_product.id).count
+      end_newimage_count = Image.where(product_id: new_product.id).count
       end_section_count = Section.all.length
       rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS section_count FROM products_sections WHERE product_id = ?', 1)
-      end_prodsection_count = rs["section_count"]
+      end_prodsection_count = rs['section_count']
       rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS section_count FROM products_sections WHERE product_id = ?', new_product.id)
-      end_newprodsection_count = rs["section_count"]
+      end_newprodsection_count = rs['section_count']
 
-      end_image_count.should == start_image_count
-      end_newimage_count.should == start_image_count
-      end_section_count.should == start_section_count
-      end_prodsection_count.should == start_prodsection_count
-      end_newprodsection_count.should == start_prodsection_count
+      expect(end_image_count).to eq(start_image_count)
+      expect(end_newimage_count).to eq(start_image_count)
+      expect(end_section_count).to eq(start_section_count)
+      expect(end_prodsection_count).to eq(start_prodsection_count)
+      expect(end_newprodsection_count).to eq(start_prodsection_count)
       # }}}
 
       # Necklace {{{
       old_product = Necklace.find(3)
 
-      start_image_count = Image.where(:product_id => old_product.id).count
+      start_image_count = Image.where(product_id: old_product.id).count
       start_section_count = Section.all.length
       rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS section_count FROM products_sections WHERE product_id = ?', old_product.id)
-      start_prodsection_count = rs["section_count"]
+      start_prodsection_count = rs['section_count']
 
       new_product = old_product.amoeba_dup
       new_product.save
-      new_product.errors.messages.length.should == 0
+      expect(new_product.errors.messages.length).to eq(0)
 
-      end_image_count = Image.where(:product_id => old_product.id).count
-      end_newimage_count = Image.where(:product_id => new_product.id).count
+      end_image_count = Image.where(product_id: old_product.id).count
+      end_newimage_count = Image.where(product_id: new_product.id).count
       end_section_count = Section.all.length
       rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS section_count FROM products_sections WHERE product_id = ?', 1)
-      end_prodsection_count = rs["section_count"]
+      end_prodsection_count = rs['section_count']
       rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS section_count FROM products_sections WHERE product_id = ?', new_product.id)
-      end_newprodsection_count = rs["section_count"]
+      end_newprodsection_count = rs['section_count']
 
-      end_image_count.should == start_image_count
-      end_newimage_count.should == start_image_count
-      end_section_count.should == start_section_count
-      end_prodsection_count.should == start_prodsection_count
-      end_newprodsection_count.should == start_prodsection_count
+      expect(end_image_count).to eq(start_image_count)
+      expect(end_newimage_count).to eq(start_image_count)
+      expect(end_section_count).to eq(start_section_count)
+      expect(end_prodsection_count).to eq(start_prodsection_count)
+      expect(end_newprodsection_count).to eq(start_prodsection_count)
       # }}}
       # }}}
       # }}}
     end
   end
+  context 'override' do
+    before :each do
+      ::Image.fresh_amoeba
+      ::Image.amoeba do
+        override ->(old, new) {
+          if old.filename == 'test.jpg'
+            new.product_id = 13
+          end
+        }
+      end
+    end
+    it 'should override fields' do
+      image = ::Image.create(filename: 'test.jpg', product_id: 12)
+      image_dup = image.amoeba_dup
+      expect(image_dup.save).to be_truthy
+      expect(image_dup.product_id).to eq(13)
+    end
+    it 'should not override fields' do
+      image = ::Image.create(filename: 'test2.jpg', product_id: 12)
+      image_dup = image.amoeba_dup
+      expect(image_dup.save).to be_truthy
+      expect(image_dup.product_id).to eq(12)
+    end
+  end
+
+  context 'nullify' do
+    before :each do
+      ::Image.fresh_amoeba
+      ::Image.amoeba do
+        nullify :product_id
+      end
+    end
+    it 'should nullify fields' do
+      image = ::Image.create(filename: 'test.jpg', product_id: 12)
+      image_dup = image.amoeba_dup
+      expect(image_dup.save).to be_truthy
+      expect(image_dup.product_id).to be_nil
+    end
+  end
+
+  context 'strict propagate' do
+    it 'should call #fresh_amoeba' do
+      expect(::SuperBlackBox).to receive(:fresh_amoeba).and_call_original
+      box = ::SuperBlackBox.create(title: 'Super Black Box', price: 9.99, length: 1, metal: '1')
+      new_box = box.amoeba_dup
+      expect(new_box.save).to be_truthy
+    end
+  end
+
+  context 'remapping and custom dup method' do
+    let(:prototype) { ObjectPrototype.new }
+    context 'through' do
+      it do
+        real_object = prototype.amoeba_dup
+        expect(real_object).to be_a(::RealObject)
+      end
+    end
+    context 'remapper' do
+      it do
+        prototype.subobject_prototypes << SubobjectPrototype.new
+        real_object = prototype.amoeba_dup
+        expect(real_object.subobjects.length).to eq(1)
+      end
+    end
+  end
+
+  context 'preprocessing fields' do
+    it 'should accept "set" to set false to attribute' do
+      super_admin = ::SuperAdmin.create!(email: 'user@example.com', active: true, password: 'password')
+      clone = super_admin.amoeba_dup
+      expect(clone.active).to eq(false)
+    end
+    it 'should skip "prepend" if it equal to false' do
+      super_admin = ::SuperAdmin.create!(email: 'user2@example.com', active: true, password: 'password')
+      clone = super_admin.amoeba_dup
+      expect(clone.password).to eq('password')
+    end
+  end
+
+  context 'inheritance' do
+    it 'does not fail with a deep inheritance' do
+      box = Box.create
+      sub_sub_product = BoxSubSubProduct.create(title: 'Awesome shoes')
+      another_product = BoxAnotherProduct.create(title: 'Cleaning product')
+      sub_sub_product.box = box
+      sub_sub_product.another_product = another_product
+      sub_sub_product.save
+      expect(box.sub_products.first.another_product.title).to eq('Cleaning product')
+      expect(box.amoeba_dup.sub_products.first.another_product.title).to eq('Cleaning product')
+    end
+  end
+
 end

data/spec/spec_helper.rb

@@ -1,10 +1,29 @@
+require 'simplecov'
 require 'coveralls'
-Coveralls.wear!
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start do
+  add_filter 'spec'
+  minimum_coverage(76)
+end
+require 'active_record'
 require 'amoeba'
 
-ActiveRecord::Base.establish_connection(:adapter => "sqlite3",
-                                       :database => File.dirname(__FILE__) + "/test.sqlite3")
+adapter = if defined?(JRuby)
+            require 'activerecord-jdbcsqlite3-adapter'
+            'jdbcsqlite3'
+          else
+            require 'sqlite3'
+            'sqlite3'
+          end
+
+ActiveRecord::Base.establish_connection(adapter: adapter, database: ':memory:')
+
+::RSpec.configure do |config|
+  config.order = :default
+end
 
 load File.dirname(__FILE__) + '/support/schema.rb'
 load File.dirname(__FILE__) + '/support/models.rb'
-load File.dirname(__FILE__) + '/support/data.rb'

data/spec/support/data.rb

@@ -1,110 +1,110 @@
-u1 = User.create(:name => "Robert Johnson", :email => "bob@crossroads.com")
-u2 = User.create(:name => "Miles Davis", :email => "miles@kindofblue.com")
+u1 = User.create(name: 'Robert Johnson', email: 'bob@crossroads.com')
+u2 = User.create(name: 'Miles Davis', email: 'miles@kindofblue.com')
 
-a1 = Author.create(:full_name => "Kermit The Vonnegut", :nickname => "kvsoitgoes")
-a2 = Author.create(:full_name => "Arthur Sees Clarck", :nickname => "strangewater")
+a1 = Author.create(full_name: 'Kermit The Vonnegut', nickname: 'kvsoitgoes')
+a2 = Author.create(full_name: 'Arthur Sees Clarck', nickname: 'strangewater')
 
-t = Topic.create(:title => "Ponies", :description => "Lets talk about my ponies.")
+t = Topic.create(title: 'Ponies', description: 'Lets talk about my ponies.')
 
 # First Post {{{
-p1 = t.posts.create(:owner => u1, :author => a1, :title => "My little pony", :contents => "Lorum ipsum dolor rainbow bright. I like dogs, dogs are awesome.")
-f1 = p1.create_post_config(:is_visible => true, :is_open => false, :password => 'abcdefg123')
-a1 = p1.create_account(:title => "Foo")
-h1 = p1.account.create_history(:some_stuff => "Bar")
-c1 = p1.comments.create(:contents => "I love it!", :nerf => "ratatat")
-c1.ratings.create(:num_stars => 5)
-c1.ratings.create(:num_stars => 5)
-c1.ratings.create(:num_stars => 4)
-c1.ratings.create(:num_stars => 3)
-c1.ratings.create(:num_stars => 5)
-c1.ratings.create(:num_stars => 5)
-
-c2 = p1.comments.create(:contents => "I hate it!", :nerf => "whapaow")
-c2.ratings.create(:num_stars => 3)
-c2.ratings.create(:num_stars => 1)
-c2.ratings.create(:num_stars => 4)
-c2.ratings.create(:num_stars => 1)
-c2.ratings.create(:num_stars => 1)
-c2.ratings.create(:num_stars => 2)
-
-c3 = p1.comments.create(:contents => "kthxbbq!!11!!!1!eleven!!", :nerf => "bonk")
-c3.ratings.create(:num_stars => 0)
-c3.ratings.create(:num_stars => 0)
-c3.ratings.create(:num_stars => 1)
-c3.ratings.create(:num_stars => 2)
-c3.ratings.create(:num_stars => 1)
-c3.ratings.create(:num_stars => 0)
-
-t1 = Tag.create(:value => "funny")
-t2 = Tag.create(:value => "wtf")
-t3 = Tag.create(:value => "cats")
+p1 = t.posts.create(owner: u1, author: a1, title: 'My little pony', contents: 'Lorum ipsum dolor rainbow bright. I like dogs, dogs are awesome.')
+f1 = p1.create_post_config(is_visible: true, is_open: false, password: 'abcdefg123')
+a1 = p1.create_account(title: 'Foo')
+h1 = p1.account.create_history(some_stuff: 'Bar')
+c1 = p1.comments.create(contents: 'I love it!', nerf: 'ratatat')
+c1.ratings.create(num_stars: 5)
+c1.ratings.create(num_stars: 5)
+c1.ratings.create(num_stars: 4)
+c1.ratings.create(num_stars: 3)
+c1.ratings.create(num_stars: 5)
+c1.ratings.create(num_stars: 5)
+
+c2 = p1.comments.create(contents: 'I hate it!', nerf: 'whapaow')
+c2.ratings.create(num_stars: 3)
+c2.ratings.create(num_stars: 1)
+c2.ratings.create(num_stars: 4)
+c2.ratings.create(num_stars: 1)
+c2.ratings.create(num_stars: 1)
+c2.ratings.create(num_stars: 2)
+
+c3 = p1.comments.create(contents: 'kthxbbq!!11!!!1!eleven!!', nerf: 'bonk')
+c3.ratings.create(num_stars: 0)
+c3.ratings.create(num_stars: 0)
+c3.ratings.create(num_stars: 1)
+c3.ratings.create(num_stars: 2)
+c3.ratings.create(num_stars: 1)
+c3.ratings.create(num_stars: 0)
+
+t1 = Tag.create(value: 'funny')
+t2 = Tag.create(value: 'wtf')
+t3 = Tag.create(value: 'cats')
 
 p1.tags << t1
 p1.tags << t2
 p1.tags << t3
 p1.save
 
-w1 = Widget.create(:value => "My Sidebar")
-w2 = Widget.create(:value => "Photo Gallery")
-w3 = Widget.create(:value => "Share & Like")
+w1 = Widget.create(value: 'My Sidebar')
+w2 = Widget.create(value: 'Photo Gallery')
+w3 = Widget.create(value: 'Share & Like')
 
 p1.widgets << w1
 p1.widgets << w2
 p1.widgets << w3
 p1.save
 
-n1 = Note.create(:value => "This is important")
-n2 = Note.create(:value => "You've been warned")
-n3 = Note.create(:value => "Don't forget")
+n1 = Note.create(value: 'This is important')
+n2 = Note.create(value: "You've been warned")
+n3 = Note.create(value: "Don't forget")
 
 p1.notes << n1
 p1.notes << n2
 p1.notes << n3
 p1.save
 
-c1 = Category.create(:title => "Umbrellas", :description => "Clown fart")
-c2 = Category.create(:title => "Widgets", :description => "Humpty dumpty")
-c3 = Category.create(:title => "Wombats", :description => "Slushy mushy")
+c1 = Category.create(title: 'Umbrellas', description: 'Clown fart')
+c2 = Category.create(title: 'Widgets', description: 'Humpty dumpty')
+c3 = Category.create(title: 'Wombats', description: 'Slushy mushy')
 
-s1 = Supercat.create(:post => p1, :category => c1, :ramblings => "zomg", :other_ramblings => "nerp")
-s2 = Supercat.create(:post => p1, :category => c2, :ramblings => "why", :other_ramblings => "narp")
-s3 = Supercat.create(:post => p1, :category => c3, :ramblings => "ohnoes", :other_ramblings => "blap")
+s1 = Supercat.create(post: p1, category: c1, ramblings: 'zomg', other_ramblings: 'nerp')
+s2 = Supercat.create(post: p1, category: c2, ramblings: 'why', other_ramblings: 'narp')
+s3 = Supercat.create(post: p1, category: c3, ramblings: 'ohnoes', other_ramblings: 'blap')
 
-s1.superkittens.create(:value => "Fluffy")
-s1.superkittens.create(:value => "Buffy")
-s1.superkittens.create(:value => "Fuzzy")
+s1.superkittens.create(value: 'Fluffy')
+s1.superkittens.create(value: 'Buffy')
+s1.superkittens.create(value: 'Fuzzy')
 
-s2.superkittens.create(:value => "Hairball")
-s2.superkittens.create(:value => "Crosseye")
-s2.superkittens.create(:value => "Spot")
+s2.superkittens.create(value: 'Hairball')
+s2.superkittens.create(value: 'Crosseye')
+s2.superkittens.create(value: 'Spot')
 
-s3.superkittens.create(:value => "Dopey")
-s3.superkittens.create(:value => "Sneezy")
-s3.superkittens.create(:value => "Sleepy")
+s3.superkittens.create(value: 'Dopey')
+s3.superkittens.create(value: 'Sneezy')
+s3.superkittens.create(value: 'Sleepy')
 
-p1.custom_things.create([{:value => [1,2]}, {:value => []}, {:value => [78]}])
+p1.custom_things.create([{ value: [1, 2] }, { value: [] }, { value: [78] }])
 # }}}
 
 # Product {{{
-product1 = Product.create(:title => "Sticky Notes 5-Pak", :price => 5.99, :weight => 0.56)
-shirt1 = Shirt.create(:title => "Fancy Shirt", :price => 48.95, :sleeve => 32, :collar => 15.5)
-necklace1 = Necklace.create(:title => "Pearl Necklace", :price => 2995.99, :length => 18, :metal => "14k")
+product1 = Product.create(title: 'Sticky Notes 5-Pak', price: 5.99, weight: 0.56)
+shirt1 = Shirt.create(title: 'Fancy Shirt', price: 48.95, sleeve: 32, collar: 15.5)
+necklace1 = Necklace.create(title: 'Pearl Necklace', price: 2995.99, length: 18, metal: '14k')
 
-img1 = product1.images.create(:filename => "sticky.jpg")
-img2 = product1.images.create(:filename => "notes.jpg")
+img1 = product1.images.create(filename: 'sticky.jpg')
+img2 = product1.images.create(filename: 'notes.jpg')
 
-img1 = shirt1.images.create(:filename => "02948u31.jpg")
-img2 = shirt1.images.create(:filename => "zsif8327.jpg")
+img1 = shirt1.images.create(filename: '02948u31.jpg')
+img2 = shirt1.images.create(filename: 'zsif8327.jpg')
 
-img1 = necklace1.images.create(:filename => "ae02x9f1.jpg")
-img2 = necklace1.images.create(:filename => "cba9f912.jpg")
+img1 = necklace1.images.create(filename: 'ae02x9f1.jpg')
+img2 = necklace1.images.create(filename: 'cba9f912.jpg')
 
-office = Section.create(:name => "Office", :num_employees => 2, :total_sales => "1234.56")
-supplies = Section.create(:name => "Supplies", :num_employees => 1, :total_sales => "543.21")
-mens = Section.create(:name => "Mens", :num_employees => 3, :total_sales => "11982.63")
-apparel = Section.create(:name => "Apparel", :num_employees => 5, :total_sales => "1315.20")
-accessories = Section.create(:name => "Accessories", :num_employees => 1, :total_sales => "8992.34")
-jewelry = Section.create(:name => "Jewelry", :num_employees => 3, :total_sales => "25481.77")
+office = Section.create(name: 'Office', num_employees: 2, total_sales: '1234.56')
+supplies = Section.create(name: 'Supplies', num_employees: 1, total_sales: '543.21')
+mens = Section.create(name: 'Mens', num_employees: 3, total_sales: '11982.63')
+apparel = Section.create(name: 'Apparel', num_employees: 5, total_sales: '1315.20')
+accessories = Section.create(name: 'Accessories', num_employees: 1, total_sales: '8992.34')
+jewelry = Section.create(name: 'Jewelry', num_employees: 3, total_sales: '25481.77')
 
 product1.sections << office
 product1.sections << supplies