ticketmaster 0.1.0 → 0.3.1

data/lib/ticketmaster/cli/common.rb

@@ -0,0 +1,27 @@
+# Parses the configuration information and puts it into options
+def parse_config!(options)
+  config = YAML.load_file File.expand_path(options[:config])
+  provider = (options[:provider] ||= config['default'] || config.first.first)
+  if provider and provider.length > 0
+    options[:project] ||= config[provider]['project']
+    options[:authentication] ||= config[provider]['authentication']
+  end
+  options
+end
+
+# A utility method used to separate name:value pairs
+def attributes_hash(kvlist)
+  if kvlist.is_a?(String)
+    kvlist.split(',').reduce({}) do |mem, kv|
+      key, value = kv.split(':')
+      mem[key] = value
+      mem
+    end
+  elsif kvlist.is_a?(Array)
+    mem = {}
+    kvlist.each_slice(2) do |k, v|
+      mem[k] = v
+    end
+    mem
+  end
+end

data/lib/ticketmaster/cli/init.rb

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'yaml'
+require File.dirname(__FILE__) + '/common.rb'
+
+
+commands ={ 'help' => 'Get the help text for a particular command',
+  'console' => 'Open up a ticketmaster console session',
+  'config' => 'Setup and configure a ticketmaster.yml file',
+  'ticket' => 'Work with tickets (create, edit, delete, etc)',
+  'project' => 'Work with projects (create, edit, delete, etc)',
+  }
+
+helptext = lambda {
+  helpmsg = "\nAvailable commands:\n"
+  commands.sort.reduce(helpmsg) { |mem, cmd| mem << "\t#{cmd.join("\t\t")}\n" }
+  helpmsg << "\nSee 'ticket help COMMAND' for more information on a specific command."
+  }
+  
+ARGV << '--help' if ARGV.length == 0
+
+options = {:original_argv => ARGV.dup}
+
+if File.exist?(options[:config] = File.expand_path('ticketmaster.yml'))
+elsif File.exist?(options[:config] = File.expand_path('config/ticketmaster.yml'))
+elsif ENV['TICKETMASTER_CONFIG'] and File.exist?(options[:config] = File.expand_path(ENV['TICKETMASTER_CONFIG']))
+else
+  options[:config] = File.expand_path('~/.ticketmaster.yml')
+end
+
+begin
+  OptionParser.new do |opts|
+    opts.banner = 'Usage: ticket [options] COMMAND [command_options]'
+    opts.separator ''
+    opts.separator 'Options:'
+    
+    opts.on('-c', '--config CONFIG', 'Use CONFIG as the configuration file. default: ~/.ticketmaster.yml') do |c|
+      options[:config] = c
+    end
+  
+    opts.on('-p', '--provider PROVIDER', 'Specifies the provider') { |p| options[:provider] = p }
+    
+    opts.on('-A', '--authentication AUTH',
+      'Specifies authentication information, comma-separated list of name:value pairs.',
+      'Note: The whole list must be enclosed in quotes if there are any spaces.') do |a|
+      options[:authentication] = attributes_hash(a)
+    end
+    
+    opts.on('-P', '--project PROJECT', 'Specifies the working project') { |p| options[:project] = p }
+    
+    opts.separator ''
+    opts.separator 'Other options:'
+    
+    opts.on_tail('-h', '--help', 'Show this message') do
+      puts opts
+      puts helptext.call
+      exit
+    end
+  end.order!
+rescue OptionParser::MissingArgument => exception
+  puts "ticket #{ARGV.join(' ')}\n\n"
+  puts "Error: An option was called that requires an argument, but was not given one"
+  puts exception.message
+end
+
+command = ARGV.shift
+if commands[command]
+  require File.dirname(__FILE__) + '/commands/' + command
+  send(command, options)
+else
+  puts "'#{command}' is not a ticketmaster command\n\n", helptext.call
+  exit
+end

data/lib/ticketmaster/comment.rb

