ticketmaster 0.0.1 → 0.1.0

data/NOTES

@@ -0,0 +1,18 @@
+This needs a documentation for implementing Providers and some guidelines on Provider stuff.
+
+Environment variables and config files
+    ~/.ticketmaster.yml
+    
+    
+.ticketmaster.yml
+    default: lighthouse
+    lighthouse:
+      token: 67dc50b88ea1e339eb72ba0e2b90573b6453d805
+      account: ticketmaster
+    unfuddle:
+      username: xxx
+      password: xxx
+      subdomain: xxx
+      
+      
+

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.1.0

data/lib/ticketmaster.rb

@@ -3,20 +3,42 @@
   hashie
 }.each {|lib| require lib }
 
+class TicketMaster
+end
+
 %w{
   project
   ticket
   authenticator
-}.each {|lib| require 'ticketmaster/' + lib }
-
-module TicketMasterMod
-  attr_reader :project, :client
+  provider
+  exception
+}.each {|lib| require File.dirname(__FILE__) + '/ticketmaster/' + lib }
 
-  def initialize(client, authentication = {})
-    @project = Project::Finder.new(client, authentication)
-  end
-end
 
+# This is the TicketMaster class
+#
 class TicketMaster
-  include TicketMasterMod
+  attr_reader :provider
+  
+  # This initializes the TicketMaster instance and prepares the provider
+  # If called without any arguments, it conveniently tries searching for the information in
+  # ~/.ticketmaster.yml
+  # See the documentation for more information on the format of that file.
+  #
+  # What it DOES NOT do is auto-require the provider...so make sure you have the providers required.
+  def initialize(system = nil, authentication = nil)
+    if system.nil?
+      require 'yaml'
+      data = YAML.load_file File.expand_path('~/.ticketmaster.yml')
+      system = data['default'] || data.first.first
+      authentication = data[system] if authentication.nil?
+    end
+    self.extend TicketMaster::Provider.const_get(system.to_s.capitalize)
+    authorize authentication
+  end
+  
+  # Providers should over-write this method
+  def authorize(authentication = {})
+    raise TicketMaster::Exception.new("This method must be reimplemented in the provider")
+  end
 end

data/lib/ticketmaster/authenticator.rb

@@ -1,4 +1,2 @@
-module TicketMasterMod
-  class Authenticator < Hashie::Mash
-  end
+class TicketMaster::Authenticator < Hashie::Mash
 end

data/lib/ticketmaster/dummy/dummy.rb

@@ -0,0 +1,65 @@
+module TicketMaster::Provider
+  # This is the Dummy Provider
+  #
+  # It doesn't really do anything, it exists in order to test the basic functionality of ticketmaster
+  # and to provide an example the basics of what is to be expected from the providers.
+  # 
+  # Note that the initial provider name is a module rather than a class. TicketMaster.new
+  # extends on an instance-based fashion. If you would rather initialize using code that is 
+  # closer to:
+  # 
+  #    TicketMaster::Provider::Dummy.new(authentication)
+  #
+  # You will have to do a little magic trick and define new on the provider as a wrapper
+  # around the TicketMaster.new call.
+  module Dummy
+    include TicketMaster::Provider::Base
+    @system = :dummy
+    # An example of what to do if you would like to do TicketMaster::Provider::Dummy.new(...)
+    # rather than TicketMaster.new(:dummy, ...)
+    def self.new(authentication = {})
+      TicketMaster.new(:dummy, authentication)
+      # maybe do some other stuff
+    end
+    
+    # It returns all projects...
+    def projects(*options)
+      return Project.find(*options) if options.length > 0
+      [Project.new]
+    end
+    
+    # It returns all tickets...
+    def tickets(*options)
+      return Ticket.find(*options) if options.length > 0
+      [Ticket.new]
+    end
+    
+    # Returning a single ticket based on parameters or a Ticket class if no parameters given
+    #
+    # The later is for doing:
+    #    ticketmaster.ticket.find(...)
+    #    ticketmaster.tickets.create(...)
+    #
+    # It's semantically nicer to use ticketmaster.tickets.find ... but people do strange things...
+    def ticket(*options)
+      return Ticket.new(*options) if options.length > 0
+      TicketMaster::Provider::Dummy::Ticket
+    end
+    
+    # Return a single project based on parameters or the Project class if no parameters given
+    #
+    # The later is for doing:
+    #     ticketmaster.project.find(...)
+    #     ticketmaster.tickets.create(...)
+    #
+    # (It's semantically nicer to use ticketmaster.projects.find ... but people do strange things)
+    def project(*options)
+      return Project.new(*options) if options.length > 0
+      TicketMaster::Provider::Dummy::Project
+    end
+  end
+end
+
+%w| project ticket |.each do |f|
+  require File.dirname(__FILE__) + '/' + f +'.rb'
+end

