squares 0.2.9 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ccabaf667507b7c385bb90a3d678c52efe24a46
-  data.tar.gz: 26050ec6702c082cbf7f6dc2fe3e14fccefb669c
+  metadata.gz: 5881a376cfce79ade243a19dfa8f3a9b112d46e6
+  data.tar.gz: 8530ebccc40ed950e0b1298d524d6e57da969149
 SHA512:
-  metadata.gz: b19a525035738a4c114fb53c2ea848ec30e3fcce50dea155e120768f32e5003b2421e8f697e20c6171e1d3cc58e331429171f7a1a4e89b64c9d249fc116bd87c
-  data.tar.gz: ba24c3380162919427a2b40a302741047851fff7cea759cdb57776e221897179d2fbc0185b75bc8a2d61183b8fd64b01d08f862d77e1d98a8f0ad1fbc2cbaece
+  metadata.gz: a16c5788667935c396834e0bac628ffee25259472e2a62025d19b38e6838bdfc0e7c047892ecb3e2a90a94f339d66b99dc18c4aa45dce6297b0e4226f1d43600
+  data.tar.gz: a02e43ca8c0141b600c4a2c3840b5ce3d0960b0797226385d4b30f2e7c76d17865436021151bc8aefc53ed4b1a727523be02be857c3d1596ae6a327b4efa7103

data/lib/squares/base.rb

@@ -4,17 +4,50 @@ module Squares
 
     def initialize *args
       apply *args
+      trigger :after_initialize
     end
 
     def save
-      store[@id] = Marshal.dump self
+      trigger :before_save
+      @_changed = false
+      store[@id] = Marshal.dump self.dup
+      trigger :after_save
       nil
     end
 
+    def delete
+      self.class.delete self.id
+    end
+
+    def destroy
+      trigger :before_destroy
+      delete
+    end
+
     def == other
       @id == other.id && properties_equal(other)
     end
 
+    def [](key)
+      get_property key
+    end
+
+    def []=(key, value)
+      set_property key, value
+    end
+
+    def update_properties new_properties
+      new_properties.each do |key, value|
+        self[key] = value if valid_property?(key)
+      end
+      save
+    end
+    alias_method :update_attributes, :update_properties
+
+    def changed?
+      @_changed
+    end
+
     def properties
       self.class.properties
     end
@@ -27,8 +60,28 @@ module Squares
       h
     end
 
+    def valid_property? property
+      self.class.valid_property? property
+    end
+
+    def defaults
+      self.class.defaults
+    end
+
     private
 
+    def trigger hook_name
+      return if @hook_callback_in_progress
+      hooks = self.class.hooks
+      if hooks && hooks[hook_name]
+        hooks[hook_name].each do |hook|
+          @hook_callback_in_progress = true
+          self.instance_eval &hook
+          @hook_callback_in_progress = false
+        end
+      end
+    end
+
     def properties_equal other
       ! properties.detect do |property|
         self.send(property) != other.send(property)
@@ -37,15 +90,47 @@ module Squares
 
     def apply *args
       @id, values = *args
-      value_hash = values.to_h
-      self.class.properties.each do |property|
-        value = value_hash.has_key?(property) ? value_hash[property] : default_for(property)
-        self.send "#{property.to_s.gsub(/\?$/,'')}=".to_sym, value
+      values_hash = values.to_h
+      properties_sorted_by_defaults.each do |property|
+        value = values_hash.has_key?(property) ? values_hash[property] : default_for(property)
+        set_property property, value
+      end
+    end
+
+    def properties_sorted_by_defaults
+      (properties || []).sort do |a,b|
+        a_val = defaults[a].respond_to?(:call) ? 1 : 0
+        b_val = defaults[b].respond_to?(:call) ? 1 : 0
+        a_val <=> b_val
       end
     end
 
     def default_for property
-      self.class.defaults[property]
+      defaults[property].respond_to?(:call) ?
+        defaults[property].call(self) :
+        defaults[property]
+    end
+
+    def get_property property
+      instance_variable_get "@#{instance_var_string_for property}"
+    end
+
+    def set_property property, value
+      unless valid_property?(property)
+        raise ArgumentError.new("\"#{property}\" is not a valid property of #{self.class}")
+      end
+      instance_variable_set("@#{instance_var_string_for property}", value).tap do |value|
+        @_changed = true
+      end
+    end
+
+    def instance_var_string_for property
+      property = self.class.normalize_property property
+      if property.to_s.match(/\?$/)
+        "#{property.to_s.gsub(/\?$/,'')}__question__".to_sym
+      else
+        property
+      end
     end
 
     def store