@@ -0,0 +1,97 @@
+module TicketMaster::Provider
+  module Base
+    # The comment class
+    #
+    # This will probably one of the most troublesome parts of creating a provider for ticketmaster
+    # since there are so many different ways comments are handled by different APIs.
+    # Keep in mind that if you do need to change/overwrite the methods, you will most likely
+    # only need to overwrite #find_by_id, #find_by_attributes, #search, and possibly #initialize
+    # as long as their parameters conform to what the find method expects.
+    #
+    # Here are the expected attributes:
+    #
+    # * author
+    # * body
+    # * id
+    # * created_at
+    # * updated_at
+    # * ticket_id
+    # * project_id
+    class Comment < Hashie::Mash
+      include TicketMaster::Provider::Common
+      include TicketMaster::Provider::Helper
+      extend TicketMaster::Provider::Helper
+      attr_accessor :system, :system_data
+      API = nil # Replace with your comment's API's Class
+
+      # Find comment
+      # You can also retrieve an array of all comments by not specifying any query.
+      #
+      # * find(<project_id>, <ticket_id>) or find(<project_id>, <ticket_id>, :all) - Returns an array of all comments
+      # * find(<project_id>, <ticket_id>, ##) - Returns a comment based on that id or some other primary (unique) attribute
+      # * find(<project_id>, <ticket_id>, [#, #, #]) - Returns many comments with these ids
+      # * find(<project_id>, <ticket_id>, :first, :name => 'Project name') - Returns the first comment based on the comment's attribute(s)
+      # * find(<project_id>, <ticket_id>, :last, :name => 'Some project') - Returns the last comment based on the comment's attribute(s)
+      # * find(<project_id>, <ticket_id>, :all, :name => 'Test Project') - Returns all comments based on the given attribute(s)
+      def self.find(project_id, ticket_id, *options)
+        first, attributes = options
+        if first.nil? or (first == :all and attributes.nil?)
+          self.find_by_attributes(project_id, ticket_id)
+        elsif first.is_a? Fixnum
+          self.find_by_id(project_id, ticket_id, first)
+        elsif first.is_a? Array
+          first.collect { |id| self.find_by_id(project_id, ticket_id, id) }
+        elsif first == :first
+          comments = attributes.nil? ? self.find_by_attributes(project_id, ticket_id) : self.find_by_attributes(project_id, ticket_id, attributes)
+          comments.first
+        elsif first == :last
+          comments = attributes.nil? ? self.find_by_attributes(project_id, ticket_id) : self.find_by_attributes(project_id, ticket_id, attributes)
+          comments.last
+        elsif first == :all
+          self.find_by_attributes(project_id, ticket_id, attributes)
+        end
+      end
+      
+      # The first of whatever comment
+      def self.first(project_id, ticket_id, *options)
+        self.find(project_id, ticket_id, :first, *options)
+      end
+      
+      # The last of whatever comment
+      def self.last(project_id, ticket_id, *options)
+        self.find(project_id, ticket_id, :last, *options)
+      end
+      
+      # Accepts an integer id and returns the single comment instance
+      # Must be defined by the provider
+      def self.find_by_id(project_id, ticket_id, id)
+        if self::API.is_a? Class
+          self.new self::API.find(id, :params => {:project_id => project_id, :ticket_id => ticket_id})
+        else
+          raise TicketMaster::Exception.new("This method must be reimplemented in the provider")
+        end
+      end
+      
+      # Accepts an attributes hash and returns all comments matching those attributes in an array
+      # Should return all comments if the attributes hash is empty
+      # Must be defined by the provider
+      def self.find_by_attributes(project_id, ticket_id, attributes = {})
+        if self::API.is_a? Class
+          self.search(project_id, ticket_id, attributes).collect { |thing| self.new thing }
+        else
+          raise TicketMaster::Exception.new("This method must be reimplemented in the provider")
+        end
+      end
+      
+      # This is a helper method to find
+      def self.search(project_id, ticket_id, options = {}, limit = 1000)
+        if self::API.is_a? Class
+          comments = self::API.find(:all, :params => {:project_id => project_id, :ticket_id => ticket_id})
+          search_by_attribute(comments, options, limit)
+        else
+          raise TicketMaster::Exception.new("This method must be reimplemented in the provider")
+        end
+      end
+    end
+  end
+end

data/lib/ticketmaster/common.rb