data/lib/ticketmaster/dummy/project.rb

@@ -0,0 +1,54 @@
+module TicketMaster::Provider
+  module Dummy
+    # This is the Project class for the Dummy provider
+    class Project < TicketMaster::Provider::Base::Project
+      # This serves to find projects
+      # As noted in the Project class's documentation, we should try to accept these:
+      #
+      # * find(:all) - Returns an array of all projects
+      # * find(##) - Returns a project based on that id or some other primary (unique) attribute
+      # * find(:first, :summary => 'Project name') - Returns a project based on the project's attributes
+      # * find(:summary => 'Test Project') - Returns all projects based on the given attribute(s)
+      def self.find(*options)
+        first = options.shift
+        if first.nil? or first == :all
+          [Project.new]
+        elsif first == :first
+          Project.new(options.shift)
+        elsif first.is_a?(Hash)
+          [Project.new(first)]
+        end
+      end
+      
+      # You should define @system and @system_data here.
+      # The data stuff is just to initialize fake data. In a real provider, you would use the API
+      # to grab the information and then initialize based on that info.
+      # @system_data would hold the API's model/instance for reference
+      def initialize(*options)
+        data = {:id => rand(1000).to_i, :name => 'Dummy', :description => 'Mock!-ing Bird',
+          :created_at => Time.now, :updated_at => Time.now}
+        @system = :dummy
+        super(data.merge(options.first || {}))
+      end
+      
+      # Should return all of the project's tickets
+      def tickets(*options)
+        return Ticket.find(*options) if options.length > 0
+        [Ticket.new]
+      end
+      
+      # Point it to the Dummy's Ticket class
+      def ticket(*options)
+        return Ticket.find(:first, options.first) if options.length > 0
+        Ticket
+      end
+      
+      # Nothing to save so we always return true
+      # ...unless it's an odd numbered second on Friday the 13th. muhaha!
+      def save
+        time = Time.now
+        !(time.wday == 5 and time.day == 13 and time.to_i % 2 == 1)
+      end
+    end
+  end
+end

data/lib/ticketmaster/dummy/ticket.rb

@@ -0,0 +1,54 @@
+module TicketMaster::Provider
+  module Dummy
+    # The Dummy Provider's Ticket class
+    class Ticket < TicketMaster::Provider::Base::Ticket
+      @system = :dummy
+      
+      # Find a ticket
+      #
+      # The implementation should be able to accept these cases if feasible:
+      #
+      # * find(:all) - Returns an array of all tickets
+      # * find(##) - Returns a project based on that id or some other primary (unique) attribute
+      # * find(:first, :summary => 'Ticket title') - Returns a ticket based on the ticket's attributes
+      # * find(:summary => 'Test Ticket') - Returns all tickets based on the given attributes
+      def self.find(*options)
+        first = options.shift
+        if first.nil? or first == :all
+          [Ticket.new]
+        elsif first == :first
+          Ticket.new(options.shift)
+        elsif first.is_a?(Hash)
+          [Ticket.new(first)]
+        end
+      end
+    
+      # You don't need to define an initializer, this is only here to initialize dummy data
+      def initialize(*options)
+        data = {:id => rand(1000), :status => ['lol', 'rofl', 'lmao', 'lamo', 'haha', 'heh'][rand(6)],
+          :priority => rand(10), :summary => 'Tickets ticket ticket ticket', :resolution => false,
+          :created_at => Time.now, :updated_at => Time.now, :description => 'Ticket ticket ticket ticket laughing',
+          :assignee => 'lol-man'}
+        @system = :dummy
+        super(data.merge(options.first || {}))
+      end
+      
+      # Nothing to save so we always return true
+      # ...unless it's the Ides of March and the second is divisible by three. muhaha!
+      def save
+        time = Time.now
+        !(time.wday == 15 and time.day == 3 and time.to_i % 3 == 0)
+      end
+      
+      # Nothing to close, so we always return true
+      def close
+        true
+      end
+      
+      # Nothing to destroy so we always return true
+      def destroy
+        true
+      end
+    end
+  end
+end

