ludo-roart 0.1.11

data/History.txt

@@ -0,0 +1,45 @@
+==0.1.9 / 2010-05-23
+Removed the String/Hash extensions copied from ActiveSupport and just added a dependency on ActiveSupport. Removed to_hash added to Array, as it conflicts with ActiveSupport's deep_merge. (via hennk)
+==0.1.8 / 2010-03-16
+Added validate presence of.
+Updated specs to test validations.
+No Longer depend on mechanize version 0.9.3 and get rid of those pesky deprecation warnings.
+The connection adapter classes are now suffixed with "Adapter", so Mechanize is now MechanizeAdapter. You still specify it with :adapter => 'mechanize', however.
+
+==0.1.7 / 2010-03-11
+Added some new error classes, add removed any extraneous raise 'text' (via jrbingham)
+Removed debugging puts from the ticket file.
+
+==0.1.6 / 2010-03-09
+Updated the search feature to pull all the ticket information at the same time, instead of only loading the id and subject.
+Fixed tests that were failing because of out-of-order strings.
+Returned to a sane version numbering scheme, sorry about that.
+
+==0.1.5.2 / 2010-01-20
+New ticket objects now come with a default attribute :text that specifies the initial log of the ticket.
+
+==0.1.5.1 / 2010-01-20
+Fixed a bug that caused custom fields not to show up in the ticket attributes
+
+==0.1.5 / 2010-01-19
+Can add transactions ticket using #comment method. (via btucker)
+Can authenticate again after the Ticket class is declared. (via newellista)
+More search fields are now avaliable. (via threetee)
+
+==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,89 @@
+== 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."
+
+* Comment on a Ticket
+    ticket = Ticket.find(23452)
+    ticket.comment("This is a lovely Ticket", :time_worked => 45, :cc => 'someone@example.com'))
+
+
+== 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' #this will go away when a stdlib adapter gets written
+
+PROJ.spec.opts << '--color'
+
+# EOF

data/lib/roart.rb

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'active_support'
+require 'active_support/core_ext'
+
+module Roart
+
+  # :stopdoc:
+  VERSION = '0.1.9'
+  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,65 @@
+require 'yaml'
+
+module Roart
+
+  module Connections
+    RequiredConfig = %w(server adapter)
+    RequiredToLogin = %w( user pass )
+
+  end
+
+  class Connection
+
+    attr_reader :agent
+    attr_reader :conf
+
+    def initialize(conf)
+      if conf.is_a?(String)
+        raise RoartError, "Loading Config File not yet implemented"
+      elsif conf.class.name == Hash.name #TODO: Figure out why conf.is_a?(Hash) doesn't work
+        @conf = conf
+      end
+      if Roart::check_keys(conf, Roart::Connections::RequiredConfig)
+        @agent = @conf[:login]
+        add_methods!
+      else
+        raise RoartError, "Configuration Error"
+      end
+    end
+
+    def authenticate(conf)
+      if Roart::check_keys(conf, Roart::Connections::RequiredToLogin)
+        connection.authenticate(conf)
+        self
+      end
+    end
+
+    def rest_path
+      self.server + '/REST/1.0/'
+    end
+
+    def get(uri)
+      connection.get(uri)
+    end
+
+    def post(uri, payload)
+      connection.post(uri, payload)
+    end
+
+    protected
+
+    def connection
+      @connection ||= ConnectionAdapter.new(conf)
+    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/connection_adapter.rb

@@ -0,0 +1,21 @@
+require 'forwardable'
+
+module Roart
+
+  class ConnectionAdapter
+    extend Forwardable
+
+    def initialize(config)
+      @adapter = Roart::ConnectionAdapters.const_get(config[:adapter].capitalize + "Adapter").new(config)
+      @adapter.login(config) if config[:user] && config[:pass]
+    end
+
+    def authenticate(config)
+      @adapter.login(config)
+    end
+
+    def_delegators :@adapter, :get, :post
+
+  end
+
+end

data/lib/roart/connection_adapters/mechanize_adapter.rb

@@ -0,0 +1,32 @@
+require 'mechanize'
+
+module Roart
+  module ConnectionAdapters
+    class MechanizeAdapter
+
+      def initialize(config)
+        @conf = config
+      end
+
+      def login(config)
+        @conf.merge!(config)
+        agent = Mechanize.new
+        page = agent.get(@conf[:server])
+        form = page.form('login')
+        form.user = @conf[:user]
+        form.pass = @conf[:pass]
+        page = agent.submit form
+        @agent = agent
+      end
+
+      def get(uri)
+        @agent.get(uri).body
+      end
+
+      def post(uri, payload)
+        @agent.post(uri, payload).body
+      end
+
+    end
+  end
+end

data/lib/roart/core/content_formatter.rb

@@ -0,0 +1,12 @@
+module Roart
+  class ContentFormatter
+    # The following is only based on quick trial&error on my part. The RT Api (at least in 3.6) does not have good documentation.
+    # Strings in a RT request:
+    #  - are not allowed to contain '\r'
+    #  - must use equally padded new-lines to distinguish them from the beginning of a new field (we use 2-space padding)
+    def self.format_string(string)
+      string.gsub("\r", '').gsub("\n", "\n  ")
+    end
+
+  end
+end

data/lib/roart/core/hash.rb

@@ -0,0 +1,22 @@
+class Hash
+  def to_content_format
+    fields = self.map do |key,value|
+      unless value.nil?
+        value = Roart::ContentFormatter.format_string(value.to_s)
+        if key.to_s.match(/^cf_.+/)
+          "CF-#{key.to_s[3..key.to_s.length].gsub(/_/, " ").camelize.humanize}: #{value}"
+        else
+          "#{key.to_s.camelize}: #{value}"
+        end
+      end
+    end
+    content = fields.compact.sort.join("\n")
+  end
+
+  def with_indifferent_access
+    hash = HashWithIndifferentAccess.new(self)
+    hash.default = self.default
+    hash
+  end
+
+end

data/lib/roart/errors.rb

@@ -0,0 +1,13 @@
+module Roart
+  
+  class RoartError < StandardError; end
+  
+  class ArgumentError < RoartError; end
+  
+  class TicketSystemError < RoartError; end
+  
+  class TicketSystemInterfaceError < RoartError; end
+  
+  class TicketNotFoundError < 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