@@ -58,7 +143,9 @@ module Squares
 
       def [] id
         if item = store[id]
-          Marshal.restore item
+          Marshal.restore(item).tap do |item|
+            item.instance_eval 'trigger :after_find'
+          end
         end
       end
       alias_method :find, :[]
@@ -75,7 +162,11 @@ module Squares
           something which responds to #to_h"
           ERR
         end
-        instance.tap { |i| i.save }
+        instance.tap do |i|
+          i.instance_eval 'trigger :before_create'
+          i.save
+          i.instance_eval 'trigger :after_create'
+        end
       end
       alias_method :create, :[]=
 
@@ -94,6 +185,17 @@ module Squares
         store.values.map{ |i| Marshal.restore i }
       end
 
+      def valid_property? property
+        !!normalize_property(property)
+      end
+
+      def normalize_property property
+        unless properties.include?(property)
+          property = "#{property}?".to_sym if properties.include?("#{property}?".to_sym)
+        end
+        properties.include?(property) && property
+      end
+
       def delete id
         store.delete id
       end
@@ -101,24 +203,46 @@ module Squares
       def each &block
         values.each &block
       end
-      alias_method :where, :select
 
-      def property prop, opts
+      def where(*args, &block)
+        result_set = []
+        if block
+          result_set = values.select(&block)
+          return result_set if result_set.empty?
+        end
+
+        args.each do |arg|
+          if arg.kind_of?(Hash)
+            result_set = (!result_set.empty? ? result_set : values).reject do |i|
+              failed_matches = 0
+              arg.each do |k,v|
+                raise ArgumentError.new("\"#{k}\" is not a valid property of #{self}") unless valid_property?(k)
+                failed_matches += 1 unless i[k] == v
+              end
+              failed_matches > 0
+            end
+          elsif arg.kind_of?(Symbol)
+            raise ArgumentError.new("\"#{arg}\" is not a valid property of #{self}") unless valid_property?(arg)
+            result_set = (result_set.empty? ? values : result_set).select do |i|
+              i[arg]
+            end
+          end
+        end
+        result_set
+      end
+
+      def property prop, opts={}
         @_properties ||= []
         @_properties << prop
         uniquify_properties
-        if prop.to_s.match(/\?$/)
-          define_method prop do
-            instance_variable_get "@#{self.class.instance_var_for prop}"
-          end
-          define_method prop.to_s.gsub(/\?$/, '=') do |v|
-            instance_variable_set "@#{self.class.instance_var_for prop}", v
-          end
-        else
-          attr_accessor prop
+        define_method prop do
+          get_property prop
         end
-        if default = opts[:default]
-          defaults[prop] = default
+        define_method "#{prop.to_s.gsub(/\?$/, '')}=" do |v|
+          set_property prop, v
+        end
+        if opts.has_key?(:default)
+          defaults[prop] = opts[:default]
         end
       end
 
@@ -148,20 +272,53 @@ module Squares
         @store ||= {}
       end
 
-      def instance_var_for property
-        if property.to_s.match(/\?$/)
-          "#{property.to_s.gsub(/\?$/,'')}__question__".to_sym
-        else
-          property
-        end
-      end
-
       def models
         @_models.uniq.sort { |a,b| a.to_s <=> b.to_s }
       end
 
+      ### hooks
+      def hooks
+        @_hooks
+      end
+
+      def before_create *args, &block
+        add_hook :before_create, args, block
+      end
+
+      def after_create *args, &block
+        add_hook :after_create, args, block
+      end
+
+      def after_initialize *args, &block
+        add_hook :after_initialize, args, block
+      end
+
+      def after_find *args, &block
+        add_hook :after_find, args, block
+      end
+
+      def before_save *args, &block
+        add_hook :before_save, args, block
+      end
+
+      def after_save *args, &block
+        add_hook :after_save, args, block
+      end
+
+      def before_destroy *args, &block
+        add_hook :before_destroy, args, block
+      end
+
+      ### /hooks
+
       private
 
