herder 0.0.2 → 0.0.4

data/Gemfile.lock

@@ -1,10 +1,11 @@
 PATH
   remote: .
   specs:
-    herder (0.0.1)
+    herder (0.0.4)
       active_resource_pagination
       activeresource
       reactive_resource
+      timecop
       will_paginate
 
 GEM
@@ -36,6 +37,7 @@ GEM
     rspec-expectations (2.11.1)
       diff-lcs (~> 1.1.3)
     rspec-mocks (2.11.1)
+    timecop (0.3.5)
     will_paginate (3.0.3)
 
 PLATFORMS

data/README.md

@@ -22,9 +22,25 @@ password: "password"
 
 Or don't add the yml file to fall back on the ENV variables `HERDER_SITE`, `HERDER_USER` and `HERDER_PASSWORD`. This is useful for Heroku.
 
-## Usage
-
-For now Herder adds a few built in ActiveResource classes. For full usage details read the [ActiveResource documentation](http://api.rubyonrails.org/classes/ActiveResource/Base.html).
+## Basic usage
+
+For now Herder adds a few built in ActiveResource classes.
+
+* `Herder::Attendee`
+  * has many `Herder::Emails`
+  * has many `Herder::Tickets`
+* `Herder::Email`
+  * belongs to `Herder::Attendee`
+* `Herder::Ticket`
+  * belongs to `Herder::Attendee`
+  * belongs to `Herder::Event`
+* `Herder::Event`
+  * has many `Herder::Tickets`
+  * belongs to `Herder::Venue`
+* `Herder::Venue`
+  * has many `Herder::Events`
+
+For full usage details read the [ActiveResource documentation](http://api.rubyonrails.org/classes/ActiveResource/Base.html).
 
 ```ruby
 Herder::Attendee.find(1)
@@ -45,8 +61,49 @@ Attendee.find(1)
 #=> #<Attendee:0x007f9aabb84550 @attributes={"created_at"=>"2012-07-10T19:26:23Z", "diet"=>nil, "first_name"=>"John", "id"=>1, "kind"=>1, "last_name"=>"Doe", "name"=>"John Doe", "notes"=>nil, "phone_number"=>nil, "public"=>true, "tshirt"=>nil, "twitter"=>nil, "updated_at"=>"2012-07-10T19:26:23Z"}, @prefix_options={}, @persisted=true>
 ```
 
+## Using interactions
+
+Interactions are a handy key-value attributes that can be set on other classes (Interactables). This is handy as it means we don't need to add loads of extra booleans to Hamster for every little thing we might need to keep track of.
+
+**Note:** Interactions are never deleted, hence you can always get a full log of interactions including date and time of when something changed value.
+
+### Acting on a record
+
+```ruby
+ticket = Ticket.find(1)
+ticket.interactions.checkin = true #changes state
+ticket.interactions.checkin.toggle #changes state to opposite of current state
+ticket.interactions.checkin.undo! #undoes (hard delete) last state
+ticket.interactions.checkin #just returns latest value for the checkin key
+ticket.interactions.checkin? #just checks if value == true
+ticket.interactions.limit(5).checkin #just returns last 5 values for checkin
+ticket.interactions.limit(5).oldest.checkin #just returns first 5 (oldest) values for checkin
+ticket.interactions #full list of interaction objects
+```
+
+### Acting on a table
+
+**Note:** These methods return the objects they are performed on (in this case Ticket).
+
+```ruby
+event = Event.find(1)
+event.tickets.where("interactions.confirmed = true") #confirmed tickets for event #1
+event.tickets.where("interactions.confirmed != true") #unconfirmed tickets for event #1
+event.tickets.where("interactions.cancelled = true") #cancelled tickets for event #1
+event.tickets.where("interactions.checkin ~ true") #attended tickets for event #1
+event.tickets.where("interactions.checkin !~ true") #noshow tickets for event #1
+event.tickets.where("interactions.checkin = true") #onsite tickets for event #1
+event.tickets.where("interactions.checkin != true") #offsite tickets for event #1
+event.tickets.where("interactions.checkin ~ ? AND interactions.created_at < ? AND interactions.created_at > ?", true, Time.now, 3.days.ago) #attended during period
+event.tickets.where("interactions.checkin !~ ? AND interactions.created_at < ? AND interactions.created_at > ?", false, Time.now, 3.days.ago) # did not check out during period
+event.tickets.where("interactions.permanently_left = true") #not-coming-back
+event.tickets.where("interactions.permanently_left != true") #coming-back
+```
+
 ## Changelog
 
+* 0.0.4 - Added events and venues
+* 0.0.3 - Added interactions and interactables
 * 0.0.2 - Added emails, tickets, and association
 * 0.0.1 - Added basic attendee interface
 

data/herder.gemspec

@@ -24,4 +24,5 @@ Gem::Specification.new do |s|
   s.add_dependency 'reactive_resource'
   s.add_dependency 'active_resource_pagination'
   s.add_dependency 'will_paginate'
+  s.add_dependency 'timecop'
 end

data/lib/herder.rb

@@ -4,9 +4,6 @@ require "active_resource_pagination"
 
 require_relative "herder/config"
 require_relative "herder/model"
-require_relative "herder/attendee"
-require_relative "herder/ticket"
-require_relative "herder/email"
 
 class Herder
 end

data/lib/herder/attendee.rb

@@ -1,5 +1,7 @@
 class Herder
   class Attendee < Herder::Model
+    include Herder::Interactable
+
     has_many :emails
     has_many :tickets
   end

data/lib/herder/event.rb

@@ -0,0 +1,8 @@
+class Herder
+  class Event < Herder::Model
+    include Herder::Interactable
+
+    has_many :tickets
+    belongs_to :venue
+  end
+end

data/lib/herder/interactable.rb

@@ -0,0 +1,15 @@
+class Herder
+  module Interactable
+    def interactions
+      Interactable::Query.new(type: klass, id: id)
+    end
+
+    protected
+
+    def klass
+      @klass ||= self.class.name.split("::").last
+    end
+  end
+end
+
+require_relative "interactable/query"

data/lib/herder/interactable/query.rb

@@ -0,0 +1,94 @@
+class Herder
+  module Interactable
+    class Query
+      def initialize options
+        params[:interactable_id] = options[:id] if options[:id]
+        params[:interactable_type] = options[:type] if options[:type]
+        newest
+      end
+
+      # this is used for lazy execution of the query
+      def each &block
+        query.each &block
+      end
+
+      def to_s
+        query.to_s
+      end
+
+      def limit count
+        params[:limit] = count
+        self
+      end
+
+      def oldest
+        order "created_at ASC"
+      end
+
+      def newest
+        order "created_at DESC"
+      end
+
+      def set key
+        params[:key] = key
+        self
+      end
+
+      def to value
+        params[:value] = value
+        create
+      end
+
+      def state? key
+        interaction = state(key)
+        interaction && interaction.value.to_s == "true"
+      end
+
+      def state key
+        limit 1
+        newest
+        states(key).first
+      end
+
+      def states key
+        params[:key] = key
+        query
+      end
+
+      protected
+
+      attr_accessor :params
+
+      def order by
+        params[:order] = by
+        self
+      end
+
+      def params
+        @params ||= {}
+      end
+
+      def query
+        @query ||= Interaction.where(params)
+      end
+
+      def method_missing(key, *args, &block)
+        if key.to_s.ends_with? "?"
+          key = key.to_s.gsub("?", "")
+          state? key
+        elsif key.to_s.ends_with? "="
+          key = key.to_s.gsub("=", "")
+          set(key).to(*args)
+        elsif params[:limit] || params[:offset]
+          states key
+        else
+          state(key)
+        end
+      end
+
+      def create
+        Interaction.create params.except(:limit, :offset, :order)
+      end
+    end
+  end
+end

data/lib/herder/interaction.rb

@@ -0,0 +1,26 @@
+class Herder
+  class Interaction < Herder::Model
+    def toggle
+      val = !["true", true].include?(value)
+      query.set(key).to(val)
+    end
+
+    def undo!
+      destroy
+    end
+
+    def to_s
+      value
+    end
+
+    def ==(other)
+      value == other
+    end
+
+    private
+
+    def query
+      @query ||= Interactable::Query.new(type: interactable_type, id: interactable_id)
+    end
+  end
+end

data/lib/herder/model.rb

@@ -4,8 +4,17 @@ class Herder
     self.user = Herder::Config.get("user")
     self.password = Herder::Config.get("password")
 
-    def self.where options
-      find(:all, params: options)
+    def self.where *params
+      Herder::Model::Query.new(self).where(*params)
     end
   end
-end
+end
+
+require_relative "model/query"
+require_relative "interaction"
+require_relative "interactable"
+require_relative "attendee"
+require_relative "venue"
+require_relative "event"
+require_relative "ticket"
+require_relative "email"

data/lib/herder/model/query.rb

@@ -0,0 +1,82 @@
+class Herder
+  class Model
+    class Query
+      attr_accessor :model, :params
+
+      def initialize model
+        self.model = model
+        self.params = {}
+      end
+
+      def where *prms
+        params.merge!(sanitize prms)
+        self
+      end
+
+      def each &block
+        query.each &block
+      end
+
+      def to_s
+        query.to_s
+      end
+
+      protected
+
+      COMPARATORS = {
+        "=" => "=",
+        "!=" => "!=",
+        "~" => "~",
+        "!~" => "!~",
+        "is" => "=",
+        "isnt" => "!=",
+        "was" => "~",
+        "wasnt" => "!~"
+      }.freeze
+
+      def query
+        @query ||= model.find(:all, params: params)
+      end
+
+      def sanitize params
+        case params.class.name
+        when "Hash"
+          return params.stringify_keys
+        when "String"
+          return hashify params
+        when "Array"
+          if params.first.is_a?(Hash)
+            return params.first.stringify_keys
+          else
+            return hashify(parameterize params)
+          end
+        end
+      end
+
+      def hashify params
+        subqueries = params.split(/and/i)
+        return subqueries.inject(Hash.new) do |results, subquery|
+          tokens = subquery.strip.split(" ", 3)
+          tokens[2].gsub!(/\A"|'/m, "")
+          tokens[2].gsub!(/"|'\Z/m, "")
+          append_param results, tokens
+          results
+        end
+      end
+
+      def parameterize params
+        return params unless params.is_a?(Array)
+        params[0].gsub(/ \?/, " %s") % params[1..-1]
+      end
+
+      def append_param results, tokens
+        if tokens[0].starts_with? "interactions."
+          comparator = COMPARATORS[tokens[1]] || tokens[1]
+          results["#{tokens[0]} #{comparator}"] = tokens[2]
+        else
+          results[tokens[0]] = tokens[2]
+        end
+      end
+    end
+  end
+end

data/lib/herder/ticket.rb

@@ -1,5 +1,8 @@
 class Herder
   class Ticket < Herder::Model
+    include Herder::Interactable
+
     belongs_to :attendee
+    belongs_to :event
   end
 end

data/lib/herder/venue.rb

@@ -0,0 +1,5 @@
+class Herder
+  class Venue < Herder::Model
+    has_many :events
+  end
+end

data/lib/herder/version.rb

@@ -1,3 +1,3 @@
 class Herder
-  VERSION = "0.0.2" unless defined? Herder::VERSION
+  VERSION = "0.0.4" unless defined? Herder::VERSION
 end

data/spec/herder/attendee_spec.rb

@@ -9,6 +9,10 @@ describe Herder::Attendee do
     Herder::Attendee.new.should be_a(Herder::Model)
   end
 
+  it "should inherit Herder::Interactable" do
+    Herder::Attendee.new.should be_a(Herder::Interactable)
+  end
+
   it "should have many tickets and emails" do
     Herder::Attendee.associations.map(&:attribute).should =~ [:tickets, :emails]
     Herder::Attendee.associations.map(&:class).uniq.should be == [ReactiveResource::Association::HasManyAssociation]

data/spec/herder/email_spec.rb

@@ -10,7 +10,7 @@ describe Herder::Email do
   end
 
   it "should belong to an attendee" do
-    Herder::Ticket.associations.map(&:attribute).should =~ [:attendee]
-    Herder::Ticket.associations.map(&:class).should be == [ReactiveResource::Association::BelongsToAssociation]
+    Herder::Email.associations.map(&:attribute).should =~ [:attendee]
+    Herder::Email.associations.map(&:class).should be == [ReactiveResource::Association::BelongsToAssociation]
   end
 end

data/spec/herder/event_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+describe Herder::Event do
+  it "should setup right name" do
+    Herder::Event.element_name.should be == "event"
+  end
+
+  it "should inherit Herder::Model" do
+    Herder::Event.new.should be_a(Herder::Model)
+  end
+
+  it "should inherit Herder::Interactable" do
+    Herder::Event.new.should be_a(Herder::Interactable)
+  end
+
+  it "should belong to an attendee" do
+    Herder::Event.associations.map(&:attribute).should =~ [:tickets, :venue]
+    Herder::Event.associations.map(&:class).should be == [ReactiveResource::Association::HasManyAssociation, ReactiveResource::Association::BelongsToAssociation]
+  end
+end

data/spec/herder/interactable/query_spec.rb

@@ -0,0 +1,132 @@
+require "spec_helper"
+
+describe Herder::Interactable::Query do
+  before :each do
+     @interactions = Herder::Interactable::Query.new type: Herder::Ticket, id: 1
+   end
+
+   describe "#initialize" do
+     it "should setup the default params" do
+       @interactions.send(:params).should be == {:interactable_id=>1, :interactable_type=>Herder::Ticket, :order=>"created_at DESC"}
+     end
+   end
+
+   describe "#each" do
+     it "should yield the query" do
+       result = [:a, :b]
+       Herder::Interaction.should_receive(:where).and_return(result)
+
+       @interactions.each.should be_a(Enumerator)
+       @interactions.each{}.should be == result
+     end
+   end
+
+   describe "#to_s" do
+     it "should stringify the result" do
+       result = [:a, :b]
+       Herder::Interaction.should_receive(:where).and_return(result)
+       @interactions.to_s.should be_a(String)
+       @interactions.to_s{}.should be == result.to_s
+     end
+   end
+
+   describe "#limit" do
+     it "should set the limit" do
+       @interactions.limit 10
+       @interactions.send(:params)[:limit].should be == 10
+     end
+   end
+
+   describe "#oldest" do
+     it "should set the order created_at ASC" do
+       @interactions.oldest
+       @interactions.send(:params)[:order].should be == "created_at ASC"
+     end
+   end
+
+   describe "#newest" do
+     it "should set the order created_at DESC" do
+       @interactions.newest
+       @interactions.send(:params)[:order].should be == "created_at DESC"
+     end
+   end
+
+   describe "#set" do
+     it "should set the key" do
+       @interactions.set(:foo)
+       @interactions.send(:params)[:key].should be == :foo
+     end
+   end
+
+   describe "#to" do
+     it "should set the value and create a new object" do
+       expected_params = {:interactable_id=>1, :interactable_type=>Herder::Ticket, :key=>:foo, :value=>:bar}
+       Herder::Interaction.should_receive(:create).with(expected_params)
+       @interactions.set(:foo).to(:bar)
+       @interactions.send(:params)[:value].should be == :bar
+     end
+   end
+
+   describe "#state" do
+     before :each do
+       expected_params = {:interactable_id=>1, :interactable_type=>Herder::Ticket, :order=>"created_at DESC", :limit=>1, :key=>:foo}
+       interaction = Herder::Interaction.new value: "bar"
+       Herder::Interaction.should_receive(:where).with(expected_params).and_return([interaction])
+     end
+
+     it "should determine the current state of a value" do
+       @interactions.state(:foo).should be == "bar"
+     end
+
+     it "should also work by directly calling the key" do
+       @interactions.foo.should be == "bar"
+     end
+   end
+
+   describe "#state?" do
+     it "should return true if the value is true" do
+       expected_params = {:interactable_id=>1, :interactable_type=>Herder::Ticket, :order=>"created_at DESC", :limit=>1, :key=>:foo}
+       interaction = Herder::Interaction.new value: true
+       Herder::Interaction.should_receive(:where).with(expected_params).and_return([interaction])
+       @interactions.state?(:foo).should be_true
+     end
+
+     it "should return true if the value is 'true'" do
+       interaction = Herder::Interaction.new value: "true"
+       Herder::Interaction.should_receive(:where).and_return([interaction])
+       @interactions.state?(:foo).should be_true
+     end
+
+     it "should also work by directly asking it by key" do
+       interaction = Herder::Interaction.new value: "true"
+       Herder::Interaction.should_receive(:where).and_return([interaction])
+       @interactions.foo?.should be_true
+     end
+
+
+     it "should return false if the value if falsy" do
+       interaction = Herder::Interaction.new value: "foobar"
+       Herder::Interaction.should_receive(:where).and_return([interaction])
+       @interactions.foo?.should be_false
+     end
+
+     it "should return false if the value has never been set" do
+       Herder::Interaction.should_receive(:where).and_return([])
+       @interactions.foo?.should be_false
+     end
+   end
+
+   describe "#states" do
+     it "should return the results" do
+       expected_params = {:interactable_id=>1, :interactable_type=>Herder::Ticket, :order=>"created_at DESC", :key=>:foo}
+       Herder::Interaction.should_receive(:where).with(expected_params).and_return([:foo, :bar])
+       @interactions.states(:foo).should be == [:foo, :bar]
+     end
+
+     it "should also be able to be called by key if a limit was set" do
+       expected_params = {:interactable_id=>1, :interactable_type=>Herder::Ticket, :order=>"created_at DESC", :limit=>10, :key=>:foo}
+       Herder::Interaction.should_receive(:where).with(expected_params).and_return([:foo, :bar])
+       @interactions.limit(10).foo.should be == [:foo, :bar]
+     end
+   end
+end

data/spec/herder/interactable_spec.rb

@@ -0,0 +1,15 @@
+require "spec_helper"
+
+describe Herder::Interactable do
+  class MockClass < Herder::Model
+    include Herder::Interactable
+  end
+
+  describe "interactions" do
+    it "should provide a class a interactions object" do
+      mock_class = MockClass.new
+      mock_class.interactions.should be_a(Herder::Interactable::Query)
+      mock_class.interactions.send(:params)[:interactable_type].should be == "MockClass"
+    end
+  end
+end

data/spec/herder/interaction_spec.rb

@@ -0,0 +1,44 @@
+require "spec_helper"
+
+describe Herder::Interaction do
+  it "should setup right name" do
+    Herder::Interaction.element_name.should be == "interaction"
+  end
+
+  it "should inherit Herder::Model" do
+    Herder::Email.new.should be_a(Herder::Model)
+  end
+
+  describe "#toggle" do
+    it "should remove the interaction" do
+      interaction = Herder::Interaction.new key: "foo", value: true
+      query = mock "Query"
+      interaction.should_receive(:query).and_return(query)
+      query.should_receive(:set).with("foo").and_return(query)
+      query.should_receive(:to).with(false)
+      interaction.toggle
+    end
+  end
+
+  describe "#undo!" do
+    it "should remove the interaction" do
+      interaction = Herder::Interaction.new value: "foo"
+      interaction.should_receive(:destroy)
+      interaction.undo!
+    end
+  end
+
+  describe "#to_s" do
+    it "should be represented by value" do
+      interaction = Herder::Interaction.new value: "foo"
+      interaction.to_s.should be == "foo"
+    end
+  end
+
+  describe "#==" do
+    it "should compare by value" do
+      interaction = Herder::Interaction.new value: "foo"
+      interaction.should be == "foo"
+    end
+  end
+end

data/spec/herder/model/query_spec.rb

@@ -0,0 +1,91 @@
+require "spec_helper"
+
+describe Herder::Model::Query do
+  before :each do
+    @query = Herder::Model::Query.new(Herder::Ticket)
+  end
+
+  describe "#initialize" do
+    it "should assign the model and init the params" do
+      @query.model.should be == Herder::Ticket
+      @query.params.should be == {}
+    end
+  end
+
+  describe "#where" do
+    it "should append to the params" do
+      @query.where("id = ?", 1)
+      @query.params.should be == {"id" => "1"}
+    end
+
+    it "should be chainable" do
+      @query.where("id = ?", 1).where("foo = bar")
+      @query.params.should be == {"id" => "1", "foo" => "bar"}
+    end
+
+    it "should overwrite previously stated values" do
+      @query.where("id = ?", 1).where("id = ?", 2)
+      @query.params.should be == {"id" => "2"}
+    end
+
+    it "should parse interactions seperately" do
+      @query.where("id = ?", 1).where("interactions.confirmed ~ ?", "true")
+      @query.params.should be == {"id" => "1", "interactions.confirmed ~" => "true"}
+    end
+
+    it "should allow for interactions date ranges" do
+      Timecop.freeze(Time.now) do
+        @query.where("id = ?", 1).where("interactions.created_at > ? AND interactions.created_at < ?",  10.day.ago, 1.days.ago)
+        @query.params.should be == {"id" => "1", "interactions.created_at >" => 10.days.ago.to_s, "interactions.created_at <" => 1.days.ago.to_s}
+      end
+    end
+  end
+
+  describe "#each" do
+    it "should yield the query" do
+      result = [:a, :b]
+      Herder::Ticket.should_receive(:find).and_return(result)
+
+      @query.each.should be_a(Enumerator)
+      @query.each{}.should be == result
+    end
+  end
+
+  describe "#to_s" do
+    it "should stringify the result" do
+      result = [:a, :b]
+      Herder::Ticket.should_receive(:find).and_return(result)
+      @query.to_s.should be_a(String)
+      @query.to_s{}.should be == result.to_s
+    end
+  end
+
+  describe "COMPARATORS" do
+    it "should translate interaction comparators" do
+      @query.where("interactions.a is 'a'").where("interactions.b isnt 'b'").where("interactions.c was 'c'").where("interactions.d wasnt 'c'")
+      @query.params.should be == {"interactions.a ="=>"a", "interactions.b !="=>"b", "interactions.c ~"=>"c", "interactions.d !~"=>"c"}
+    end
+  end
+
+  describe "#hashify" do
+    it "should accept hashes" do
+      @query.where(foo: "this is a sentence")
+      @query.params.should be == {"foo" => "this is a sentence"}
+    end
+
+    it "should accept strings" do
+      @query.where("foo = 'this is a sentence'")
+      @query.params.should be == {"foo" => "this is a sentence"}
+    end
+
+    it "should accept strings with formats as tokens" do
+      @query.where("foo = ?", "this is a sentence")
+      @query.params.should be == {"foo" => "this is a sentence"}
+    end
+
+    it "should be chain-able" do
+      @query.where("foo = ?", "this is a sentence1").where("bar = 'this is a sentence2'")
+      @query.params.should be == {"foo" => "this is a sentence1", "bar" => "this is a sentence2"}
+    end
+  end
+end

data/spec/herder/model_spec.rb

@@ -14,8 +14,26 @@ describe Herder::Model do
   describe "#where" do
     it "should pass the query along to find" do
       options = {foo: :bar}
+      Herder::Model.should_receive(:find).with(:all, params: {"foo" => :bar})
+      Herder::Model.where(options).to_s
+    end
+
+    it "should accept strings" do
+      options = {"foo" => "bar"}
+      Herder::Model.should_receive(:find).with(:all, params: options)
+      Herder::Model.where("foo = 'bar'").to_s
+    end
+
+    it "should accept strings with formats as tokens" do
+      options = {"foo" => "bar"}
+      Herder::Model.should_receive(:find).with(:all, params: options)
+      Herder::Model.where("foo = ?", "bar").to_s
+    end
+
+    it "should be chain-able" do
+      options = {"foo" => "bar", "baz" => "qar"}
       Herder::Model.should_receive(:find).with(:all, params: options)
-      Herder::Model.where(options)
+      Herder::Model.where("foo = ?", "bar").where("baz = ?", "qar").to_s
     end
   end
 end

data/spec/herder/ticket_spec.rb

@@ -9,8 +9,12 @@ describe Herder::Ticket do
     Herder::Ticket.new.should be_a(Herder::Model)
   end
 
+  it "should inherit Herder::Interactable" do
+    Herder::Ticket.new.should be_a(Herder::Interactable)
+  end
+
   it "should belong to an attendee" do
-    Herder::Ticket.associations.map(&:attribute).should =~ [:attendee]
-    Herder::Ticket.associations.map(&:class).should be == [ReactiveResource::Association::BelongsToAssociation]
+    Herder::Ticket.associations.map(&:attribute).should =~ [:attendee, :event]
+    Herder::Ticket.associations.map(&:class).should be == [ReactiveResource::Association::BelongsToAssociation, ReactiveResource::Association::BelongsToAssociation]
   end
 end

data/spec/herder/venue_spec.rb

@@ -0,0 +1,16 @@
+require "spec_helper"
+
+describe Herder::Venue do
+  it "should setup right name" do
+    Herder::Venue.element_name.should be == "venue"
+  end
+
+  it "should inherit Herder::Model" do
+    Herder::Venue.new.should be_a(Herder::Model)
+  end
+
+  it "should have many events" do
+    Herder::Venue.associations.map(&:attribute).should =~ [:events]
+    Herder::Venue.associations.map(&:class).should be == [ReactiveResource::Association::HasManyAssociation]
+  end
+end

data/spec/spec_helper.rb

@@ -1 +1,2 @@
 require "herder"
+require "timecop"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: herder
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-21 00:00:00.000000000 Z
+date: 2012-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70333801744000 !ruby/object:Gem::Requirement
+  requirement: &70345550619080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70333801744000
+  version_requirements: *70345550619080
 - !ruby/object:Gem::Dependency
   name: activeresource
-  requirement: &70333801743580 !ruby/object:Gem::Requirement
+  requirement: &70345550617940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70333801743580
+  version_requirements: *70345550617940
 - !ruby/object:Gem::Dependency
   name: reactive_resource
-  requirement: &70333801743160 !ruby/object:Gem::Requirement
+  requirement: &70345551200100 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70333801743160
+  version_requirements: *70345551200100
 - !ruby/object:Gem::Dependency
   name: active_resource_pagination
-  requirement: &70333801742740 !ruby/object:Gem::Requirement
+  requirement: &70345551199680 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70333801742740
+  version_requirements: *70345551199680
 - !ruby/object:Gem::Dependency
   name: will_paginate
-  requirement: &70333801742320 !ruby/object:Gem::Requirement
+  requirement: &70345551199260 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,7 +65,18 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70333801742320
+  version_requirements: *70345551199260
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: &70345551198840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70345551198840
 description: The herder that manages all animals talking to the hamster
 email:
 - cristiano@geeksoflondon.com
@@ -87,14 +98,26 @@ files:
 - lib/herder/attendee.rb
 - lib/herder/config.rb
 - lib/herder/email.rb
+- lib/herder/event.rb
+- lib/herder/interactable.rb
+- lib/herder/interactable/query.rb
+- lib/herder/interaction.rb
 - lib/herder/model.rb
+- lib/herder/model/query.rb
 - lib/herder/ticket.rb
+- lib/herder/venue.rb
 - lib/herder/version.rb
 - spec/herder/attendee_spec.rb
 - spec/herder/config_spec.rb
 - spec/herder/email_spec.rb
+- spec/herder/event_spec.rb
+- spec/herder/interactable/query_spec.rb
+- spec/herder/interactable_spec.rb
+- spec/herder/interaction_spec.rb
+- spec/herder/model/query_spec.rb
 - spec/herder/model_spec.rb
 - spec/herder/ticket_spec.rb
+- spec/herder/venue_spec.rb
 - spec/herder_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/geeksoflondon/herder
@@ -125,7 +148,13 @@ test_files:
 - spec/herder/attendee_spec.rb
 - spec/herder/config_spec.rb
 - spec/herder/email_spec.rb
+- spec/herder/event_spec.rb
+- spec/herder/interactable/query_spec.rb
+- spec/herder/interactable_spec.rb
+- spec/herder/interaction_spec.rb
+- spec/herder/model/query_spec.rb
 - spec/herder/model_spec.rb
 - spec/herder/ticket_spec.rb
+- spec/herder/venue_spec.rb
 - spec/herder_spec.rb
 - spec/spec_helper.rb