eventbright 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 David Haslem
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,92 @@
+eventbright
+================
+
+A simple library for integrating with EventBrite's API. Requires the "httparty" gem for connecting and doing XML parsing, and "tzinfo" gem for getting back and forth between timezone names and GMT offsets.
+
+Usage
+-----
+
+    require 'eventbright'
+    EventBright.setup("APP_KEY")
+    user = EventBright::User.new("USER_KEY") #=> <EventBright::User >
+    user.venues #=> [<EventBright::Venue>,...] # Venues the user has defined
+
+Authentication
+--------------
+Many methods require user authentication. For these methods, you can pass a user object as an authentication token, and the user's api_key will automatically be used for the request. 
+
+Example:
+    
+    EventBright::Event.new({"x" => "y"... , "user" => user})
+
+Known Bugs
+----------
+
+1. This library's testing coverage is almost zero. I'm working on it.
+2. There is no subuser support.
+
+A Note About App Keys
+---------------------
+
+This gem has an application key for accessing EventBrite, but each app key is limited to 30,000 requests a day. To make sure your limits aren't affected by others, you should register for your own app key specific to the application you're adding the gem to. 
+
+If you just want to give the gem a whirl (you have to wait for approval to get your own) just don't call setup. The app key for the gem will be used.
+
+Learn more about EventBrite's App Key policy here: [Terms of Service](http://www.eventbrite.com/api/terms)
+
+Register for your own app key here: [Request a Key](http://www.eventbrite.com/api/key/)
+
+
+API Gotchas:
+--------------------
+
+A list of sticking points for anyone attempting their own integration with the EventBrite API:
+
+__/get => /update variable inconsistencies__
+
+* event.id => event.event_id
+* event.timezone (Olson format, ex: "US/Central") => event.timezone (GMT offset hours, ex: "GMT-05")
+* event.privacy (String representing privacy "Private"|"Public") => event.privacy (Boolean 0 = public)
+* event.url => event.personalized_url
+* venue.address => venue.adress
+* venue.address_2 => venue.adress_2
+* venue.name => venue.venue
+* event.tickets.ticket.start_date => ticket.start_sales
+* event.tickets.ticket.end_date => ticket.end_sales
+* event.tickets.ticket.visible (1 is visible) => ticket.hide (y is hidden, n is visible)
+* event.tickets.ticket.quantity_available => ticket.quantity
+
+__Fields you can't edit__
+
+* event.category
+* event.tags
+* event.logo
+* ticket.hide (on /ticket_new. You must save the ticket then call /ticket_update to hide)
+
+__Documentation errors__
+
+* /venue_new and /venue_update does not throw an error if "venue" is invalid/non-unique/empty.
+* Dates are not technically ISO 8601 (ISO 8601 specifies a "T" - not a space - between date and time, so passing perfectly formatted ISO 8601 datetime strings such as those a standard library would provide will cause errors)
+* Error description for event Privacy Error: <pre>"The privacy field must be equal to 0 (public) or 1 (private)"</pre> -> This is the opposite of the actual case. 0 is private and 1 is public, as described in other places within the API.
+* /ticket_new and /ticket_update do not throw errors if quantity not set
+
+__Other gotchas__
+
+* Venue object included in event has extra "Lat-Long" attribute, along with "latitude" and "longitude". If you're turning a result into an object, this might cause an error if you don't suspect it.
+* Timezones are weird (nothing EventBrite can do about this one): GMT offset for timezones is always computed in standard time (don't adjust for Daylight Savings, unlike UTC offset). This weirdness means that once you save the timezone the Olson description might not match what you think it should (ex. US/Eastern becomes GMT-5 which then becomes America/Bogota)
+
+Note on Patches/Pull Requests
+-----------------------------
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+Copyright
+---------
+
+Copyright (c) 2010 David Haslem. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "eventbright"
+    gem.summary = %Q{An unofficial gem for EventBrite Integration}
+    gem.description = %Q{A simple, unoffical gem that integrates with the EventBrite events service. (http://www.eventbrite.com)}
+    gem.email = "therabidbanana@gmail.com"
+    gem.homepage = "http://github.com/therabidbanana/eventbright"
+    gem.authors = ["David Haslem"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_dependency "httparty", ">= 0.5.2"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :irb
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "eventbright #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+desc "Runs irb with eventbright lib"
+task :irb do
+  sh "irb -r 'lib/eventbright'"
+end

data/VERSION

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

data/lib/eventbright.rb

@@ -0,0 +1,5 @@
+libdir = File.dirname(__FILE__)
+$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+require File.join(libdir, 'eventbright', 'main.rb')
+Dir.glob(File.join(libdir, 'eventbright', '*.rb')).each {|f| require f }
+Dir.glob(File.join(libdir, 'eventbright', 'api_objects', '*.rb')).each {|f| require f }

data/lib/eventbright/api_object.rb

@@ -0,0 +1,180 @@
+require 'eventbright/api_object_class_methods'
+require 'eventbright/api_object_relationships'
+module EventBright
+  class ApiObject
+    extend EventBright::ApiObjectClassMethods
+    include EventBright::ApiObjectRelationships
+    attr_accessor :id, :owner
+    attr_accessor :attributes, :relations, :collections
+    attr_accessor :dirty, :dirty_relations, :dirty_collections
+    
+    def initialize(owner = false, hash = {})
+      preinit
+      unless hash.empty?
+        @id = hash.delete(:id)
+        @owner = owner if owner
+        load(hash, true)
+        init
+      end
+    end
+    
+    def preinit
+      @attributes = @relations = @collections = {}
+      @dirty = @dirty_relations = @dirty_collections = {}
+    end
+    
+    def clean!
+      @dirty = @dirty_relations = @dirty_collections = {}
+    end
+    
+    # Callback after initialization
+    def init; end
+    
+    def attribute_get(key);   @attributes[key];   end
+   
+    def attribute_set(key, val, no_dirty = false)
+      @dirty[key] = true if(@attributes[key] != val && !no_dirty)
+      @attributes[key] = val
+      after_attribute_set
+    end
+    
+    def after_attribute_set
+    end
+    
+    
+    def id=(new_id,*args)
+      @id = new_id.to_int
+    end
+    
+    def load(hash = {}, no_dirty = false)
+      if hash.nil? || hash.size == 0
+        response = EventBright.call("#{self.class.singlet_name}_get", prep_api_hash('get'))
+        hash = response["#{self.class.singlet_name}"]
+      end
+      unless hash.nil? || hash.size == 0
+        init_with_hash(hash, no_dirty)
+        load_relations_with_hash(hash, no_dirty)
+        load_collections_with_hash(hash, no_dirty)
+      end
+      clean! if no_dirty
+      after_load(hash)
+    end
+    
+    
+    def init_with_hash(hash, no_dirty = false)
+      @attributes ||= {}
+      hash.each do |k, v| 
+        self.__send__("#{k}=", v, no_dirty) unless (self.class.ignores.include?(k) ||
+                                                    self.class.ignores.include?(k.to_sym)) ||
+                                                    self.class.relations.include?(k) ||
+                                                    self.class.relations.include?(k.to_sym) ||
+                                                    self.class.collections.include?(k) ||
+                                                    self.class.collections.include?(k.to_sym)
+      end
+    end
+    
+    
+    # A callback for after loads
+    def after_load(hash = {})
+      hash
+    end
+    
+    # A callback for methods to clean up the hash a bit
+    # allowing subclasses to insert the user if necessary
+    def prep_api_hash(method = 'get', hash = {})
+      hash = hash.merge api_hash
+      hash = hash.merge get_hash if method == 'get'
+      hash = hash.merge new_hash if method == 'new'
+      hash = hash.merge update_hash if method == 'update'
+      hash
+    end
+    
+    # Callbacks for individual hash changes
+    # These are added to the updatable_hash, if appropriate
+    # These are called by prep_api_hash
+    def api_hash;     {:user => owner};  end
+    def update_hash;  {};                 end
+    def get_hash;     {};                 end
+    def new_hash;     {};                 end
+    
+    def nested_hash;  {:user => owner, :id => id}; end
+    
+    
+    # Forces a clean load from the remote API. Load can be passed a hash of local
+    # values to avoid an API call, but this circumvents it.
+    def load!
+      load({}, true)
+    end
+    
+    
+    # Callback that happens before saving. Allows modification of options
+    def before_save(opts = {});   opts;     end
+    
+    # Save function. Can alter functionality by changing callbacks
+    def save(opts = {})
+      return false unless dirty?
+      opts.merge!(updatable_hash(self.class.requires))
+      opts = relations_save(opts)
+      opts = before_save(opts)
+      call = if loaded?
+        c = EventBright.call("#{self.class.singlet_name}_update", prep_api_hash('update', opts))
+        after_update
+        c
+      else
+        c = EventBright.call("#{self.class.singlet_name}_new", prep_api_hash('new', opts))
+        after_new
+        c
+      end
+      self.id = call["process"]["id"] unless loaded?
+      collections_save
+      after_save
+      clean!
+      call
+    end
+    
+    # After save callback, only called on a new call
+    def after_new;    end
+    # After save callback, only called on an update call
+    def after_update; end
+    # After save callback
+    def after_save; end
+    
+    
+    def updatable_hash(always_dirty = [])
+      updates = {}
+      @attributes.each do |k, v|
+        updates[k] = @attributes[k] if @dirty[k] || always_dirty.include?(k)
+      end
+      updates.merge! :id => @id if @id
+      self.class.reformats.each do |k|
+        updates[k] = self.__send__(k) if updates[k]
+      end
+      self.class.renames.each do |k,v|
+        updates[v] = updates.delete(k) if updates[k]
+      end
+      updates
+    end
+    
+    def inspect
+      "#<#{self.class.to_s}:#{self.id} @attributes=#{@attributes.inspect}>"
+    end
+    
+    def to_s
+      "#<#{self.class.to_s}:#{self.id} @attributes=#{@attributes.inspect}>"
+    end
+    
+    # Defines whether the object has been loaded from a remote source. If not, then
+    # we assume it's new when saving.
+    def loaded?
+      (!@id.nil? || @id == "")
+    end
+    
+    # Something is dirty if it's never been loaded or if the @dirty
+    # hash contains something. 
+    def dirty?
+      @dirty ||= {}
+      @dirty.size > 0 || !loaded?
+    end
+    
+  end
+end

data/lib/eventbright/api_object_class_methods.rb

@@ -0,0 +1,117 @@
+module EventBright
+  module ApiObjectClassMethods
+    def singlet_name(name = false)
+      @singlet_name = name if name
+      @singlet_name || self.to_s.gsub('EventBright::', '').downcase
+    end
+  
+    def plural_name(name = false)
+      @plural_name = name if name
+      @plural_name || "#{self.singlet_name}s"
+    end
+  
+    def ignores(*args)
+      @ignores ||= []
+      @ignores.concat(args) unless args.empty?
+      @ignores
+    end
+    
+    def requires(*args)
+      @requires ||= []
+      @requires.concat(args) unless args.empty?
+      @requires
+    end
+    
+    # Columns to reformat when sending outgoing data
+    # (Reformatting is assumed to be done by calling the method with the
+    # same name as the attribute, so to reformat foo, use def foo... with 
+    # an attribute_get inside)
+    def reformats(*args)
+      @reformats ||= []
+      @reformats.concat(args) unless args.empty?
+      @reformats
+    end
+    
+    # Columns to rename when sending outgoing data
+    def renames(attrs = false)
+      @renames ||= {}
+      @renames.merge!(attrs) if attrs
+      @renames
+    end
+  
+    def updatable(*args)
+      args.each{|symbol|
+        module_eval( "def #{symbol}(); attribute_get(:#{symbol});  end")
+        module_eval( "def #{symbol}=(val, no_dirty = false); attribute_set(:#{symbol}, val, no_dirty); end")
+      }
+    end
+  
+    def readable(*args)
+      args.each{|symbol|
+      
+        module_eval( "def #{symbol}(); attribute_get(:#{symbol}); end")
+        module_eval( "def #{symbol}=(val, no_dirty = false); attribute_set(:#{symbol}, val, true); end")
+      }
+    end
+  
+    def updatable_date(*args)
+      args.each{|symbol|
+      
+        module_eval( "def #{symbol}(); EventBright.formatted_time(attribute_get(:#{symbol})); end")
+        module_eval( "def #{symbol}=(val, no_dirty = false); attribute_set(:#{symbol}, Time.parse(val), no_dirty); end")
+      }
+    end
+  
+    def readable_date(*args)
+      args.each{|symbol|
+      
+        module_eval( "def #{symbol}(); EventBright.formatted_time(attribute_get(:#{symbol})); end")
+        module_eval( "def #{symbol}=(val, no_dirty = false); attribute_set(:#{symbol}, Time.parse(val), true); end")
+      }
+    end
+    
+    # Columns that are the same as other columns. This is mainly useful
+    # for incoming data with inconsistent naming. Args are passed as a hash,
+    # where the key is the new method name, and the value is the target method name
+    # you are mapping the new one onto. Note that this  means there is only the original
+    # one stored on the object. Also note this is different from the 
+    # renames list, which is exclusively for outgoing hashes sent to the API.
+    def remap(args = {})
+      args.each{|k,v|
+        module_eval( "def #{k}(); #{v};  end")
+        module_eval( "def #{k}=(val,no_dirty = false); self.__send__('#{v}=', val, no_dirty); end")
+      }
+    end
+    
+    # Defines a has 1 relation
+    def has(args = {})
+      @class_relations ||= {}
+      args.each{|symbol, klass|
+        module_eval( "def #{symbol}(); relation_get(:#{symbol});  end")
+        module_eval( "def dirty_#{symbol}!(); relation_dirty!(:#{symbol});  end")
+        module_eval( "def dirty_#{symbol}?(); relation_dirty?(:#{symbol});  end")
+        module_eval( "def #{symbol}=(val, no_dirty = false); relation_set(:#{symbol}, val, no_dirty); end")
+        @class_relations[symbol] = klass
+      }
+    end
+    def relations
+      @class_relations || {}
+    end
+    
+    # Defines a has may relation
+    def collection(args = {})
+      @class_collections ||= {}
+      args.each{|symbol, klass|
+        module_eval( "def #{symbol}(); collection_get(:#{symbol});  end")
+        module_eval( "def dirty_#{symbol}!(); collection_dirty!(:#{symbol});  end")
+        module_eval( "def dirty_#{symbol}?(); collection_dirty?(:#{symbol});  end")
+        module_eval( "def #{symbol}=(val, no_dirty = false); collection_set(:#{symbol}, val, no_dirty); end")
+        @class_collections[symbol] = klass
+      }
+    end
+    def collections
+      @class_collections || {}
+    end
+
+  end
+end