data/lib/ticketmaster/exception.rb

@@ -0,0 +1,2 @@
+class TicketMaster::Exception < Exception
+end

data/lib/ticketmaster/project.rb

@@ -1,82 +1,87 @@
-module TicketMasterMod
-  class Project < Hashie::Mash
-    # Find a project, or find more projects. You can also retrieve an array of all
-    # projects by not specifying any query.
+module TicketMaster::Provider
+  module Base
+    # This is the base Project class for providers
     #
-    #     unfuddle = TicketMaster.new(:unfuddle, {:username => "..", :password => "..", :subdomain => ".."})
-    #     unfuddle.project.find("ticketmaster")
-    #         #=> TicketMasterMod::Project<#name = "ticketmaster", ..>
-    #     unfuddle.project.find
-    #         #=> [TicketMasterMod::Project<..>, TicketMasterMod::Project<..>, ..]
+    # Providers should inherit this class and redefine the methods
+    # 
+    # Each provider should have their own @system defined.
+    # For example, ticketmaster-unfuddle's @system is :unfuddle and ticketmaster-lighthouse's
+    # @system is :lighthouse.
     #
-    def self.find(query = nil, options = {})
-      # Asks the client for the projects, should return an array of
-      # project objects.
-      projects = TicketMasterMod.const_get(options[:client].to_s.capitalize)::Project.find(query, options)
-      
-      if query
-        query = {:name => query} if query.is_a?(String)
-
-        # For some reason #tickets find ability messes up if we use a class method.
-        # Thus I decided to go for an instance method.
-        return Project.new.search(query, projects)
-      end
-
-      # No query, so we just go ahead and return the array of projects
-      projects
-    end
-
-    # Asks the client for the tickets associated with the project,
-    # returns an array of Ticket objects.
+    # Methods that must be implemented by the provider
     #
-    #     project.tickets
-    #         #=> [TicketMasterMod::Ticket<...>, TicketMasterMod::Ticket<...>, ..]
-    def tickets(query = {})
-      tickets = TicketMasterMod.const_get(self.system.capitalize)::Project.tickets(self)
-      return search(query, tickets) unless query.empty?
-
-      tickets
-    end
-
-    # Mainly here because it is more natural to do:
-    #     project.ticket.create(..)
+    # * self.find
+    # * tickets
+    # * ticket
+    # * save
+    # * initialize
     #
-    # Than
-    #     project.tickets.create(..)
-    def ticket
-      TicketMasterMod::Ticket::Creator.new(self)
-    end
-
-    def search(query, objects)
-      matching_objects = []
-
-      objects.each do |object|
-        matches = 0
-        query.each_pair do |method, expected_value|
-          matches += 1 if object.send(method) == expected_value
-        end
-
-        matching_objects << object if matches == query.length
+    # Methods that would probably be okay if the provider left it alone:
+    #
+    # * self.create
+    #
+    # A provider should define as many attributes as feasibly possible. The list below are 
+    # some guidelines as to what attributes are necessary, if your provider's api does not
+    # implement them, point it to an attribute that is close to it. (for example, a name
+    # can point to title. Remember to alias it in your class!)
+    # 
+    # * id
+    # * name
+    # * created_at
+    # * updated_at
+    # * description
+    class Project < Hashie::Mash
+      attr_accessor :system, :system_data
+      # Find a project, or find more projects.
+      # You can also retrieve an array of all projects by not specifying any query.
+      #
+      # The implementation should be able to accept these cases if feasible:
+      #
+      # * find(:all) - Returns an array of all projects
+      # * find(##) - Returns a project based on that id or some other primary (unique) attribute
+      # * find(:first, :summary => 'Project name') - Returns a project based on the project's attributes
+      # * find(:summary => 'Test Project') - Returns all projects based on the given attribute(s)
+      def self.find(*options)
+        raise TicketMaster::Exception.new("This method must be reimplemented in the provider")
       end
