roart 0.1.4

data/History.txt

@@ -0,0 +1,17 @@
+==0.1.4 / 2009-08-19
+Implemented callbacks, you can now hook into the ticket life-cycle with before and after create and update.
+Saving works like ActiveRecord now, with save returning true if successful and false otherwise, and save! raising an error if unsuccessful.
+Creating tickets is more ActiveRecord like now, with new not saving to the ticketing system automatically, you must call save or save!. There is a create function to do this now. Although this does break backward compatability, I'm not going to bump the minor because a) nobody has forked this yet, and b) i skipped 0.
+You can now specify a default queue when you subclass Roart::Ticket. just add a default_queue 'queue name' to your class and that queue will automatically be searched unless you specify a queue.
+
+==0.1.3 / 2009-08-18
+Can now update tickets with #save. Returns true if saved, raises an error if not.
+
+==0.1.2 / 2009-08-18
+Added Create ticket functionality. Ticket.new will create a ticket in the RT system and return that ticket.
+
+== 0.1.1 / 2009-08-17
+Added History functionality. #histories now loads an array of history objects into memory and you can access them like you would a regular array. A few connivence methods (last, count) have also been added.
+
+== 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,85 @@
+== 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?
+    
+* Get history for a ticket
+    
+    my_ticket.histories #-> Returns an array of history objects
+    
+* Create a new ticket
+
+    issue = Ticket.new(:queue => 'some_queue', :subject => 'This is not working for me')
+    issue.id #-> 'ticket/new'
+    issue.save
+    issue.id #-> 23423
+    
+* Update a ticket
+
+    ticket = Ticket.find(23452)
+    ticket.subject #-> "Some Subject for a ticket."
+    ticket.subject #-> "Smoke me a kipper, I'll be back for breakfast."
+    ticket.save
+    ticket.subject #->"Smoke me a kipper, I'll be back for breakfast."
+    
+
+== 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.rb

@@ -0,0 +1,49 @@
+require 'rubygems'
+module Roart
+
+  # :stopdoc:
+  VERSION = '0.1.4'
+  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/lib/roart/callbacks.rb

@@ -0,0 +1,25 @@
+module Roart
+  
+  # Callbacks are implemented to do a bit of logic either before or after a part of the object life cycle. These can be overridden in your Ticket class and will be called at the approprate times.
+  #
+  module Callbacks
+    
+    # called just before a ticket that has not been saved to the ticketing system is saved.
+    #
+    def before_create; end
+    
+    # Called immediately a ticket that has not been saved is saved.
+    #
+    def before_update; end
+    
+    # called just before a ticket that has been updated is saved to the ticketing system
+    #
+    def after_create; end
+    
+    # called just after a ticket that has been updated is saved to the ticketing system
+    #
+    def after_update; end
+    
+  end
+  
+end

data/lib/roart/connection.rb

@@ -0,0 +1,62 @@
+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 rest_path
+      self.server + '/REST/1.0/'
+    end
+    
+    def get(uri)
+      @agent.get(uri).body
+    end
+    
+    def post(uri, payload)
+      @agent.post(uri, payload).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/hash.rb

@@ -0,0 +1,15 @@
+class Hash
+  def to_content_format
+    fields = self.map do |key,value| 
+      unless value.nil?
+        if key.to_s.match(/^cf_.+/)
+          "CF-#{key.to_s[3..key.to_s.length].camelize.humanize}: #{value}"
+        else
+          "#{key.to_s.camelize}: #{value}"
+        end
+      end
+    end
+    content = fields.compact.join("\n")
+  end
+  
+end

data/lib/roart/core/string.rb

@@ -0,0 +1,21 @@
+# 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
+  
+  def humanize
+    self.gsub(/_id$/, "").gsub(/_/, " ").capitalize
+  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/history.rb

@@ -0,0 +1,115 @@
+module Roart
+  
+  module Histories
+    
+    DefaultAttributes = %w(creator type description content created)
+    RequiredAttributes = %w(creator type)
+  
+  end
+  
+  class HistoryArray < Array
+    
+    def ticket
+      @default_options[:ticket]
+    end
+    
+    def all
+      self
+    end
+    
+    def count
+      self.size
+    end
+    
+    def last
+      self[self.size - 1]
+    end
+    
+  end
+  
+  class History
+
+#TODO Figure out why i can't include Roart::MethodFunctions
+    def add_methods!
+      @attributes.each do |key, value|
+        (class << self; self; end).send :define_method, key do
+          return value
+        end
+      end 
+    end
+    
+    class << self
+    
+      def default(options)
+        history = self.dup
+        history.instance_variable_set("@default_options", options)
+        history.all
+      end
+    
+      def ticket
+        @default_options[:ticket]
+      end
+    
+      def all
+        @histories ||= get_all
+      end
+      
+      def default_options
+        @default_options
+      end
+      
+      protected
+      
+      def instantiate(attrs)
+        object = nil
+        if attrs.is_a?(Array)
+          array = Array.new
+          attrs.each do |attr|
+            object = self.allocate
+            object.instance_variable_set("@attributes", attr.merge(self.default_options))
+            object.send("add_methods!")
+            array << object
+          end
+          return array
+        elsif attrs.is_a?(Hash)
+          object = self.allocate
+          object.instance_variable_set("@attributes", attrs.merge(self.default_options))
+          object.send("add_methods!")
+        end
+        object
+      end
+      
+      def get_all
+        page = get_page
+        raise TicketSystemError, "Can't get history." unless page
+        raise TicketSystemInterfaceError, "Error getting history for Ticket: #{ticket.id}." unless page.split("\n")[0].include?("200")
+        history_array = get_histories_from_page(page)
+        history_array
+      end
+      
+      def get_histories_from_page(page)
+        full_history = HistoryArray.new
+        for history in page.split(/^--$/)
+          history = history.split("\n")
+          history.extend(Roart::TicketPage)
+          full_history << self.instantiate(history.to_history_hash)
+        end
+        full_history.instance_variable_set("@default_options", @default_options)
+        full_history
+      end
+      
+      def get_page
+        @default_options[:ticket].class.connection.get(uri_for(@default_options[:ticket]))
+      end
+      
+      def uri_for(ticket)
+        uri = self.default_options[:ticket].class.connection.rest_path + "ticket/#{ticket.id}/history?format=l"
+      end
+      
+    end
+    
+    protected 
+    
+  end
+  
+end