pjdavis-roart 0.1.0

data/History.txt

@@ -0,0 +1,2 @@
+== 0.1.0 / 2009-08-13
+Initial Commit. Base functionality added. Can search for tickets, and see all info on tickets. Ticket History not yet implemented.

data/README.rdoc

@@ -0,0 +1,66 @@
+== Roart
+ 
+  \___\__o/
+  /       \
+
+  
+by PJ Davis
+http://github.com/pjdavis/roart
+
+== DESCRIPTION:
+If you are using Best Practical's Request Tracker (RT) and you need to interact with tickets from other applications, Roart provides an interface that is slightly reminiscent of ActiveRecord. 
+
+
+== FEATURES/PROBLEMS:
+
+* Access RT Tickets through an ActiveRecord like API
+  
+* This has only been tested against RT 3.6. Changes to the REST interface in later versions of RT may break stuff. 
+
+== SYNOPSIS:
+
+* Create a class to interact with your ticket system
+  
+    require 'rubygems'
+    require 'roart'
+    
+    class Ticket < Roart::Ticket
+      connection :server => 'http://my.rt.server.com', :user => 'myuser', :pass => 'mypass'
+      
+    end
+    
+* Search for tickets
+
+    my_tickets = Ticket.find(:all, :queue => 'Scutters', :status => [:new, :open])
+    my_tickets.each do |ticket|
+      puts ticket.subject
+    end
+    
+    #-> New John Wayne packages
+    #-> Medi-lab training
+    
+* See all info for a ticket
+  
+    my_ticket = Ticket.find(:first, :queue => 'Issues', :status => :new)
+    ticket.creator #-> rimmer@reddwarf.com
+    ticket.subject #-> Where is the Bomb?
+    
+
+== REQUIREMENTS:
+
+* mechanize
+* A working RT3 install.
+  
+== INSTALL:
+
+    $ gem sources -a http://gems.github.com
+    $ sudo gem install pjdavis-roart
+
+== LICENSE:
+  
+          (C) PJ Davis <pj.davis@gmail.com>
+
+  This program is free software; you can redistribute it and/or modify it under
+  the terms of the WTFPL, Version 2, as
+  published by Sam Hocevar. See http://sam.zoy.org/wtfpl/ for more details.
+

data/Rakefile

@@ -0,0 +1,35 @@
+# Look in the tasks/setup.rb file for the various options that can be
+# configured in this Rakefile. The .rake files in the tasks directory
+# are where the options are used.
+
+begin
+  require 'bones'
+  Bones.setup
+rescue LoadError
+  begin
+    load 'tasks/setup.rb'
+  rescue LoadError
+    raise RuntimeError, '### please install the "bones" gem ###'
+  end
+end
+
+ensure_in_path 'lib'
+require 'roart'
+
+task :default => 'spec:run'
+
+PROJ.name = 'roart'
+PROJ.ignore_file = '.gitignore'
+PROJ.authors = 'PJ Davis'
+PROJ.email = 'pj.davis@gmail.com'
+PROJ.url = 'http://github.com/pjdavis/roart'
+PROJ.version = Roart::VERSION
+PROJ.rubyforge.name = 'roart'
+PROJ.exclude = %w(.git pkg coverage)
+PROJ.description = "Interface for working with Request Tracker (RT) tickets inspired by ActiveRecord."
+PROJ.rdoc.main = 'README.rdoc'
+depend_on 'mechanize'
+
+PROJ.spec.opts << '--color'
+
+# EOF

data/lib/roart/connection.rb

@@ -0,0 +1,54 @@
+require 'yaml'
+require 'mechanize'
+
+module Roart
+  
+  module Connections
+    RequiredConfig = %w(server user pass)
+  
+  end
+  
+  class Connection
+  
+    attr_reader :agent
+  
+    def initialize(conf)
+    
+      if conf.is_a?(String)
+        raise "Loading Config File not yet implemented"
+      elsif conf.is_a?(Hash)
+        Roart::check_keys!(conf, Roart::Connections::RequiredConfig)
+        @conf = conf
+      end
+    
+      @agent = login
+      add_methods!
+    end
+    
+    def get(uri)
+      @agent.get(uri).body
+    end
+    
+    protected
+    
+    def login
+      agent = WWW::Mechanize.new
+      page = agent.get(@conf[:server])
+      form = page.form('login')
+      form.user = @conf[:user]
+      form.pass = @conf[:pass]
+      page = agent.submit form
+      agent
+    end
+    
+    def add_methods!
+      @conf.each do |key, value|
+        (class << self; self; end).send :define_method, key do
+          return value
+        end
+      end
+    end
+    
+  end
+  
+end

