eventbright 0.1.0

data/lib/eventbright/api_objects/venue.rb

@@ -0,0 +1,18 @@
+module EventBright
+  
+  class Venue < ApiObject
+    
+    updatable :name
+    updatable :address, :address_2 
+    updatable :city, :region, :postal_code 
+    updatable :country, :country_code
+    readable :latitude, :longitude
+    requires :name
+    renames :name => :venue, :address => :adress, :address_2 => :adress_2
+    ignores :"Lat-Long"
+    
+    def state;        region;       end    # Region is same as state in US
+    def state=(val);  region= val;  end    # Region is same as state in US
+  end
+  class VenueCollection < ApiObjectCollection; collection_for Venue; end
+end

data/lib/eventbright/error.rb

@@ -0,0 +1,14 @@
+module EventBright
+  class Error < Exception
+    attr_accessor :type, :response, :message
+    def initialize(message, type = "", response = nil)
+      @type = type
+      @response = response
+      @message = message
+      super(message)
+    end
+    def inspect
+      "<EventBright::Error(#{type}): #{message}>"
+    end
+  end
+end

data/lib/eventbright/main.rb

@@ -0,0 +1,57 @@
+require 'httparty'
+
+module EventBright
+  EVENTBRITE_TIME_STRING = '%Y-%m-%d %H:%M:%S'
+  def self.setup(app_key = "YmRmMmMxMjYzNDYy", debug = false)
+    @app_key = app_key
+    @debug = debug
+  end
+  
+  def self.debug!
+    @debug = true
+  end
+  
+  def self.call(function, opts = {})
+    @app_key ||= "YmRmMmMxMjYzNDYy"
+    opts[:app_key] = @app_key
+    if opts[:user].is_a? EventBright::User 
+      # Allow passing User object instead of user auth info.
+      u = opts.delete :user
+      opts.merge!(u.auth)
+    end 
+    debug "\tSending  /#{function}\t\t(#{opts.inspect})"
+    response = API.do_post("/#{function}", :body => opts)
+    debug "\tResponse /#{function}\t\t#{response.inspect}"
+    response
+  end
+  
+  
+  def self.debug(msg)
+    puts msg if debug?
+  end
+  
+  def self.debug?
+    @debug.nil? ? false : @debug
+  end
+  
+  def self.formatted_time(date)
+    case date
+    when Time
+      date.strftime(EVENTBRITE_TIME_STRING)
+    when String
+      Time.parse(String).strftime(EVENTBRITE_TIME_STRING)
+    end
+  end
+  
+  class API
+    include HTTParty
+    base_uri "https://www.eventbrite.com/json/"
+    def self.do_post(function, opts = {})
+      response = post(function, opts)
+      if response["error"]
+        raise Error.new(response["error"]["error_message"], response["error"]["error_type"], response)
+      end
+      response
+    end
+  end
+end

data/spec/eventbright/api_object_class_spec.rb