-
-      # Raw object versus array with one entry
-      return matching_objects.first if matching_objects.length == 1
-      matching_objects
-    end
-
-    class Finder
-      def initialize(client, authentication)
-        @client = client
-        @authentication = Authenticator.new(authentication)
+      
+      # Create a project.
+      # Basically, a .new and .save in the same call. The default method assumes it is passed a
+      # single hash with attribute information
+      def self.create(*options)
+        project = self.new(options.first)
+        project.save
+        project
+      end
+      
+      # The initializer
+      def initialize(*options)
+        super(options.shift)
+        # do some other stuff
       end
 
-      def find(query = nil, options = {})
-        options[:authentication] = @authentication
-        options[:client] = @client
-        Project::find(query, options)
+      # Asks the provider's api for the tickets associated with the project,
+      # returns an array of Ticket objects.
+      def tickets(*options)
+        raise TicketMaster::Exception.new("This method must be reimplemented in the provider")
       end
 
-      alias_method :[], :find
+      # Mainly here because it is more natural to do:
+      #     project.ticket.create(..)
+      #
+      # Than
+      #     project.tickets.create(..)
+      # 
+      # returns a ticket object or ticket class that responds to .new and .create. 
+      def ticket(*options)
+        raise TicketMaster::Exception.new("This method must be reimplemented in the provider")
+      end
+      
+      # Save changes to this project
+      def save
+        raise TicketMaster::Exception.new("This method must be reimplemented in the provider")
+      end
+      
     end
   end
 end

data/lib/ticketmaster/provider.rb

@@ -0,0 +1,68 @@
+# This is the TicketMaster::Provider Module
+#
+# All provider classes will extend into this module. 
+# See the Dummy provider's code for some specifics on implementing a provider
+#
+# Currently, only Projects and Tickets are standardized in ticket master. Therefore,
+# if your provider has other types--such as People/Members, Messages, Milestones, Notes,
+# Tags, etc--you may implement it at your discretion. We are planning to eventually
+# incorporate and standardize many of these into the overall provider. Keep on the look out for it!
+#
+# We are also planning on standardizing non-standard/provider-specific object models
+module TicketMaster::Provider
+  module Base
+    # All providers must define this method.
+    # It doesn't *have* to do anything, it just has to be there. But since it's here, you don't
+    # have to worry about it as long as you "include TicketMaster::Provider::Base"
+    #
+    # If you need to do some additional things to initialize the instance, here is where you would put it
+    def authorize(authentication = {})
+      @authentication = TicketMaster::Authenticator.new(authentication)
+    end
+    
+    # Providers should try to define this method
+    #
+    # It returns the project class for this provider, so that there can be calls such as
+    #    ticketmaster.project.find :all
+    #    ticketmaster.project(:id => 777, :name => 'Proj test')
+    #
+    # Should try to implement a find :first (or find with singular result) if given parameters
+    def project(*options)
+      return TicketMaster::Project.find(*options) if options.length > 0
+      TicketMaster::Project
+    end
+    
+    # Providers should try to define this method
+    #
+    # It returns the ticket class for this provider, so that there can be calls such as
+    #    ticketmaster.ticket.find :all
+    #    ticketmaster.ticket(:id => 102, :title => 'Ticket')
+    #
+    # Don't confuse this with project.ticket.find(...) since that deals with tickets specific to a
+    # project. This is deals with tickets
+    #
+    # Should try to implement a find :first (or find with singular result) if given parameters
+    def ticket(*options)
+      return TicketMaster::Ticket.find(*options) if options.length > 0
+      TicketMaster::Ticket
+    end
+    
+    # All providers should try to define this method.
+    #
+    # It returns all projects in an array
+    # Should try to implement a find :all if given parameters
+    def projects(*options)
+      []
+    end
+      
+    # All providers should try to define this method
+    #
+    # It returns all tickets in an array.
+    # Should try to implement a find :all if given parameters
+    def tickets(*options)
+      []
+    end
+  end
+end
+
+