data/lib/roart/core/array.rb

@@ -0,0 +1,11 @@
+class Array
+  
+  def to_hash
+    h = Hash.new
+    self.each do |element|
+      h.update(element.to_sym => nil)
+    end
+    h
+  end
+  
+end

data/lib/roart/core/string.rb

@@ -0,0 +1,18 @@
+# used from ActiveSupport
+# Copyright (c) 2005-2009 David Heinemeier Hansson
+
+class String
+  
+  def underscore
+    self.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+  end
+  
+  def camelize
+    self.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+  end
+  
+end

data/lib/roart/errors.rb

@@ -0,0 +1,11 @@
+module Roart
+  
+  class RoartError < StandardError; end
+  
+  class ArgumentError < RoartError; end
+  
+  class TicketSystemError < RoartError; end
+  
+  class TicketSystemInterfaceError < RoartError; end
+  
+end

data/lib/roart/roart.rb

@@ -0,0 +1,11 @@
+module Roart
+  
+  def self.check_keys!(hash, required)
+    unless required.inject(true) do |inc, attr| 
+        inc ? hash.keys.include?(attr.to_sym) : nil
+      end
+      raise ArgumentError, "Not all required fields entered" 
+    end
+  end
+  
+end

data/lib/roart/ticket.rb

@@ -0,0 +1,280 @@
+module Roart
+  
+  module Tickets
+    
+    DefaultAttributes = %w(queue owner creator subject status priority initial_priority final_priority requestors cc admin_cc created starts started due resolved told last_updated time_estimated time_worked time_left full logs)
+    RequiredAttributes = %w(queue creator subject status created)
+  
+  end
+  
+  class Ticket
+  
+    def initialize(attributes)
+      Roart::check_keys!(attributes, Roart::Tickets::RequiredAttributes)
+      if attributes.is_a?(Hash)
+        @attributes = Roart::Tickets::DefaultAttributes.to_hash.merge(attributes)
+      else
+        raise ArgumentError, "Expects a hash."
+      end
+      add_methods!
+    end
+    
+    # Loads all information for a ticket from RT and lets full to true. 
+    # This changes the ticket object and adds methods for all the fields on the ticket.
+    # Custom fields will be prefixed with 'cf' so a custom field of 'phone'
+    # would be cf_phone
+    #
+    def load_full!
+      unless self.full
+        ticket = self.class.find(self.id)
+        @attributes = ticket.instance_variable_get("@attributes")
+        add_methods!
+      end
+    end
+    
+    class << self #class methods
+      
+      # Gives or Sets the connection object for the RT Server.
+      # Accepts 3 parameters :server, :user, and :pass. Call this 
+      # at the top of your subclass to create the connection, 
+      #     class Ticket < Roart::Ticket
+      #       connection :server => 'server', :user => 'user', :pass => 'pass'
+      #     end
+      #
+      def connection(options=nil)
+        if options && @connection.nil?
+          @connection = Roart::Connection.new(options)
+        else
+          @connection
+        end
+        @connection
+      end
+      
+      # Searches for a ticket or group of tickets with an active
+      # record like interface.
+      #
+      # Find has 3 different ways to search for tickets
+      #
+      # * search for tickets by the id. This will search for the Ticket with the exact id and will automatically load the entire ticket into the object (full will return true).
+      # * search for all tickets with a hash for search options by specifying :all along with your options. This will return an array of tickets or an empty array if no tickets are found that match the options.
+      # * search for a single ticket with a hash for search options by specifying :first along with your options. This will return a single ticket object or nil if no tickets are found.
+      #
+      # A hash of options for search paramaters are passed in as the last argument.
+      #
+      # ====Parameters
+      # * <tt>:queue</tt> or <tt>:queues</tt> - the name of a queue in the ticket system. This can be specified as a string, a symbol or an array of strings or symbols. The array will search for tickets included in either queue.
+      # * <tt>:status</tt> - the status of the tickets to search for. This can be specified as a string, a symbol or an array of strings or symbols. 
+      # * <tt>:subject</tt>, <tt>:content</tt>, <tt>content_type</tt>, <tt>file_name</tt> - takes a string and searches for that string in the respective field.
+      # * <tt>:created</tt>, <tt>:started</tt>, <tt>:resolved</tt>, <tt>:told</tt>, <tt>:last_updated</tt>, <tt>:starts</tt>, <tt>:due</tt>, <tt>:updated</tt> - looks for dates for the respective fields. Can take a Range, Array, String, Time. Range will find all tickets between the two dates (after the first, before the last). Array works the same way, using #first and #last on the array. The elements should be either db-time formatted strings or Time objects. Time will be formatted as a db string. String will be passed straight to the search.
+      # * <tt>:custom_fields</tt> - takes a hash of custom fields to search for. the key should be the name of the field exactly how it is in RT and the value will be what to search for. 
+      #
+      # ==== Examples
+      #
+      #   # find first
+      #   MyTicket.find(:first) 
+      #   MyTicket.find(:first, :queue => 'My Queue')
+      #   MyTicket.find(:first, :status => [:new, :open])
+      #   MyTicket.find(:first, :queue => 'My Queue', :status => :resolved)
+      #   MyTicket.find(:first, :custom_fields => {:phone => '8675309'})
+      #
+      #   # find all
+      #   MyTicket.find(:all, :subject => 'is down')
+      #   MyTicket.find(:all, :created => [Time.now - 300, Time.now])
+      #   MyTicket.find(:all, :queues => ['my queue', 'issues'])
+      #
+      #   # find by id
+      #   MyTicket.find(12345)
+      #
+      def find(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        case args.first
+          when :first then  find_initial(options)
+          when :all then    find_all(options)
+          else              find_by_ids(args, options)
+        end
+      end
+      
+      protected
+      
+      def instantiate(ticket)
+        object = nil
+        if ticket.is_a?(Array)
+          array = Array.new
+          ticket.each do |tick|
+            object = self.allocate
+            object.instance_variable_set("@attributes", tick)
+            object.send("add_methods!")
+            array << object
+          end
+          return array
+        elsif ticket.is_a?(Hash)
+          object = self.allocate
+          object.instance_variable_set("@attributes", ticket)
+          object.send("add_methods!")
+        end
+        object
+      end
+      
+      def find_initial(options={})
+        options.update(:limit => 1)
+        find_all(options).first
+      end
+      
+      def find_all(options)
+        uri = construct_search_uri(options)
+        tickets = get_tickets_from_search_uri(uri)
+      end
+      
+      def find_by_ids(args, options)
+        get_ticket_by_id(args.first)
+      end
+      
+      def page_array(uri)
+        page = self.connection.get(uri)
+        raise TicketSystemError, "Can't get ticket." unless page
+        page = page.split("\n")   
+        status = page.delete_at(0)
+        if status.include?("200") 
+          page.delete_if{|x| !x.include?(":")} 
+          page
+        else
+          raise TicketSystemInterfaceError, "Error Getting Ticket: #{status}"
+        end
+      end
+      
+      def get_tickets_from_search_uri(uri)
+        page = page_array(uri)
+        page.extend(Roart::TicketPage)
+        page = page.to_search_array
+        self.instantiate(page)
+      end
+      
+      def get_ticket_from_uri(uri)
+        page = page_array(uri)
+        page.extend(Roart::TicketPage)
+        page = page.to_hash
+        page.update(:full => true)
+        self.instantiate(page)
+      end
+      
+      def get_ticket_by_id(id)
+        uri = "#{self.connection.server}/REST/1.0/ticket/"
+        uri << id.to_s
+        get_ticket_from_uri(uri)
+      end
+      
+      def construct_search_uri(options)
+        uri = "#{self.connection.server}/REST/1.0/search/ticket?"
+        uri << 'orderby=-Created&' if options.delete(:order)
+        unless options.empty?
+          uri << 'query= '
+          query = Array.new
+        
+          add_queue!(query, options[:queues] || options[:queue])
+          add_dates!(query, options)
+          add_searches!(query, options)
+          add_status!(query, options[:status])
+          add_custom_fields!(query, options[:custom_fields])
+        
+          query << options[:conditions].to_s.chomp if options[:conditions]
+          
+          uri << query.join(" AND ")
+        end
+        uri
+      end
+      
+      def add_queue!(uri, queue)
+        return false unless queue
+        if queue.is_a?(Array)
+          queues = Array.new
+          queue.each do |name|
+            queues << "Queue = '#{name}'"
+          end
+          uri << '( ' + queues.join(' OR ') + ' )'
+        elsif queue.is_a?(String) || queue.is_a?(Symbol)
+          uri << "Queue = '#{queue.to_s}'"
+        end
+      end
+      
+      def add_custom_fields!(uri, options)
+        return false unless options
+        options.each do |field, value|
+          if value.is_a?(Array)
+            valpart = Array.new
+            for val in value
+              valpart << "'CF.{#{field}}' = '#{val.to_s}'"
+            end
+            uri << '( ' + valpart.join(" OR ") + ' )'
+          elsif value.is_a?(String)
+            uri << "'CF.{#{field}}' = '#{value.to_s}'"
+          end
+        end
+      end
+      
+      def add_status!(uri, options)
+        return false unless options
+        parts = Array.new
+        if options.is_a?(Array)
+          statpart = Array.new
+          for status in options
+            statpart << "Status = '#{status.to_s}'"
+          end
+          parts << '( ' + statpart.join(" OR ") + ' )'
+        elsif options.is_a?(String) || options.is_a?(Symbol)
+          parts << "Status = '#{options.to_s}'"
+        end
+        uri << parts
+      end
+      
+      def add_searches!(uri, options)
+        search_fields = %w( subject content content_type file_name)
+        options.each do |key, value|
+          if search_fields.include?(key.to_s)
+            key = key.to_s.camelize
+            parts = Array.new
+            if value.is_a?(Array)
+              value.each do |v|
+                parts << "#{key} LIKE '#{v}'"
+              end
+              uri << '( ' + parts.join(" AND ") + ' )'
+            elsif value.is_a?(String)
+              uri << "#{key} LIKE '#{value}'"
+            end
+          end
+        end
+      end
+      
+      def add_dates!(uri, options)
+        date_field = %w( created started resolved told last_updated starts due updated )
+        options.each do |key, value|
+          if date_field.include?(key.to_s)
+            key = key.to_s.camelize
+            parts = Array.new
+            if value.is_a?(Range) or value.is_a?(Array)
+              parts << "#{key} > '#{value.first.is_a?(Time) ? value.first.strftime("%Y-%m-%d %H:%M:%S") : value.first.to_s}'"
+              parts << "#{key} < '#{value.last.is_a?(Time) ? value.last.strftime("%Y-%m-%d %H:%M:%S") : value.last.to_s}'"
+            elsif value.is_a?(String)
+              parts << "#{key} > '#{value.to_s}'"
+            elsif value.is_a?(Time)
+              parts << "#{key} > '#{value.strftime("%Y-%m-%d %H:%M:%S")}'"
+            end
+            uri << '( ' + parts.join(" AND ") + ' )'
+          end
+        end
+      end
+      
+    end
+      
+    protected
+    
+    def add_methods!
+      @attributes.each do |key, value|
+        (class << self; self; end).send :define_method, key do
+          return value
+        end
+      end 
+    end
+    
+  end
+    
+end

data/lib/roart/ticket_page.rb

@@ -0,0 +1,38 @@
+module Roart
+  
+  module TicketPage
+
+    def to_hash
+      hash = Hash.new
+      self.delete_if{|x| !x.include?(":")}
+      self.each do |ln|
+        ln = ln.split(":")
+        key = ln.delete_at(0).strip.underscore
+        value = ln.join(":").strip
+        hash[key.to_sym] = value
+      end
+      hash[:id] = hash[:id].split("/").last.to_i
+      hash.update(:history => false)
+      hash
+    end
+    
+    def to_search_array
+      array = Array.new
+      self.delete_if{|x| !x.include?(":")}
+      self.each do |ln|
+        hash = Hash.new
+        ln = ln.split(":")
+        id = ln.delete_at(0).strip.underscore
+        sub = ln.join(":").strip
+        hash[:id] = id.to_i
+        hash[:subject] = sub
+        hash[:full] = false
+        hash[:history] = false
+        array << hash
+      end
+      array
+    end
+    
+  end
+  
+end

data/lib/roart.rb

@@ -0,0 +1,49 @@
+require 'rubygems'
+module Roart
+
+  # :stopdoc:
+  VERSION = '0.1.0'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility method used to require all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+end  # module Roart
+
+Roart.require_all_libs_relative_to(__FILE__)
+
+# EOF

data/roart.gemspec

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{roart}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["PJ Davis"]
+  s.date = %q{2009-08-14}
+  s.description = %q{Interface for working with Request Tracker (RT) tickets inspired by ActiveRecord.}
+  s.email = %q{pj.davis@gmail.com}
+  s.extra_rdoc_files = ["History.txt", "README.rdoc"]
+  s.files = ["History.txt", "README.rdoc", "Rakefile", "lib/roart.rb", "lib/roart/connection.rb", "lib/roart/core/array.rb", "lib/roart/core/string.rb", "lib/roart/errors.rb", "lib/roart/roart.rb", "lib/roart/ticket.rb", "lib/roart/ticket_page.rb", "roart.gemspec", "spec/roart/connection_spec.rb", "spec/roart/core/array_spec.rb", "spec/roart/core/string_spec.rb", "spec/roart/roart_spec.rb", "spec/roart/ticket_page_spec.rb", "spec/roart/ticket_spec.rb", "spec/roart_spec.rb", "spec/spec_helper.rb", "test/test_roart.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/pjdavis/roart}
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{roart}
+  s.rubygems_version = %q{1.3.2}
+  s.summary = %q{Interface for working with Request Tracker (RT) tickets inspired by ActiveRecord}
+  s.test_files = ["test/test_roart.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<mechanize>, [">= 0.9.0"])
+      s.add_development_dependency(%q<bones>, [">= 2.5.1"])
+    else
+      s.add_dependency(%q<mechanize>, [">= 0.9.0"])
+      s.add_dependency(%q<bones>, [">= 2.5.1"])
+    end
+  else
+    s.add_dependency(%q<mechanize>, [">= 0.9.0"])
+    s.add_dependency(%q<bones>, [">= 2.5.1"])
+  end
+end

data/spec/roart/connection_spec.rb

@@ -0,0 +1,7 @@
+
+require File.join(File.dirname(__FILE__), %w[ .. spec_helper])
+
+describe "Connection" do
+  
+  
+end 

data/spec/roart/core/array_spec.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__), %w[ .. .. spec_helper])
+
+describe 'array extentions' do
+  
+  it 'should turn an array to a nil valued hash' do
+    array = %w[key1 key2]
+    hash = array.to_hash
+    hash.has_key?(:key1).should be_true
+    hash.has_key?(:key2).should be_true
+    hash[:key1].should be_nil
+  end
+  
+end

data/spec/roart/core/string_spec.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__), %w[ .. .. spec_helper])
+
+describe 'string extentions' do
+
+  it 'should underscore a word' do
+    'SomeGuy'.underscore.should == 'some_guy'
+  end
+  
+  it 'should camelcase a word' do
+    'some_guy'.camelize.should == 'SomeGuy'
+  end
+
+end