@@ -0,0 +1,113 @@
+share_examples_for "EventBright::ApiObject class methods" do
+  it "should have a singlet name same as class name, or set singlet_name" do
+    EventBright::Foo.singlet_name.should == 'foo'
+    EventBright::Bar.singlet_name.should == 'baz'
+  end
+  it "should add an s to the singlet name to get the plural, or use set plural" do
+    EventBright::Foo.plural_name.should == 'foos'
+    EventBright::Bar.plural_name.should == 'bazzes'
+  end
+  it "should have ignores" do
+    EventBright::Foo.ignores.should == []
+    EventBright::Foo.ignores :foo, :bar
+    EventBright::Foo.ignores :baz
+    EventBright::Foo.ignores.should == [:foo, :bar, :baz]
+  end
+  it "should have requires" do
+    EventBright::Foo.requires.should == []
+    EventBright::Foo.requires :foo, :bar
+    EventBright::Foo.requires :baz
+    EventBright::Foo.requires.should == [:foo, :bar, :baz]
+  end
+  it "should have reformats" do
+    EventBright::Foo.reformats.should == []
+    EventBright::Foo.reformats :foo, :bar
+    EventBright::Foo.reformats :baz
+    EventBright::Foo.reformats.should == [:foo, :bar, :baz]
+  end
+  it "should have renames" do
+    EventBright::Foo.renames.should == {}
+    EventBright::Foo.renames :foo => :bar, :quux => :wobble
+    EventBright::Foo.renames :baz => :qux
+    EventBright::Foo.renames.should == {:foo => :bar, :baz => :qux, :quux => :wobble}
+  end
+  
+  it "should have updatable" do
+    f = EventBright::Foo.new(false, {})
+    f.should_not respond_to(:attr_1)
+    f.should_not respond_to(:attr_2)
+    f.should_not respond_to(:attr_3)
+    f.should_not respond_to(:attr_3=)
+    EventBright::Foo.updatable :attr_1, :attr_2
+    EventBright::Foo.updatable :attr_3
+    f.should respond_to(:attr_1)
+    f.should respond_to(:attr_2)
+    f.should respond_to(:attr_3)
+    f.should respond_to(:attr_3=)
+    f.should_receive(:attribute_set).with(:attr_3, :banana, false)
+    f.attr_3 = :banana
+  end
+  it "should have readable" do
+    f = EventBright::Foo.new(false, {})
+    f.should_not respond_to(:attr_4)
+    f.should_not respond_to(:attr_5)
+    f.should_not respond_to(:attr_6)
+    f.should_not respond_to(:attr_6=)
+    EventBright::Foo.readable :attr_4, :attr_5
+    EventBright::Foo.readable :attr_6
+    f.should respond_to(:attr_4)
+    f.should respond_to(:attr_5)
+    f.should respond_to(:attr_6)
+    f.should respond_to(:attr_6=)
+    f.should_receive(:attribute_set).with(:attr_6, :banana, true)
+    f.attr_6 = :banana
+  end
+  it "should have a readable_date" do
+    f = EventBright::Foo.new(false, {})
+    time = Time.parse("4/1/2010 13:37")
+    EventBright::Foo.readable_date :attr_7, :attr_8
+    f.attr_7 = f.attr_8 = "4/1/2010 13:37"
+    f.attributes.should == {:attr_7 => time, :attr_8 => time}
+    f.attr_7.should == EventBright.formatted_time(time)
+  end
+  it "should have an updatable_date" do
+    f = EventBright::Foo.new(false, {})
+    time = Time.parse("4/1/2010 13:37")
+    EventBright::Foo.updatable_date :attr_9, :attr_0
+    f.attr_9 = f.attr_0 = "4/1/2010 13:37"
+    f.attributes.should == {:attr_9 => time, :attr_0 => time}
+    f.attr_9.should == EventBright.formatted_time(time)
+  end
+  it "should have a remap method" do
+    f = EventBright::Foo.new(false, {})
+    f.should_not respond_to(:banana)
+    EventBright::Foo.remap :banana => :attr_1
+    f.should respond_to(:banana)
+    f.should_receive(:attr_1=).once
+    f.should_receive(:attr_1).once
+    f.banana = :banana
+    f.banana
+  end
+  
+  it "should have the #has method" do
+    f = EventBright::Foo.new(false, {})
+    f.should_not respond_to(:bar)
+    f.class.relations.should == {}
+    EventBright::Foo.has :bar => EventBright::Bar
+    f.should respond_to(:bar)
+    f.should respond_to(:bar=)
+    f.class.relations.should have(1).relation
+    f.class.relations[:bar].should == EventBright::Bar
+  end
+  
+  it "should have the #collection method" do
+    f = EventBright::Foo.new(false, {})
+    f.should_not respond_to(:baz)
+    f.class.collections.should == {}
+    EventBright::Foo.collection :baz => EventBright::BananaBunch
+    f.should respond_to(:baz)
+    f.should respond_to(:baz=)
+    f.class.collections.should have(1).relation
+    f.class.collections[:baz].should == EventBright::BananaBunch
+  end
+end

data/spec/eventbright/api_object_collection_spec.rb