data/lib/ticketmaster/ticket.rb

@@ -1,27 +1,120 @@
-module TicketMasterMod
-  class Ticket < Hashie::Mash
-    def create
-      TicketMasterMod.const_get((self.system || self.project.system).to_s.capitalize)::Ticket.create(self)
-    end
-
-    def close(resolution = {})
-      TicketMasterMod.const_get(self.system.to_s.capitalize)::Ticket.close(self, resolution)
-    end
-
-    def save
-      TicketMasterMod.const_get(self.system.to_s.capitalize)::Ticket.save(self)
-    end
-
-    class Creator
-      def initialize(system)
-        @system = {:project => system}
+module TicketMaster::Provider
+  module Base
+    # The base ticket class for ticketmaster
+    # All providers should inherit this class
+    #
+    # The difference between the class methods and instance methods are that the instance
+    # methods should be treated as though they are called on a known ticket and the class
+    # methods act based on a blank slate (which means the info to find a specific ticket has
+    # to be passed in the parameters in the ticket)
+    #
+    # Methods that a provider must define:
+    #
+    # * self.find
+    # * close
+    # * save
+    # * destroy
+    #
+    # Methods that the provider should define if feasible:
+    #
+    # * reload!
+    # * initialize
+    #
+    # Methods that would probably be okay if the provider left it alone:
+    #
+    # * self.create
+    # * update
+    # * update!
+    #
+    # A provider should define as many attributes as feasibly possible. The list below are 
+    # some guidelines as to what attributes are necessary, if your provider's api does not
+    # implement them, point it to an attribute that is close to it. (for example, a summary
+    # can point to title. and assignee might point to assigned_to. Remember to alias it in your class!)
+    # 
+    # * id
+    # * status
+    # * priority
+    # * summary
+    # * resolution
+    # * created_at
+    # * updated_at
+    # * description
+    # * assignee
+    class Ticket < Hashie::Mash
+      @ignore_inspect = %w| system system_data |
+      @system = nil # The symbol for the provider.
+      @system_data = nil # The system info for the provider
+      attr_accessor :system, :system_data
+      # Find a ticket
+      #
+      # The implementation should be able to accept these cases if feasible:
+      #
+      # * find(:all) - Returns an array of all tickets
+      # * find(##) - Returns a project based on that id or some other primary (unique) attribute
+      # * find(:first, :summary => 'Ticket title') - Returns a ticket based on the ticket's attributes
+      # * find(:summary => 'Test Ticket') - Returns all tickets based on the given attributes
+      def self.find(*options)
+        raise TicketMaster::Exception.new("This method must be reimplemented in the provider")
+      end
+      
+      # Create a ticket.
+      # Basically, a .new and .save in the same call. The default method assumes it is passed a
+      # single hash with attribute information
+      def self.create(*options)
+        ticket = self.new(options.first)
+        ticket.save
+      end
+      
+      # Instantiate a new ticket (but don't save yet!)
+      # The default method assumes a single hash with all the parameters is passed to Ticket.new
+      def initialize(*options)
+        super(options.first)
+        # do some other stuff
       end
 
-      def create(ticket_hash)
-        ticket_hash.merge!(@system)
-        ticket = TicketMasterMod::Ticket.new(ticket_hash)
-        ticket.create
+      # Close this ticket
+      #
+      # On success it should return true, otherwise false
+      def close(*options)
+        raise TicketMaster::Exception.new("This method must be reimplemented in the provider")
+      end
+      
+      # Save this ticket
+      # Expected return value of true (successful) or false (failure)
+      def save(*options)
+        raise TicketMaster::Exception.new("This method must be reimplemented in the provider")
+      end
+      
+      # Reload this ticket
+      def reload!(*options)
+        raise TicketMaster::Exception.new("This method must be reimplemented in the provider")
+      end
+      
+      # Delete this ticket
+      #
+      # If your provider doesn't have a delete or trash option for tickets:
+      #    raise TicketMaster::Exception.new("Tickets can not be destroyed on SomeProviderAPI")
+      def destroy(*options)
+        raise TicketMaster::Exception.new("This method must be reimplemented in the provider")
       end