@@ -0,0 +1,82 @@
+module TicketMaster::Provider
+  # Common module
+  # contains method definitions common to all or most of the models
+  module Common
+      module ClassMethods
+        # Create a something.
+        # Basically, a .new and .save in the same call. The default method assumes it is passed a
+        # single hash with attribute information
+        def create(*options)
+          if self::API.is_a? Class
+            something = self::API.new(*options)
+            something.save
+            self.new something
+          else
+            raise TicketMaster::Exception.new("This method must be reimplemented in the provider")
+          end
+        end
+      end
+      
+      # Automatic extension of class methods on include
+      def self.included(base)
+        base.extend ClassMethods
+      end
+      
+      # The initializer
+      # It tries to do a default system for ActiveResource-based api providers
+      def initialize(*options)
+        @system_data ||= {}
+        @cache ||= {}
+        first = options.shift
+        case first
+          when ActiveResource::Base
+            @system_data[:client] = first
+            self.prefix_options ||= @system_data[:client].prefix_options if @system_data[:client].prefix_options
+            super(first.attributes)
+          
+          when Hash
+            super(first.to_hash)
+        end
+      end
+      
+      # Update the something and save
+      # As opposed to update which just updates the attributes
+      def update!(*options)
+        update(*options)
+        save
+      end
+      
+      # Save changes to this project
+      # Returns true (success) or false (failure) or nil (no changes)
+      def save
+        if @system_data and (something = @system_data[:client]) and something.respond_to?(:attributes)
+          changes = 0
+          something.attributes.each do |k, v|
+            if self.send(k) != v
+              something.send(k + '=', self.send(k)) 
+              changes += 1
+            end
+          end
+          something.save if changes > 0
+        else
+          raise TicketMaster::Exception.new("This method must be reimplemented in the provider")
+        end
+      end
+      
+      # Delete this project
+      # Returns true (success) or false(failure)
+      def destroy
+        if @system_data and @system_data[:client] and @system_data[:client].respond_to?(:destroy)
+          return @system_data[:client].destroy
+        else
+          raise TicketMaster::Exception.new("This method must be reimplemented in the provider")
+        end
+      end
+      
+      def respond_to?(symbol)
+        result = super(symbol)
+        return true if result or @system_data.nil? or @system_data[:client].nil?
+        @system_data[:client].respond_to?(symbol)
+      end
+  end
+end

data/lib/ticketmaster/dummy/project.rb

@@ -49,6 +49,11 @@ module TicketMaster::Provider
         time = Time.now
         !(time.wday == 5 and time.day == 13 and time.to_i % 2 == 1)
       end
+      
+      # Nothing to update, so we always return true
+      def update(*options)
+        return true
+      end
     end
   end
 end

data/lib/ticketmaster/helper.rb

@@ -0,0 +1,61 @@
+module TicketMaster::Provider
+  # Contains a series of helper methods
+  module Helper
+  
+    # A helper method for easy finding
+    def easy_finder(api, symbol, options, at_index = 0)
+      if api.is_a? Class
+        return api if options.length == 0 and symbol == :first
+        options.insert(at_index, symbol) if options[at_index].is_a?(Hash)
+        api.find(*options)
+      else
+        raise TicketMaster::Exception.new("This method must be reimplemented in the provider")
+      end
+    end
+    
+    # This is a search filter that all parameters are passed through
+    # Redefine this method in your classes if you need specific functionality
+    def search_filter(k)
+      k
+    end
+    
+    # Goes through all the things and returns results that match the options attributes hash
+    def search_by_attribute(things, options = {}, limit = 1000)
+      things.find_all do |thing|
+        options.reduce(true) do |memo, kv|
+          break unless memo
+          key, value = kv
+          begin
+            memo &= thing.send(key) == value
+          rescue NoMethodError
+            memo = false
+          end
+          memo
+        end and (limit -= 1) > 0
+      end
+    end
+    
+    # Returns a filter-like string from a hash
+    # If array_join is given, arrays are joined rather than having their own separated key:values
+    # 
+    # ex: filter_string({:name => 'some value', :tags => ['abc', 'def']}) = "name:'some value' tag:abc tag:def"
+    def filter_string(filter = {}, array_join = nil)
+        filter.reduce('') do |mem, kv|
+          key, value = kv
+          if value.is_a?(Array)
+            if !array_join.nil?
+              mem += value.reduce('') { |m, v|
+              v = "\"#{v}\"" if v.to_s.include?(' ')
+              m+= "#{key}:#{v}"
+              }
+              return mem
+            else
+              value = value.join(array_join)
+            end
+          end
+            value = "\"#{value}\"" if value.to_s.include?(' ')
+            mem += "#{key}:#{value} "
+        end
+    end
+  end
+end