@@ -0,0 +1,67 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe EventBright::ApiObjectCollection do
+  before(:all) do
+    @b = EventBright::BananaBunch.new(false, [{"banana" => {:val => 1}}, {"banana" => {:val => 2}}])
+  end
+  context "collection functions" do
+    it "should pass through standard Array methods" do
+      lambda{
+       @b.first
+       @b.last
+       @b[0]
+      }.should_not raise_error
+    end
+    it "should iterate through collection and check dirtyness for #dirty?" do
+      @b.first.should_receive(:dirty?).once.and_return(false)
+      @b.last.should_receive(:dirty?).once.and_return(false)
+      @b.dirty?.should == false
+      @b.first.should_receive(:dirty?).once.and_return(true)
+      @b.last.should_receive(:dirty?).once.and_return(false)
+      @b.dirty?.should == true
+    end
+    it "should iterate through collection and not save any objects if clean" do
+      @b.first.should_receive(:dirty?).once.and_return(false)
+      @b.first.should_not_receive(:save)
+      @b.last.should_receive(:dirty?).once.and_return(false)
+      @b.last.should_not_receive(:save)
+      @b.save
+    end
+    it "should iterate through collection and save dirty objects only" do
+      @b.first.should_receive(:dirty?).once.ordered.and_return(true)
+      @b.first.should_receive(:save).once.ordered.and_return(true)
+      @b.last.should_receive(:dirty?).once.and_return(false)
+      @b.last.should_not_receive(:save)
+      @b.save
+    end
+  end
+  
+  context "class definitions" do
+    it "should have a singlet name same as class name" do
+      EventBright::BananaBunch.singlet_name.should == 'banana'
+      EventBright::BradyBunch.singlet_name.should == 'bob'
+    end
+    it "should add an s to the singlet name to get the plural" do
+      EventBright::BananaBunch.plural_name.should == 'bananas'
+      EventBright::BradyBunch.plural_name.should == 'joe'
+    end
+    it "should know what class it collects" do
+      EventBright::BananaBunch.collection_for.should eql EventBright::Banana
+      EventBright::BradyBunch.collection_for.should eql EventBright::Brady
+    end
+    it "should have a getter" do
+      EventBright::BananaBunch.getter.should == "user_list_bananas"
+      EventBright::BradyBunch.getter.should == :foo_bar_baz
+    end
+  end
+
+  it "should map an array of values on initialization" do
+    @b.first.val.should == 1
+    @b.last.val.should == 2
+  end
+  
+  it "should silently reject useless objects (ones without required attributes, empty ones)"  do
+    @bb = EventBright::BradyBunch.new(false, [{"bob" => {:foo => 1}}, {"bob" => {}}, {"bob" => {:bar => 3}}])
+    @bb.size.should == 1
+  end
+end

data/spec/eventbright/api_object_relationship_spec.rb

@@ -0,0 +1,23 @@
+share_examples_for "EventBright::ApiObject relationship methods" do
+  before :all do
+    @bar = EventBright::Bar.new
+  end
+  it "should be able to get relations" do
+    @bar.relations.should == {}
+    @bar.relations = {:banana => EventBright::Banana.new}
+    @bar.banana.should be_an_instance_of(EventBright::Banana)
+    @bar.relations.should have(1).items
+    @bar.should_receive(:relation_get).with(:banana)
+    lambda{
+      @bar.banana
+    }.should_not raise_error
+  end
+  it "should be able to get collections" do
+    @bar.collections.should == {}
+    @bar.collections = {:bananas => EventBright::BananaBunch.new}
+    @bar.bananas.should be_an_instance_of(EventBright::BananaBunch)
+    @bar.collections.should have(1).items
+    @bar.should_receive(:collection_get).with(:bananas)
+    lambda{@bar.bananas}.should_not raise_error
+  end
+end

data/spec/eventbright/api_object_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require File.expand_path(File.dirname(__FILE__) + '/api_object_class_spec')
+require File.expand_path(File.dirname(__FILE__) + '/api_object_relationship_spec')
+describe EventBright::ApiObject do
+  before(:all) do
+    
+  end
+  describe "class methods" do
+    it_should_behave_like "EventBright::ApiObject class methods"
+  end
+  describe "relationships" do
+    it_should_behave_like "EventBright::ApiObject relationship methods"
+  end
+  
+end

data/spec/eventbright/user_spec.rb