+      
+      # Update a ticket and save
+      #
+      # The default assumes the options passed to it is a single hash with the attributes to update
+      def update!(*options)
+        update(options.first)
+        save
+      end
+      
+      # Update a ticket's attributes, but no save
+      # Used when you need to do mass attribute assignment
+      def update(*options)
+        options.first.each do |k, v|
+          self.send(k + '=', v)
+        end
+        self
+      end
+
     end
   end
 end

data/spec/spec.opts

@@ -0,0 +1 @@
+--color

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'ticketmaster.rb'
+require 'ticketmaster/dummy/dummy.rb'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

data/spec/ticketmaster_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+# This can also act as an example test or test skeleton for your provider.
+# Just replace the Dummy in @project_class and @ticket_class
+# Also, remember to mock or stub any API calls
+describe "Ticketmaster" do
+  before(:each) do
+    @ticketmaster = TicketMaster.new(:dummy)
+    @project_class = TicketMaster::Provider::Dummy::Project
+    @ticket_class = TicketMaster::Provider::Dummy::Ticket
+  end
+  
+  # Essentially just a sanity check on the include since .new always returns the object's instance
+  it "should be able to instantiate a new instance" do
+    @ticketmaster.should be_an_instance_of TicketMaster
+    @ticketmaster.should be_a_kind_of TicketMaster::Provider::Dummy
+  end
+  
+  it "should be able to load projects" do
+    @ticketmaster.projects.should be_an_instance_of Array
+    @ticketmaster.projects.first.should be_an_instance_of @project_class
+    @ticketmaster.projects.first.description.should == "Mock!-ing Bird"
+    @ticketmaster.projects(:id => 555).should be_an_instance_of Array
+    @ticketmaster.projects(:id => 555).first.should be_an_instance_of @project_class
+    @ticketmaster.projects(:id => 555).first.id.should == 555
+    
+    @ticketmaster.project.should == @project_class
+    @ticketmaster.project(:name => "Whack whack what?").should be_an_instance_of @project_class
+    @ticketmaster.project(:name => "Whack whack what?").name.should == "Whack whack what?"
+    @ticketmaster.project.find(:first, :description => "Shocking Dirb").should be_an_instance_of @project_class
+    @ticketmaster.project.find(:first, :description => "Shocking Dirb").description.should == "Shocking Dirb"
+  end
+  
+  it "should be able to do project stuff" do
+    info = {:id => 777, :name => "Tiket Name  c", :description => "that c thinks the k is trying to steal it's identity"}
+    @ticketmaster.project.create(info).should be_an_instance_of @project_class
+    @ticketmaster.project.new(info).should be_an_instance_of @project_class
+    @ticketmaster.project.create(info).id.should == 777
+    @ticketmaster.project.new(info).id.should == 777
+    
+    @ticketmaster.projects.first.save.should == true
+  end
+  
+  it "should be able to load tickets" do
+    project = @ticketmaster.projects.first
+    project.tickets.should be_an_instance_of Array
+    project.tickets.first.should be_an_instance_of @ticket_class
+    project.tickets(:id => 999).should be_an_instance_of Array
+    project.tickets(:id => 999).first.should  be_an_instance_of @ticket_class
+    project.tickets(:id => 999).first.id.should == 999
+    
+    project.ticket.should ==  TicketMaster::Provider::Dummy::Ticket
+    project.ticket(:id => 888).should be_an_instance_of @ticket_class
+    project.ticket(:id => 888).id.should == 888
+    project.ticket.find(:first, :id => 888).should be_an_instance_of @ticket_class
+    project.ticket.find(:first, :id => 888).id.should == 888
+  end
+end

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: ticketmaster
 version: !ruby/object:Gem::Version 