data/spec/roart/roart_spec.rb

@@ -0,0 +1,11 @@
+
+require File.join(File.dirname(__FILE__), %w[ .. spec_helper])
+
+describe "Roart" do
+  
+  it "should raise an error if there aren't required fields" do
+    attributes = {:subject => "Not Enough Stuff"}
+    lambda { Roart::check_keys!(attributes, Roart::Tickets::RequiredAttributes) }.should raise_error(Roart::ArgumentError)
+  end
+  
+end

data/spec/roart/ticket_page_spec.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), %w[ .. spec_helper])
+
+describe 'ticket page' do
+  
+  describe 'ticket hash' do
+    
+    it 'should convert an array to a hash' do
+      array = ["id : 10", "subject : asdf"]
+      array.extend(Roart::TicketPage)
+      hash = array.to_hash
+      hash.has_key?(:id).should be_true
+      hash[:id].should == 10
+      hash[:subject].should == 'asdf'
+    end
+    
+    it 'should not have a history' do
+      array = ["id : 10", "subject : asdf"]
+      array.extend(Roart::TicketPage)
+      hash = array.to_hash
+      hash[:history].should be_false
+    end
+  
+  end
+  
+  describe 'search array' do
+    
+    before do
+      @array = ["123 : Subject", "234 : Subject"]
+      @array.extend(Roart::TicketPage)
+      @array = @array.to_search_array
+    end
+    
+    it 'should make an array of search results' do
+      @array.size.should == 2
+    end
+    
+    it 'should put search elements into the search array' do
+      @array.first[:id].should == 123
+      @array.last[:id].should == 234
+    end
+    
+    it 'should keep history false' do
+      @array.first[:history].should be_false
+      @array.last[:history].should be_false
+    end
+    
+  end
+  
+end