+      def add_hook hook_id, args, block
+        @_hooks ||= {}
+        @_hooks[hook_id] ||= []
+        @_hooks[hook_id] << block
+      end
+
       def uniquify_properties
         @_properties = @_properties.uniq.compact
       end

data/lib/squares/version.rb

@@ -1,3 +1,3 @@
 module Squares
-  VERSION = "0.2.9"
+  VERSION = "0.3.0"
 end

data/spec/squares/base_spec.rb

@@ -4,11 +4,15 @@ require 'squares/base'
 module Marvel
   class SuperHero < Squares::Base
     properties :real_name, :special_powers
+    property :caped?, default: false
   end
   class Villain < Squares::Base
     properties :vehicle, :lair
     property :really_evil?, default: true
   end
+  class Sidekick < Squares::Base
+    property :catch_phrase
+  end
 end
 
 module Squares
@@ -22,7 +26,7 @@ module Squares
     Given(:powers)     { ['super strength', 'strategy', 'leadership'] }
     When(:hero)        { test_class.new id, real_name: name, special_powers: powers }
 
-    describe 'class' do
+    describe 'class methods' do
 
       describe '.underscore_name' do
         Then { test_class.underscore_name == 'marvel/super_hero' }
@@ -35,22 +39,22 @@ module Squares
       end
 
       describe '.properties' do
-        Then { test_class.properties == [:real_name, :special_powers] }
+        Then { test_class.properties == [:real_name, :special_powers, :caped?] }
       end
 
-      describe '.use_storage' do
+      describe '.storage' do
         Given(:storage) { {attack: :fwoosh } }
         When            { test_class.store = storage }
         Then            { test_class.store == storage }
       end
 
-      describe '.models lists defined models (inheritors)' do
+      describe '.models lists defined models (inheritors, sorted alphabetically)' do
         When(:result) { described_class.models }
-        Then { result == [ Marvel::SuperHero, Marvel::Villain ] }
+        Then { result == [ Marvel::Sidekick, Marvel::SuperHero, Marvel::Villain ] }
       end
 
       describe '.[]' do
-        Given { storage[id] = Marshal.dump hero }
+        Given                 { storage[id] = Marshal.dump hero }
         When(:recovered_hero) { Marvel::SuperHero['Captain America'] }
         Then                  { recovered_hero.class     == Marvel::SuperHero }
         Then                  { recovered_hero.id        == 'Captain America' }
@@ -103,7 +107,7 @@ module Squares
         Then  { expect(test_class).to be_includes(id) }
       end
 
-      describe 'more cool stuff' do
+      describe 'enumerable collections' do
         Given do
           Marvel::SuperHero['Superman'] = { real_name: 'Clark Kent',   special_powers: ['flying'] }
           Marvel::SuperHero['Hulk']     = { real_name: 'Bruce Banner', special_powers: ['smash'] }
@@ -111,8 +115,48 @@ module Squares
         end
 
         describe '.where' do
-          When(:result) { Marvel::SuperHero.where { |h| h.real_name =~ /^Bruce/ } }
-          Then { result.count == 2 }
+          describe 'accepts a block of code (essentailly like .select)' do
+            When(:result) { Marvel::SuperHero.where { |h| h.real_name =~ /^Bruce/ } }
+            Then { result.count == 2 }
+          end
+
+          describe 'accepts a hash' do
+            When(:result) { Marvel::SuperHero.where( real_name: 'Clark Kent' ) }
+            Then { result.count == 1 }
+          end
+
+          describe 'accepts a symbol' do
+            Given { Marvel::SuperHero['The Sponge'] = { special_powers: ['soaking'] } }
+            Then  { Marvel::SuperHero.where( :special_powers ).count == 4 }
+            Then  { Marvel::SuperHero.where( :real_name ).count == 3 }
+          end
+
+          describe 'accepts boolean symbols' do
+            Given do
+              %w[ Superman Batman ].each do |h|
+                hero = Marvel::SuperHero.find h
+                hero.caped = true
+                hero.save
+              end
+            end
+            Then { Marvel::SuperHero.where(:caped?).count == 2 }
+            Then { Marvel::SuperHero.where(:caped).count == 2 }
+          end
+
+          describe 'accepts both block and args' do
+            Given do
+              Marvel::SuperHero.find('Superman').tap do |superman|
+                superman.special_powers = ['smash']
+              end.save
+            end
+            When(:result) { Marvel::SuperHero.where(special_powers: ['smash']) { |h| h.real_name =~ /^Bruce/ } }
+            Then { result.count == 1 }
+          end
+
+          context 'with invalid properties as arguments' do
+            Given(:bogus_hash) { { bogus: 'hash' } }
+            Then { expect{Marvel::SuperHero.where(bogus_hash)}.to raise_error(ArgumentError) }
+          end
         end
 
         describe 'models are enumerable!' do