data/lib/ticketmaster/project.rb

@@ -10,15 +10,21 @@ module TicketMaster::Provider
     #
     # Methods that must be implemented by the provider
     #
-    # * self.find
+    # * self.find_by_id
+    # * self.find_by_attributes
+    #
+    # Methods that might need to be implemented by the provider
     # * tickets
     # * ticket
-    # * save
     # * initialize
+    # * update
+    # * destroy
+    # * self.create
     #
     # Methods that would probably be okay if the provider left it alone:
     #
-    # * self.create
+    # * self.find - although you can define your own to optimize it a bit
+    # * 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
@@ -31,55 +37,101 @@ module TicketMaster::Provider
     # * updated_at
     # * description
     class Project < Hashie::Mash
+      include TicketMaster::Provider::Common
+      include TicketMaster::Provider::Helper
+      extend TicketMaster::Provider::Helper
       attr_accessor :system, :system_data
-      # Find a project, or find more projects.
+      API = nil #Replace with your api digestor's class.
+
+      # Find project
       # 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() or 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)
+      # * find([#, #, #]) - Returns many projects with these ids
+      # * find(:first, :name => 'Project name') - Returns the first project based on the project's attribute(s)
+      # * find(:last, :name => 'Some project') - Returns the last project based on the project's attribute(s)
+      # * find(:all, :name => '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")
+        first = options.shift
+        attributes = options.shift
+        if first.nil? or (first == :all and attributes.nil?)
+          self.find_by_attributes
+        elsif first.is_a? Fixnum
+          self.find_by_id(first)
+        elsif first.is_a? Array
+          first.collect { |id| self.find_by_id(id) }
+        elsif first == :first
+          projects = attributes.nil? ? self.find_by_attributes : self.find_by_attributes(attributes)
+          projects.first
+        elsif first == :last
+          projects = attributes.nil? ? self.find_by_attributes : self.find_by_attributes(attributes)
+          projects.last
+        elsif first == :all
+          self.find_by_attributes(attributes)
+        end
       end
       
-      # 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
+      # The first of whatever project
+      def self.first(*options)
+        self.find(:first, *options)
       end
       
-      # The initializer
-      def initialize(*options)
-        super(options.shift)
-        # do some other stuff
+      # The last of whatever project
+      def self.last(*options)
+        self.find(:last, *options)
+      end
+      
+      # Accepts an integer id and returns the single project instance
+      # Must be defined by the provider
+      def self.find_by_id(id)
+        if self::API.is_a? Class
+          self.new self::API.find id
+        else
+          raise TicketMaster::Exception.new("This method must be reimplemented in the provider")
+        end
+      end
+      
+      # Accepts an attributes hash and returns all projects matching those attributes in an array
+      # Should return all projects if the attributes hash is empty
+      # Must be defined by the provider
+      def self.find_by_attributes(attributes = {})
+        if self::API.is_a? Class
+          self.search(attributes).collect { |thing| self.new thing }
+        else
+          raise TicketMaster::Exception.new("This method must be reimplemented in the provider")
+        end
+      end
+      
+      # This is a helper method to find
+      def self.search(options = {}, limit = 1000)
+        if self::API.is_a? Class
+          projects = self::API.find(:all)
+          search_by_attribute(projects, options, limit)
+        else
+          raise TicketMaster::Exception.new("This method must be reimplemented in the provider")
+        end
       end
 
       # 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")
+        options.insert 0, id
+        easy_finder(self.class.parent::Ticket, :all, options, 1)
       end
-
-      # 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. 
+      
+      # Very similar to tickets, and is practically an alias of it
+      # however this returns the ticket class if no parameter is given
+      # unlike tickets which returns an array of all tickets when given no parameters
       def ticket(*options)
-        raise TicketMaster::Exception.new("This method must be reimplemented in the provider")
+        options.insert(0, id) if options.length > 0
+        easy_finder(self.class.parent::Ticket, :first, options, 1)
       end
       
-      # Save changes to this project
-      def save
-        raise TicketMaster::Exception.new("This method must be reimplemented in the provider")
+      # Define some provider specific initalizations
+      def initialize(*options)
+        # @system_data = {'some' => 'data}
+        super(*options)
       end
       
     end