data/spec/roart/ticket_spec.rb

@@ -0,0 +1,299 @@
+require File.join(File.dirname(__FILE__), %w[ .. spec_helper])
+
+describe "Ticket" do
+  
+  it "should have a connection" do
+    Roart::Connection.should_receive(:new).with('some options').and_return(true)
+    Roart::Ticket.connection('some options').should == true
+  end
+  
+  it "should find the first ticket" do
+    Roart::Ticket.should_receive(:find_initial).with(:my => 'options').and_return('a ticket')
+    Roart::Ticket.find(:first, :my => 'options').should == 'a ticket'
+  end
+  
+  it 'should find all tickets' do
+    Roart::Ticket.should_receive(:find_all).with(:my => 'options').and_return(%w[array of tickets])
+    Roart::Ticket.find(:all, :my => 'options').should == ['array', 'of', 'tickets']
+  end
+  
+  it 'should find a ticket by id' do
+    Roart::Ticket.should_receive(:find_by_ids).with([12345],{}).and_return('a ticket')
+    Roart::Ticket.find(12345).should == 'a ticket'
+  end
+  
+  describe "find initial" do 
+  
+    it 'should set options to include :limit => 1' do 
+      Roart::Ticket.should_receive(:find_all).with({:limit => 1}).and_return(['ticket', 'not seen'])
+      Roart::Ticket.send(:find_initial)
+    end
+    
+    it 'should not overwrite the options hash' do
+      Roart::Ticket.should_receive(:find_all).with({:queue => 'queue', :limit => 1}).and_return(['ticket', 'not seen'])
+      Roart::Ticket.send(:find_initial, :queue => 'queue')      
+    end
+    
+    it 'should return 1 ticket object' do
+      Roart::Ticket.should_receive(:find_all).with({:limit => 1}).and_return(['ticket', 'not seen'])
+      Roart::Ticket.send(:find_initial).should == 'ticket'
+    end
+    
+  end
+  
+  describe 'page array' do
+    
+    it 'should raise an error if not a 200 response' do
+      connection = mock('connection', :get => 'some error message')
+      Roart::Ticket.should_receive(:connection).and_return(connection)
+      lambda do 
+        Roart::Ticket.send(:page_array, 'www.whatever')
+      end.should raise_error(Roart::TicketSystemInterfaceError)
+    end
+    
+    it 'should raise an error if nothing is returned' do
+      connection = mock('connection', :get => nil)
+      Roart::Ticket.should_receive(:connection).and_return(connection)
+      lambda do 
+        Roart::Ticket.send(:page_array, 'www.whatever')
+      end.should raise_error(Roart::TicketSystemError)
+    end
+    
+    it 'should give back an array of strings' do
+      connection = mock('connection', :get => "200 OK\n23:SomeTicket\n33:Another")
+      Roart::Ticket.should_receive(:connection).and_return(connection)
+      Roart::Ticket.send(:page_array, 'uri').should == ['23:SomeTicket', '33:Another']
+    end
+    
+  end
+  
+  describe 'getting tickets from URI' do
+    
+    describe 'search' do
+      
+      it 'should give an array of tickets' do
+        Roart::Ticket.should_receive(:page_array).with('uri').and_return(['23:SomeTicket', '33:Another'])
+        Roart::Ticket.send(:get_tickets_from_search_uri, 'uri').size.should == 2
+      end
+      
+      it 'should not have full tickets' do
+        Roart::Ticket.should_receive(:page_array).with('uri').and_return(['23:SomeTicket', '33:Another'])
+        Roart::Ticket.send(:get_tickets_from_search_uri, 'uri').each do |ticket|
+          ticket.full.should_not be_true
+        end
+      end
+      
+    end
+    
+    describe 'full ticket' do
+      
+      it 'should give a ticket' do
+        Roart::Ticket.should_receive(:page_array).with('uri').and_return(['id:23', 'subject:someticket'])
+        Roart::Ticket.send(:get_ticket_from_uri, 'uri').is_a?(Roart::Ticket).should be_true
+      end
+      
+      it 'should be a full ticket' do
+        Roart::Ticket.should_receive(:page_array).with('uri').and_return(['id:23', 'subject:someticket'])
+        Roart::Ticket.send(:get_ticket_from_uri, 'uri').full.should be_true
+      end
+      
+    end
+    
+    describe 'getting ticket from id' do
+      
+      it 'should give a ticket' do
+        connection = mock('connection', :server => "server")
+        Roart::Ticket.should_receive(:connection).and_return(connection)
+        Roart::Ticket.should_receive(:get_ticket_from_uri).with('server' + '/REST/1.0/ticket/' + 12345.to_s).and_return('a ticket')
+        Roart::Ticket.send(:get_ticket_by_id, 12345).should == 'a ticket'
+      end
+      
+    end
+    
+    describe 'find methods' do
+      
+      it 'should get all tickets from an options hash' do
+        Roart::Ticket.should_receive('construct_search_uri').with('searches').and_return('uri')
+        Roart::Ticket.should_receive('get_tickets_from_search_uri').with('uri').and_return(['tickets'])
+        Roart::Ticket.send(:find_all, 'searches').should == ['tickets']
+      end
+      
+      it 'should find tickets from id' do
+        Roart::Ticket.should_receive(:get_ticket_by_id).with('id').and_return('a ticket')
+        Roart::Ticket.send(:find_by_ids, ['id'], {}).should == 'a ticket'
+      end
+      
+    end
+    
+    describe 'building a search uri' do
+      
+      before do
+        @connection = mock('connection', :server => "server")
+        @search_string = "/REST/1.0/search/ticket?"
+        Roart::Ticket.should_receive(:connection).and_return(@connection)
+        @query = @connection.server + @search_string + 'query= '
+      end
+      
+      describe 'queues' do
+        
+        it 'should include a queue' do
+          Roart::Ticket.send(:construct_search_uri, {:queue => 'myQueue'}).should == @query + "Queue = 'myQueue'"
+        end
+        
+        it 'should take multiple queues' do
+          Roart::Ticket.send(:construct_search_uri, {:queue => ['myQueue', 'another']}).should == @query + "( Queue = 'myQueue' OR Queue = 'another' )"
+        end
+        
+      end
+      
+      describe 'dates' do
+      
+        before do 
+          @time = Time.now
+        end
+        
+        it 'should accept a date' do
+          Roart::Ticket.send(:construct_search_uri, {:created => @time}).should == @query + "( Created > '#{dbtime(@time)}' )"
+        end
+        
+        it 'should accept an array of dates' do
+          Roart::Ticket.send(:construct_search_uri, {:created => [@time, @time + 300]}).should == @query + "( Created > '#{dbtime(@time)}' AND Created < '#{dbtime(@time + 300)}' )"
+        end
+        
+        it 'should accept a range of dates' do
+          Roart::Ticket.send(:construct_search_uri, {:created => (@time..(@time + 300))}).should == @query + "( Created > '#{dbtime(@time)}' AND Created < '#{dbtime(@time + 300)}' )"
+        end
+        
+        it 'should accept an array of strings' do
+          Roart::Ticket.send(:construct_search_uri, {:created => %w[cat dog]}).should == @query + "( Created > 'cat' AND Created < 'dog' )"
+        end
+        
+        it 'should accept a string' do
+          Roart::Ticket.send(:construct_search_uri, {:created => 'time'}).should == @query + "( Created > 'time' )"
+        end
+        
+        describe 'date fields' do
+        
+          it 'should search started' do
+            Roart::Ticket.send(:construct_search_uri, {:started => 'time'}).should == @query + "( Started > 'time' )"
+          end
+        
+          it 'should search resolved' do
+            Roart::Ticket.send(:construct_search_uri, {:resolved => 'time'}).should == @query + "( Resolved > 'time' )"
+          end
+        
+          it 'should search told' do
+            Roart::Ticket.send(:construct_search_uri, {:told => 'time'}).should == @query + "( Told > 'time' )"
+          end
+        
+          it 'should search last_updated' do
+            Roart::Ticket.send(:construct_search_uri, {:last_updated => 'time'}).should == @query + "( LastUpdated > 'time' )"
+          end
+        
+          it 'should search starts' do
+            Roart::Ticket.send(:construct_search_uri, {:starts => 'time'}).should == @query + "( Starts > 'time' )"
+          end
+        
+          it 'should search due' do
+            Roart::Ticket.send(:construct_search_uri, {:due => 'time'}).should == @query + "( Due > 'time' )"
+          end
+        
+          it 'should search updated' do
+            Roart::Ticket.send(:construct_search_uri, {:updated => 'time'}).should == @query + "( Updated > 'time' )"
+          end
+        
+        end
+        
+      end
+      
+      describe 'searches' do
+        
+        it 'should accept a string' do 
+          Roart::Ticket.send(:construct_search_uri, {:subject => 'fish'}).should == @query + "Subject LIKE 'fish'"
+        end
+        
+        it 'should accept an array' do 
+          Roart::Ticket.send(:construct_search_uri, {:subject => %w[cramanation station]}).should == @query + "( Subject LIKE 'cramanation' AND Subject LIKE 'station' )"
+        end
+        
+        describe 'search fields' do 
+          
+          it 'should search content' do 
+            Roart::Ticket.send(:construct_search_uri, {:content => 'fish'}).should == @query + "Content LIKE 'fish'"
+          end
+          
+          it 'should search content_type' do 
+            Roart::Ticket.send(:construct_search_uri, {:content_type => 'fish'}).should == @query + "ContentType LIKE 'fish'"
+          end
+          
+          it 'should search file_name' do 
+            Roart::Ticket.send(:construct_search_uri, {:file_name => 'fish'}).should == @query + "FileName LIKE 'fish'"
+          end
+          
+        end
+        
+      end
+      
+      describe 'status' do
+        
+        it 'should accept a string' do
+          Roart::Ticket.send(:construct_search_uri, {:status => 'new'}).should == @query + "Status = 'new'"
+        end
+        
+        it 'should accept a symbol' do
+          Roart::Ticket.send(:construct_search_uri, {:status => :new}).should == @query + "Status = 'new'"
+        end
+        
+        it 'should accept an array' do
+          Roart::Ticket.send(:construct_search_uri, {:status => ['new', 'open']}).should == @query + "( Status = 'new' OR Status = 'open' )"
+        end
+        
+      end
+      
+      describe 'custom_fields' do
+        
+        it 'should accept a hash with string values' do
+          Roart::Ticket.send(:construct_search_uri, {:custom_fields => {:phone => '8675309'}}).should == @query + "'CF.{phone}' = '8675309'"
+        end
+
+        it 'should accept a hash with string values' do
+          Roart::Ticket.send(:construct_search_uri, {:custom_fields => {:phone => ['8675309', '5553265']}}).should == @query + "( 'CF.{phone}' = '8675309' OR 'CF.{phone}' = '5553265' )"
+        end
+        
+      end
+      
+      describe 'multiple find options' do
+        
+        it 'should allow multiple find options' do
+          query = Roart::Ticket.send(:construct_search_uri, {:status => 'new', :queue => 'MyQueue'})
+          query.include?("Status = 'new'").should be_true
+          query.include?("Queue = 'MyQueue'").should be_true
+        end
+        
+        it "should search for :queue => 'A Queue', :status => [:new, :open]" do 
+          query = Roart::Ticket.send(:construct_search_uri, {:queue => 'A Queue', :status => [:new, :open]})
+          query.include?("( Status = 'new' OR Status = 'open' )").should be_true
+          query.include?("Queue = 'A Queue'").should be_true
+        end
+        
+      end
+      
+    end  
+    
+  end
+  
+  describe 'ticket methods' do
+    
+    it 'should be able to load the full ticket' do
+      search_array = ['1:subject']
+      search_array.extend(Roart::TicketPage)
+      full_ticket = Roart::Ticket.send(:instantiate, {:id => 1, :subject => 'subject', :full => true})
+      ticket = Roart::Ticket.send(:instantiate, search_array.to_search_array ).first
+      Roart::Ticket.should_receive(:find).with(1).and_return(full_ticket)
+      ticket.load_full!
+      ticket.full.should be_true
+    end
+    
+  end
+  
+end