@@ -121,15 +165,29 @@ module Squares
         end
       end
 
-    end
+    end # class methods
 
-    describe 'instances' do
+    describe 'instance methods' do
       describe '#{{property}}' do
         Then { hero.id             == id }
         Then { hero.real_name      == name }
         Then { hero.special_powers == powers }
       end
 
+      describe '#{{boolean}}?' do
+        When(:villain) { Marvel::Villain.new 'Lizard Man', really_evil?: false }
+        describe 'has an accessor (ends with "?")' do
+          Then { expect(villain).to respond_to(:really_evil?) }
+          Then { expect(villain).to_not be_really_evil }
+        end
+
+        describe 'also has a setter (ends with "=")' do
+          Then { expect(villain).to respond_to(:really_evil=) }
+          When { villain.really_evil = true }
+          Then { expect(villain).to be_really_evil }
+        end
+      end
+
       describe '#save' do
         When { hero.save }
         When(:frozen_hero) { Marshal.restore storage.values.first }
@@ -138,16 +196,22 @@ module Squares
         Then { frozen_hero.class     == Marvel::SuperHero }
       end
 
+      describe '#delete' do
+        Given(:villain) { Marvel::Villain.create 'Lizard Man', lair: 'lab' }
+        When { villain.delete }
+        Then { expect(Marvel::Villain[villain.id]).to be_nil }
+      end
+
       describe '#to_h' do
         Given(:hero1) { test_class.new id, real_name: name, special_powers: powers }
         context 'default key name' do
-          Given(:expected_hash) { { id: id, real_name: name, special_powers: powers } }
+          Given(:expected_hash) { { id: id, real_name: name, special_powers: powers, caped?: false } }
           When(:result) { hero1.to_h }
           Then { expect(result).to eq(expected_hash) }
         end
 
         context 'custom key name' do
-          Given(:expected_hash) { { hero: id, real_name: name, special_powers: powers } }
+          Given(:expected_hash) { { hero: id, real_name: name, special_powers: powers, caped?: false } }
           When(:result) { hero1.to_h(:hero) }
           Then { expect(result).to eq(expected_hash) }
         end
@@ -167,34 +231,253 @@ module Squares
         end
       end
 
-      describe 'default values' do
-        Given do
-          class Marvel::SuperHero < Squares::Base
-            property :hair_color, default: 'black'
+      describe '#[]' do
+        context 'valid key' do
+          Then { expect(hero[:real_name]).to eq(name) }
+        end
+
+        context 'key which is not a property' do
+          Then { expect(hero[:insurance_company]).to be_nil }
+        end
+
+        context 'boolean properties' do
+          When(:villain) { Marvel::Villain.new 'Lizard Man', really_evil?: true }
+          Then { expect(villain[:really_evil?]).to eq(true) }
+          Then { expect(villain[:really_evil]).to eq(true) }
+        end
+      end
+
+      describe '#[]=' do
+        context 'valid property' do
+          When { hero[:real_name] = 'Bruce Banner' }
+          Then { expect(hero.real_name).to eq('Bruce Banner') }
+        end
+
+        context 'key which is not a property' do
+          Then { expect { hero[:ip_address] = '127.0.0.1' }.to raise_error(ArgumentError) }
+        end
+
+        context 'boolean properties' do
+          When(:villain) { Marvel::Villain.new 'Lizard Man', really_evil?: false }
+
+          describe 'can be set using the symbol ending in "?"' do
+            When { villain[:really_evil?] = true }
+            Then { expect(villain).to be_really_evil }
+          end
+
+          describe 'can also be set using the variant without the "?"' do
+            When { villain[:really_evil] = true }
+            Then { expect(villain).to be_really_evil }
+          end
+        end
+      end
+
+      describe '#update_properties' do
+        Given(:villain) { Marvel::Villain.create 'Dr. Doom', vehicle: 'jet', lair: 'Latveria', really_evil?: false }
+        Given(:new_properties) { { vehicle: 'train', hairstyle: 'bald' } }
+        When { villain.update_properties new_properties }
+
+        describe 'un-updated properties stay the same' do
+          Then { expect(villain.lair).to eq('Latveria') }
+        end
+
+        describe 'updated properties are changed' do
+          Then { expect(villain.vehicle).to eq('train') }
+        end
+
+        describe 'invalid properties do nothing' do
+          Then { expect(villain.instance_variable_get("@hairstyle")).to be_nil }
+        end
+
+        describe 'boolean properties' do
+          context 'where key ends in "?"' do
+            Given { new_properties[:really_evil?] = true }
+            Then  { expect(villain).to be_really_evil }
+          end
+          context 'where key does not end with "?"' do
+            Given { new_properties[:really_evil] = true }
+            Then  { expect(villain).to be_really_evil }
           end
         end