@@ -0,0 +1,141 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe EventBright::User do
+  before(:all) do
+    EventBright.setup("key")
+  end
+  
+  it "should load from API on initialization" do
+    EventBright::API.should_receive(:do_post).with("/user_get", anything).and_return(fake_response("/user_get"))
+    u = EventBright::User.new("fake_key")
+    u.attribute_get(:email).should == "david@orangesparkleball.com"
+    u.attribute_get(:password).should be_nil
+    u.attribute_get(:user_key).should_not be_nil
+  end
+  
+  it "should not call API if no_load set in initialization" do
+    EventBright::API.should_not_receive(:do_post)
+    EventBright::User.new("fake_key", true)
+  end
+  
+  it "should accept an array of [email, password] as authentication" do
+    EventBright::API.should_receive(:do_post).with("/user_get", :body => hash_including("password", "user")).and_return(fake_response("/user_get"))
+    u = EventBright::User.new(["fake_user", "fake_pass"])
+    u.attribute_get(:email).should_not be_nil
+  end
+  
+  it "should return a user auth hash" do
+    u = EventBright::User.new("fake_key", true)
+    u2 = EventBright::User.new(["fake_email", "fake_pass"], true)
+    u.auth.should_not == u2.auth
+    u.auth["user_key"].should_not be_nil
+    u2.auth["user_key"].should be_nil
+    u.auth["user"].should be_nil
+    u2.auth["user"].should_not be_nil
+  end
+  
+  it "should retrieve venues" do
+    u = EventBright::User.new("fake_key", true)
+    EventBright::API.should_receive(:do_post).with("/user_list_venues", anything).and_return(fake_response("/user_list_venues"))
+    v = u.venues
+    v.should be_an EventBright::VenueCollection
+    v.should_not be_empty
+  end
+  
+  it "should cache venues" do
+    u = EventBright::User.new("fake_key", true)
+    EventBright::API.should_receive(:do_post).once.with("/user_list_venues", anything).and_return(fake_response("/user_list_venues"))
+    u.venues
+    u.venues
+    EventBright::API.should_receive(:do_post).once.with("/user_list_venues", anything).and_return(fake_response("/user_list_venues"))
+    u.dirty_venues!
+    u.venues
+  end
+  
+  it "should retrieve organizers" do
+    u = EventBright::User.new("fake_key", true)
+    EventBright::API.should_receive(:do_post).with("/user_list_organizers", anything).and_return(fake_response("/user_list_organizers"))
+    o = u.organizers
+    o.should be_an EventBright::OrganizerCollection
+    o.should_not be_empty
+  end
+  
+  it "should cache organizers" do
+    u = EventBright::User.new("fake_key", true)
+    EventBright::API.should_receive(:do_post).once.with("/user_list_organizers", anything).and_return(fake_response("/user_list_organizers"))
+    u.organizers
+    u.organizers
+    EventBright::API.should_receive(:do_post).once.with("/user_list_organizers", anything).and_return(fake_response("/user_list_organizers"))
+    u.dirty_organizers!
+    u.organizers
+  end
+  
+  it "should retrieve events" do
+    u = EventBright::User.new("fake_key", true)
+    EventBright::API.should_receive(:do_post).with("/user_list_events", anything).and_return(fake_response("/user_list_events"))
+    e = u.events
+    e.should be_an EventBright::EventCollection
+    e.should_not be_empty
+  end
+  
+  it "should cache events" do
+    u = EventBright::User.new("fake_key", true)
+    EventBright::API.should_receive(:do_post).once.with("/user_list_events", anything).and_return(fake_response("/user_list_events"))
+    u.events
+    u.events
+    EventBright::API.should_receive(:do_post).once.with("/user_list_events", anything).and_return(fake_response("/user_list_events"))
+    u.dirty_events!
+    u.events
+  end
+  
+  it "should call init_with_hash and call API if calling load" do
+    u = EventBright::User.new("fake_key", true)
+    EventBright::API.should_receive(:do_post).with("/user_get", anything).and_return(fake_response("/user_get"))
+    u.should_receive(:init_with_hash).with(instance_of(Hash), anything)
+    u.load
+  end
+  
+  it "should get an init_with_hash method" do
+    u = EventBright::User.new("fake_key", true)
+    h = fake_response("/user_get")["user"]
+    u.init_with_hash(h)
+    u.email.should_not be_nil
+  end
+  
+  it "should load attributes when calling load" do
+    u = EventBright::User.new("fake_key", true)
+    u.email.should be_nil
+    u.load
+    u.email.should_not be_nil
+  end
+  
+  it "should have a dirty-tracking update hash" do
+    u = EventBright::User.new("fake_key", true)
+    u.updatable_hash.should be_empty
+    u.load!
+    u.updatable_hash.size.should == 1
+    u.updatable_hash[:id].should_not be_nil
+    u.email = "foo"
+    u.updatable_hash.size.should == 2
+    u.updatable_hash[:email].should_not be_nil
+  end
+  
+  it "should track loaded status" do
+    u = EventBright::User.new("fake_key", true)
+    u.loaded?.should be_false
+    u.load
+    u.loaded?.should be_true
+  end
+  
+  it "should track dirty status" do
+    u = EventBright::User.new("fake_key", true)
+    # Can't be clean until we load
+    u.dirty?.should be_true
+    u.load!
+    u.dirty?.should be_false
+    u.date_modified = "now"
+    u.dirty?.should be_false
+    u.email = "banana"
+    u.dirty?.should be_true
+  end
+end