data/spec/roart_spec.rb

@@ -0,0 +1,8 @@
+
+require File.join(File.dirname(__FILE__), %w[spec_helper])
+
+describe Roart do
+  
+end
+
+# EOF

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+
+dir = File.dirname(__FILE__)
+
+$:.unshift(File.join(dir, '/../lib/'))
+require dir + '/../lib/roart'
+
+def dbtime(time)
+  time.strftime("%Y-%m-%d %H:%M:%S")
+end
+
+Spec::Runner.configure do |config|
+  # == Mock Framework
+  #
+  # RSpec uses it's own mocking framework by default. If you prefer to
+  # use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+end
+
+# EOF

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification 
+name: pjdavis-roart
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- PJ Davis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-14 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mechanize
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: bones
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.5.1
+    version: 
+description: Interface for working with Request Tracker (RT) tickets inspired by ActiveRecord.
+email: pj.davis@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- README.rdoc
+files: 
+- History.txt
+- README.rdoc
+- Rakefile
+- lib/roart.rb
+- lib/roart/connection.rb
+- lib/roart/core/array.rb
+- lib/roart/core/string.rb
+- lib/roart/errors.rb
+- lib/roart/roart.rb
+- lib/roart/ticket.rb
+- lib/roart/ticket_page.rb
+- roart.gemspec
+- spec/roart/connection_spec.rb
+- spec/roart/core/array_spec.rb
+- spec/roart/core/string_spec.rb
+- spec/roart/roart_spec.rb
+- spec/roart/ticket_page_spec.rb
+- spec/roart/ticket_spec.rb
+- spec/roart_spec.rb
+- spec/spec_helper.rb
+- test/test_roart.rb
+has_rdoc: true
+homepage: http://github.com/pjdavis/roart
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: roart
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Interface for working with Request Tracker (RT) tickets inspired by ActiveRecord
+test_files: 
+- test/test_roart.rb