-        When(:hero) { test_class.new id, real_name: name }
-        Then { hero.special_powers == nil }
-        Then { hero.hair_color == 'black' }
-        Then { Marvel::SuperHero.defaults == { hair_color: 'black' } }
+
+        describe 'writes changes to the data store' do
+          Then { expect(Marvel::Villain.find('Dr. Doom').vehicle).to eq('train') }
+        end
+      end
+
+      describe '#changed?' do
+        Given(:hero) { test_class.new id, real_name: name, special_powers: powers }
+        context 'new, unsaved' do
+          Then { expect(hero).to be_changed }
+        end
+        context 'after save' do
+          When { hero.save }
+          Then { expect(hero).to_not be_changed }
+        end
+        context 'freshly retrieved from storage' do
+          Given { hero.save }
+          When(:found_hero) { test_class.find id }
+          Then { expect(found_hero).to_not be_changed }
+        end
+        context 'unchanged, but then modified' do
+          Given { hero.save }
+          When  { hero.real_name = 'Fred Flintstone' }
+          Then  { expect(hero).to be_changed }
+        end
+        context 'after create' do
+          Given(:made_hero) { test_class.create 'Iron Man', real_name: 'Tony Stark', special_powers: ['snark'] }
+          Then { expect(made_hero).to_not be_changed }
+        end
       end
 
+      describe 'default values' do
+        context 'as a simple value' do
+          Given do
+            class Marvel::SuperHero < Squares::Base
+              property :hair_color, default: 'black'
+            end
+          end
+          When(:hero) { test_class.new id, real_name: name }
+
+          Then { hero.special_powers == nil }
+          Then { hero.hair_color == 'black' }
+          Then { Marvel::SuperHero.defaults == { caped?: false, hair_color: 'black' } }
+        end
+
+        context 'as a callback' do
+          Given do
+            class Marvel::SuperHero < Squares::Base
+              property :hungry?, default: lambda{ |i| i.earthling? && i.body_mass > 150 }
+              property :body_mass, default: 160
+              property :earthling?, default: true
+            end
+          end
+          Given(:the_fly)   { test_class.new 'The Fly', body_mass: 110 }
+          Given(:manhunter) { test_class.new 'Manhunter', earthling?: false }
+          Given(:colossus)  { test_class.new 'Colossus', body_mass: 350 }
+          Then { expect(the_fly).to_not be_hungry }
+          Then { expect(manhunter).to_not be_hungry }
+          Then { expect(colossus).to be_hungry }
+        end
+
+      end
     end
 
-    describe "models' properties don't bleed into each other" do
+    describe 'instance properties' do
       When(:villain) { Marvel::Villain.new 'Dr. Octopus', vehicle: 'jets', lair: 'abandonned sewer' }
-      Then { villain.class              == Marvel::Villain }
-      Then { Marvel::Villain.properties == [:vehicle, :lair, :really_evil?] }
-      Then { villain.properties         == [:vehicle, :lair, :really_evil?] }
-      Then { expect(villain).to_not respond_to(:hair_color) }
-      Then { expect(villain).to respond_to(:really_evil?) }
-      Then { expect(villain).to respond_to(:really_evil=) }
-      Then { expect(villain).to be_really_evil }
-    end
 