+  hash: 27
   prerelease: false
   segments: 
   - 0
-  - 0
   - 1
-  version: 0.0.1
+  - 0
+  version: 0.1.0
 platform: ruby
 authors: 
 - Sirupsen
@@ -15,16 +16,18 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-12 00:00:00 +02:00
+date: 2010-06-22 00:00:00 +02:00
 default_executable: ticket
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: hashie
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
@@ -34,9 +37,11 @@ dependencies:
   name: shoulda
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
+        hash: 3
         segments: 
         - 0
         version: "0"
@@ -55,17 +60,26 @@ files:
 - .document
 - .gitignore
 - LICENSE
+- NOTES
 - README.md
 - Rakefile
 - VERSION
 - bin/ticket
+- lib/console.rb
 - lib/ticketmaster.rb
 - lib/ticketmaster/authenticator.rb
+- lib/ticketmaster/dummy/dummy.rb
+- lib/ticketmaster/dummy/project.rb
+- lib/ticketmaster/dummy/ticket.rb
+- lib/ticketmaster/exception.rb
 - lib/ticketmaster/project.rb
+- lib/ticketmaster/provider.rb
 - lib/ticketmaster/ticket.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- spec/ticketmaster_spec.rb
 - test/helper.rb
 - test/test_ticketmaster.rb
-- test/test_unfuddler.rb
 has_rdoc: true
 homepage: http://ticketrb.com
 licenses: []
@@ -76,27 +90,32 @@ rdoc_options:
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 1.3.7
 signing_key: 
 specification_version: 3
 summary: Ticketmaster provides a universal API to trouble ticket and project management systems.
 test_files: 
-- test/test_unfuddler.rb
+- spec/spec_helper.rb
+- spec/ticketmaster_spec.rb
 - test/test_ticketmaster.rb
 - test/helper.rb

data/test/test_unfuddler.rb

@@ -1,75 +0,0 @@
-require 'helper'
-require 'ticketmaster-unfuddle'
-
-class TestTicketmaster < Test::Unit::TestCase
-  context "Unfuddle" do
-    setup do
-      @unfuddle = TicketMaster.new(:unfuddle, {:username => "", :password => "", :subdomain => "ticketmaster"})
-      @project = @unfuddle.project.find.first
-    end
-
-    should "find testproject" do
-      project = @unfuddle.project.find(:name => "testproject")
-
-      assert_instance_of TicketMasterMod::Project, project
-      assert_equal "testproject", project.name
-
-      #method 2
-      project = @unfuddle.project.find("testproject")
-
-      assert_instance_of TicketMasterMod::Project, project
-      assert_equal "testproject", project.name
-
-      #method 3
-      project = @unfuddle.project["testproject"]
-
-      assert_instance_of TicketMasterMod::Project, project
-      assert_equal "testproject", project.name
-    end
-
-    context "project instance" do
-      should "find a project" do
-        assert_instance_of TicketMasterMod::Project, @project
-      end
-    
-      should "find a bunch of tickets" do
-        @project.tickets
-      end
-
-      should "find new tickets" do
-        tickets = @project.tickets(:status => "new")
-
-        tickets.each do |ticket|
-          assert_equal "new", ticket.status
-        end
-      end
-
-      should "find ticket with id 1" do
-        ticket = @project.tickets(:id => 1)
-
-        assert_equal 1, ticket.id
-      end
-
-      should "create a ticket" do
-        assert @project.ticket.create(:priority => 3, :summary => "Test", :description => "Hello World from TicketMaster::Unfuddle").empty?
-      end
-    
-      should "change ticket property" do
-        ticket = @project.tickets.last
-        ticket.description = "Edited description"
-        assert ticket.save.empty?
-    
-        ticket = @project.tickets.last
-        assert_equal "Edited description", ticket.description
-      end
-    
-      should "close the last ticket with a resolution" do
-        ticket = @project.tickets.last
-        assert ticket.close(:resolution => "fixed", :description => "Fixed issue").empty?
-    
-        ticket = @project.tickets.last
-        assert_equal "fixed", ticket.resolution
-      end
-    end
-  end
-end