axtro-roart 0.1.8

data/History.txt

@@ -0,0 +1,43 @@
+==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,49 @@
+require 'rubygems'
+module Roart
+
+  # :stopdoc:
+  VERSION = '0.1.8'
+  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,63 @@
+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!
+        @connection = ConnectionAdapter.new(@conf)
+      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 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/array.rb

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

data/lib/roart/core/hash.rb

@@ -0,0 +1,22 @@
+require "#{File.dirname(__FILE__)}/hash/indifferent_access.rb"
+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].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/core/hash/indifferent_access.rb

@@ -0,0 +1,135 @@
+unless defined?(HashWithIndifferentAccess)
+  # used from ActiveSupport
+  # Copyright (c) 2005-2009 David Heinemeier Hansson
+
+  # This class has dubious semantics and we only have it so that
+  # people can write params[:key] instead of params['key']
+  # and they get the same value for both keys.
+
+  class HashWithIndifferentAccess < Hash
+    def initialize(constructor = {})
+      if constructor.is_a?(Hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    def default(key = nil)
+      if key.is_a?(Symbol) && include?(key = key.to_s)
+        self[key]
+      else
+        super
+      end
+    end
+
+    alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+    alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+    # Assigns a new value to the hash:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash[:key] = "value"
+    #
+    def []=(key, value)
+      regular_writer(convert_key(key), convert_value(value))
+    end
+
+    # Updates the instantized hash with values from the second:
+    #
+    #   hash_1 = HashWithIndifferentAccess.new
+    #   hash_1[:key] = "value"
+    #
+    #   hash_2 = HashWithIndifferentAccess.new
+    #   hash_2[:key] = "New Value!"
+    #
+    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+    #
+    def update(other_hash)
+      other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+      self
+    end
+
+    alias_method :merge!, :update
+
+    # Checks the hash for a key matching the argument passed in:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash["key"] = "value"
+    #   hash.key? :key  # => true
+    #   hash.key? "key" # => true
+    #
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+    # Fetches the value for the specified key, same as doing hash[key]
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    # Returns an array of the values at the specified indices:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash[:a] = "x"
+    #   hash[:b] = "y"
+    #   hash.values_at("a", "b") # => ["x", "y"]
+    #
+    def values_at(*indices)
+      indices.collect {|key| self[convert_key(key)]}
+    end
+
+    # Returns an exact copy of the hash.
+    def dup
+      HashWithIndifferentAccess.new(self)
+    end
+
+    # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
+    # Does not overwrite the existing hash.
+    def merge(hash)
+      self.dup.update(hash)
+    end
+
+    # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+    # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a HashWithDifferentAccess.
+    def reverse_merge(other_hash)
+      super other_hash.with_indifferent_access
+    end
+
+    # Removes a specified key from the hash.
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def stringify_keys!; self end
+    def symbolize_keys!; self end
+    def to_options!; self end
+
+    # Convert to a Hash with String keys.
+    def to_hash
+      Hash.new(default).merge(self)
+    end
+
+    protected
+      def convert_key(key)
+        key.kind_of?(Symbol) ? key.to_s : key
+      end
+
+      def convert_value(value)
+        case value
+        when Hash
+          value.with_indifferent_access
+        when Array
+          value.collect { |e| e.is_a?(Hash) ? e.with_indifferent_access : e }
+        else
+          value
+        end
+      end
+  end
+
+end