-    describe 'question? properties' do
-      When(:villain) { Marvel::Villain.new 'Lizard Man', really_evil?: false }
-      Then { expect(villain).to_not be_really_evil }
+      describe "are the same as the Model's properties" do
+        Then { villain.properties == Marvel::Villain.properties }
+      end
+
+      describe "don't bleed into other types" do
+        Then { expect(villain).to_not respond_to(:real_name) }
+      end
     end
+
+    describe 'hooks' do
+      Given(:hook_spy) { double }
+      Given { expect(hook_spy).to receive(hook) }
+      Given { allow_any_instance_of(Marvel::Sidekick).to receive(:spy).and_return(hook_spy) }
+      Given { Marvel::Sidekick.instance_variable_set "@_hooks", nil }
+
+      describe '.before_create' do
+        Given(:hook) { :before_create }
+        Given do
+          class Marvel::Sidekick < Squares::Base
+            before_create { spy.before_create }
+          end
+        end
+        When { Marvel::Sidekick.create 'Robin', catch_phrase: 'Holy _, Batman!' }
+        Then { 'hooked' }
+      end
+
+      describe '.after_create' do
+        Given(:hook) { :after_create }
+        Given do
+          class Marvel::Sidekick < Squares::Base
+            after_create { spy.after_create }
+          end
+        end
+        When { Marvel::Sidekick.create 'Robin', catch_phrase: 'Holy _, Batman!' }
+        Then { 'hooked' }
+      end
+
+      describe '.after_initialize' do
+        Given(:hook) { :after_initialize }
+        Given do
+          class Marvel::Sidekick < Squares::Base
+            after_initialize { spy.after_initialize }
+          end
+        end
+        When { Marvel::Sidekick.new 'Robin', catch_phrase: 'Holy _, Batman!' }
+        Then { 'hooked' }
+      end
+
+      describe '.after_find' do
+        Given(:hook) { :after_find }
+        Given do
+          class Marvel::Sidekick < Squares::Base
+            after_find { spy.after_find }
+          end
+        end
+        Given { Marvel::Sidekick.create 'Robin', catch_phrase: 'Holy _, Batman!' }
+        When(:result) { Marvel::Sidekick.find 'Robin' }
+        Then { 'hooked' }
+      end
+
+      describe '.before_save' do
+        Given(:hook) { :before_save }
+        Given do
+          class Marvel::Sidekick < Squares::Base
+            before_save { spy.before_save }
+          end
+        end
+        Given(:robin) { Marvel::Sidekick.new 'Robin', catch_phrase: 'Holy _, Batman!' }
+        When { robin.save }
+        Then { 'hooked' }
+      end
+
+      describe '.after_save' do
+        Given(:hook) { :after_save }
+        Given do
+          class Marvel::Sidekick < Squares::Base
+            after_save { spy.after_save }
+          end
+        end
+        Given(:robin) { Marvel::Sidekick.new 'Robin', catch_phrase: 'Holy _, Batman!' }
+        When { robin.save }
+        Then { 'hooked' }
+      end
+
+      describe '.before_destroy' do
+        Given(:hook) { :before_destroy }
+        Given do
+          class Marvel::Sidekick < Squares::Base
+            before_destroy { spy.before_destroy }
+          end
+        end
+        Given(:robin) { Marvel::Sidekick.create 'Robin', catch_phrase: 'Holy _, Batman!' }
+        When { robin.destroy }
+        Then { 'hooked' }
+      end
+
+      describe 'hook callbacks do not fire other hook callbacks' do
+        Given(:hook) { :after_initialize }
+        Given { expect(hook_spy).to_not receive(:before_save) }
+        Given do
+          class Marvel::Sidekick < Squares::Base
+            after_initialize do
+              self.spy.after_initialize
+              save
+            end
+            before_save { spy.before_save }
+          end
+        end
+        When { Marvel::Sidekick.new 'Robin', catch_phrase: 'Holy _, Batman!' }
+        Then { 'hooked' }
+      end
+
+    end # instance methods
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: squares
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.3.0
 platform: ruby
 authors:
 - Joel Helbling
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-16 00:00:00.000000000 Z
+date: 2015-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler