roart 0.1.4 → 0.1.5

data/History.txt

@@ -1,3 +1,8 @@
+==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.

data/README.rdoc

@@ -1,61 +1,61 @@
 == 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. 
+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. 
+
+* 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)
@@ -63,20 +63,24 @@ If you are using Best Practical's Request Tracker (RT) and you need to interact
     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

data/lib/roart/connection.rb

@@ -2,53 +2,55 @@ require 'yaml'
 require 'mechanize'
 
 module Roart
-  
+
   module Connections
-    RequiredConfig = %w(server user pass)
-  
+    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 "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!
+      if Roart::check_keys(conf, Roart::Connections::RequiredConfig)
+        @agent = @conf[:login]
+        add_methods!
+        @connection = ConnectionAdapter.new(@conf)
+      else
+        raise "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)
-      @agent.get(uri).body
+      @connection.get(uri)
     end
-    
+
     def post(uri, payload)
-      @agent.post(uri, payload).body
+      @connection.post(uri, payload)
     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
@@ -56,7 +58,7 @@ module Roart
         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).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,30 @@
+module Roart
+  module ConnectionAdapters
+    class Mechanize
+
+      def initialize(config)
+        @conf = config
+      end
+
+      def login(config)
+        @conf.merge!(config)
+        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 = 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/string.rb

@@ -18,4 +18,9 @@ class String
   def humanize
     self.gsub(/_id$/, "").gsub(/_/, " ").capitalize
   end
+  
+  def blank?
+    self == ""
+  end
+  
 end

data/lib/roart/roart.rb

@@ -1,6 +1,7 @@
 module Roart
   
   def self.check_keys!(hash, required)
+    puts hash
     unless required.inject(true) do |inc, attr| 
         inc ? hash.keys.include?(attr.to_sym) : nil
       end
@@ -8,6 +9,14 @@ module Roart
     end
   end
   
+  def self.check_keys(hash, required)
+    unless required.inject(true) do |inc, attr| 
+        inc ? hash.keys.include?(attr.to_sym) : nil
+      end
+      return false
+    end
+    return true
+  end
   
   module MethodFunctions
     

data/lib/roart/ticket.rb

@@ -1,38 +1,40 @@
 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)
     RequiredAttributes = %w(queue subject)
-  
+
   end
-  
+
   class Ticket
-    
+
     include Roart::MethodFunctions
     include Roart::Callbacks
-    
+    require File.join(File.dirname(__FILE__), %w[ validations.rb ])
+    include Roart::Validations
+
     attr_reader :full, :history, :saved
-    
+
     # Creates a new ticket. Attributes queue and subject are required. Expects a hash with the attributes of the ticket.
     #
     #   ticket = MyTicket.new(:queue => "Some Queue", :subject => "The System is Down.")
     #   ticket.id #-> This will be the ID of the ticket in the RT System.
     #
-    def initialize(attributes)
-      Roart::check_keys!(attributes, Roart::Tickets::RequiredAttributes)
-      if attributes.is_a?(Hash)
+    def initialize(attributes=nil)
+      if attributes
         @attributes = Roart::Tickets::DefaultAttributes.to_hash.merge(attributes)
-        @attributes.update(:id => 'ticket/new')
-        @saved = false
       else
-        raise ArgumentError, "Expects a hash."
+        @attributes = Roart::Tickets::DefaultAttributes.to_hash
       end
+      @attributes.update(:id => 'ticket/new')
+      @saved = false
       @history = false
+      @new_record = true
       add_methods!
     end
-    
-    # Loads all information for a ticket from RT and lets full to true. 
+
+    # 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. custom fields hold their case from how they are defined in RT, so a custom field of PhoneNumber would be cf_PhoneNumber and a custom field of phone_number would be cf_phone_number
@@ -44,13 +46,13 @@ module Roart
         add_methods!
       end
     end
-    
+
     #loads the ticket history from rt
     #
     def histories
       @histories ||= Roart::History.default(:ticket => self)
     end
-    
+
     # if a ticket is new, calling save will create it in the ticketing system and assign the id that it gets to the id attribute. It returns true if the save was successful, and false if something went wrong
     #
     def save
@@ -88,16 +90,20 @@ module Roart
       raise "Ticket Comment Failed" unless resp.first.include?("200")
       !!resp[2].match(/^# Message recorded/)
     end
-    
+
     # works just like save, but if the save fails, it raises an exception instead of silently returning false
     #
     def save!
       raise "Ticket Create Failed" unless self.save
       true
     end
-    
+
+    def new_record?
+      return @new_record
+    end
+
     protected
-      
+
       def create #:nodoc:
         self.before_create
         uri = "#{self.class.connection.server}/REST/1.0/ticket/new"
@@ -108,19 +114,20 @@ module Roart
         if tid = resp[2].match(/^# Ticket (\d+) created./)
           @attributes[:id] = tid[1].to_i
           self.after_create
+          @new_record = false
           true
         else
           false
-        end      
+        end
       end
-      
+
       def create! #:nodoc:
         raise "Ticket Create Failed" unless self.create
         true
       end
-    
+
     class << self #class methods
-      
+
       # Searches for a ticket or group of tickets with an active record like interface.
       #
       # Find has 3 different ways to search for tickets
@@ -133,15 +140,15 @@ module Roart
       #
       # ====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>: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. 
+      # * <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)
       #   MyTicket.find(:first, :queue => 'My Queue')
       #   MyTicket.find(:first, :status => [:new, :open])
       #   MyTicket.find(:first, :queue => 'My Queue', :status => :resolved)
@@ -163,24 +170,46 @@ module Roart
           else              find_by_ids(args, options)
         end
       end
-      
 
-      # 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, 
+
+      # Accepts parameters for connecting to an RT server.
+      # Required:
+      # :server sets the URL for the rt server, :ie http://rt.server.com/
+      # Optional:
+      # :user sets the username to connect to RT
+      # :pass sets the password for the user to connect with
+      # :adapter is the connection adapter to connect with. Defaults to Mechanize
+      #
       #     class Ticket < Roart::Ticket
       #       connection :server => 'server', :user => 'user', :pass => 'pass'
       #     end
       #
       def connection(options=nil)
         if options
-          @connection = Roart::Connection.new(options)
+          @connection = Roart::Connection.new({:adapter => "mechanize"}.merge(options))
         else
           defined?(@connection) ? @connection : nil
         end
       end
-      
-      # Adds a default queue to search each time. This is overridden by 
+
+      # Sets the username and password used to connect to the RT server
+      # Required:
+      # :user sets the username to connect to RT
+      # :pass sets the password for the user to connect with
+      # This can be used to change a connection once the Ticket class has
+      # been initialized. Not required if you sepecify :user and :pass in
+      # the connection method
+      #
+      #     class Ticket < Roart::Ticket
+      #       connection :server => 'server'
+      #       authenticate :user => 'user', :pass => 'pass'
+      #     end
+      #
+      def authenticate(options)
+        @connection.authenticate(options)
+      end
+
+      # Adds a default queue to search each time. This is overridden by
       # specifically including a :queue option in your find method. This can
       # be an array of queue names or a string with a single queue name.
       #
@@ -191,16 +220,16 @@ module Roart
           defined?(@default_queue) ? @default_queue : nil
         end
       end
-      
+
       # creates a new ticket object and immediately saves it to the database.
       def create(options)
         ticket = self.new(options)
         ticket.save
         ticket
       end
-      
+
       protected
-      
+
       def instantiate(attrs) #:nodoc:
         object = nil
         if attrs.is_a?(Array)
@@ -218,43 +247,45 @@ module Roart
           object.send("add_methods!")
         end
         object.instance_variable_set("@history", false)
+        object.instance_variable_set("@new_record", false)
         object
       end
-      
+
       def find_initial(options={}) #:nodoc:
         options.update(:limit => 1)
         find_all(options).first
       end
-      
+
       def find_all(options) #:nodoc:
         uri = construct_search_uri(options)
         tickets = get_tickets_from_search_uri(uri)
       end
-      
+
       def find_by_ids(args, options) #:nodoc:
+        raise "First argument must be :all or :first, or an ID with no hash options" unless args.first.is_a?(Fixnum) || args.first.is_a?(String)
         get_ticket_by_id(args.first)
       end
-      
+
       def page_array(uri) #:nodoc:
         page = self.connection.get(uri)
         raise TicketSystemError, "Can't get ticket." unless page
-        page = page.split("\n")   
+        page = page.split("\n")
         status = page.delete_at(0)
-        if status.include?("200") 
-          page.delete_if{|x| !x.include?(":")} 
+        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) #:nodoc:
         page = page_array(uri)
         page.extend(Roart::TicketPage)
         page = page.to_search_array
         self.instantiate(page)
       end
-      
+
       def get_ticket_from_uri(uri) #:nodoc:
         page = page_array(uri)
         page.extend(Roart::TicketPage)
@@ -263,20 +294,20 @@ module Roart
         ticket.instance_variable_set("@full", true)
         ticket
       end
-      
+
       def get_ticket_by_id(id) #:nodoc:
         uri = "#{self.connection.server}/REST/1.0/ticket/"
         uri << id.to_s
         get_ticket_from_uri(uri)
       end
-      
+
       def construct_search_uri(options={}) #:nodoc:
         uri = "#{self.connection.server}/REST/1.0/search/ticket?"
         uri << 'orderby=-Created&' if options.delete(:order)
         unless options.empty? && default_queue.nil?
           uri << 'query= '
           query = Array.new
-          
+
           if options[:queues] || options[:queue]
             add_queue!(query, options[:queues] || options[:queue])
           else
@@ -286,14 +317,14 @@ module Roart
           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) #:nodoc:
         return false unless queue
         if queue.is_a?(Array)
@@ -306,7 +337,7 @@ module Roart
           uri << "Queue = '#{queue.to_s}'"
         end
       end
-      
+
       def add_custom_fields!(uri, options) #:nodoc:
         return false unless options
         options.each do |field, value|
@@ -321,7 +352,7 @@ module Roart
           end
         end
       end
-      
+
       def add_status!(uri, options) #:nodoc:
         return false unless options
         parts = Array.new
@@ -336,9 +367,9 @@ module Roart
         end
         uri << parts
       end
-      
+
       def add_searches!(uri, options) #:nodoc:
-        search_fields = %w( subject content content_type file_name)
+	search_fields = %w( subject content content_type file_name owner requestors cc admin_cc)
         options.each do |key, value|
           if search_fields.include?(key.to_s)
             key = key.to_s.camelize
@@ -354,7 +385,7 @@ module Roart
           end
         end
       end
-      
+
       def add_dates!(uri, options) #:nodoc:
         date_field = %w( created started resolved told last_updated starts due updated )
         options.each do |key, value|
@@ -373,9 +404,9 @@ module Roart
           end
         end
       end
-      
+
     end
-    
+
   end
-    
+
 end

data/lib/roart/validations.rb

@@ -0,0 +1,221 @@
+module Roart
+    
+  class Errors
+    include Enumerable
+    
+    def initialize(obj)
+      @base, @errors = obj, {}
+    end
+    
+    def add_to_base(msg)
+      add(:base, msg)
+    end
+    
+    def add(field, message)
+      @errors[field.to_sym] ||= []
+      @errors[field.to_sym] << message
+    end
+    
+    def on_base
+      on(:base)
+    end
+    
+    def on(field)
+      errors = @errors[field.to_sym]
+      return nil if errors.nil?
+      errors
+    end
+    
+    alias :[] :on
+    
+    def each
+      @errors.each_key { |attr| @errors[attr].each { |msg| yield attr, msg } }
+    end
+    
+    # Returns true if no errors have been added.
+    def empty?
+      @errors.empty?
+    end
+
+    # Removes all errors that have been added.
+    def clear
+      @errors = {}
+    end
+    
+    # Returns the total number of errors added. Two errors added to the same attribute will be counted as such.    
+    def size
+      @errors.values.inject(0) { |error_count, attribute| error_count + attribute.size }
+    end
+    
+    alias_method :count, :size
+    alias_method :length, :size
+      
+  end
+  
+  module Validations
+    
+    def self.included(model)
+      model.extend ClassMethods
+
+    end
+  
+    class Validators
+      
+      def initialize
+        @validators = []
+      end
+      
+      def add(validator)
+        @validators << validator
+      end
+      
+      def validate(obj)
+        @validators.each{|validator| validator.call(obj)}
+      end
+      
+    end
+    
+    module ClassMethods
+      
+      ALL_RANGE_OPTIONS = [ :is, :within, :in, :minimum, :min, :maximum, :max ].freeze
+      ALL_NUMERICALITY_CHECKS = { :greater_than => '>', :greater_than_or_equal_to => '>=',
+                                  :equal_to => '==', :less_than => '<', :less_than_or_equal_to => '<=',
+                                  :odd => 'odd?', :even => 'even?' }.freeze
+
+      def validator
+        @validator ||= Validators.new
+      end
+      
+      def validates_presence_of(*args)
+        
+      end
+      
+      def validates_format_of(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        args.each do |field|
+          validator_proc = lambda do |obj|
+            unless obj.send(field.to_sym).match(options[:format])
+              obj.errors.add(field.to_sym, "Wrong Format") 
+            end
+          end
+          self.validator.add(validator_proc)
+        end
+      end
+      
+      def validates_length_of(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        # Ensure that one and only one range option is specified.
+        range_options = ALL_RANGE_OPTIONS & options.keys
+        case range_options.size
+        when 0
+          raise ArgumentError, 'Range unspecified.  Specify the :within, :maximum, :minimum, or :is option.'
+        when 1
+          # Valid number of options; do nothing.
+        else
+          raise ArgumentError, 'Too many range options specified.  Choose only one.'
+        end
+        
+        option = range_options.first
+        option_value = options[range_options.first]
+        key = {:is => :wrong_length, :minimum => :too_short, :maximum => :too_long}[option]
+        custom_message = options[:message] || options[key]
+        
+        args.each do |field|
+          case option
+          when :within, :in
+            raise ArgumentError, ":#{option} must be a Range" unless option_value.is_a?(Range)          
+            validator_proc = lambda do |obj|
+              if obj.send(field.to_sym).length < option_value.begin
+                obj.errors.add(field.to_sym, "Must be more than #{option_value.begin} characters.") 
+              end
+              if obj.send(field.to_sym).length > option_value.end
+                obj.errors.add(field.to_sym, "Must be less than #{option_value.end} characters")
+              end
+            end
+            self.validator.add(validator_proc)
+          when :min, :minium
+            raise ArgumentError, ":#{option} must be an Integer" unless option_value.is_a?(Integer)
+            validator_proc = lambda do |obj|
+              if obj.send(field.to_sym).length < option_value
+                obj.errors.add(field.to_sym, "Must be more than #{option_value} characters.") 
+              end
+            end
+            self.validator.add(validator_proc)
+          when :max, :maxium
+            raise ArgumentError, ":#{option} must be an Integer" unless option_value.is_a?(Integer)
+            validator_proc = lambda do |obj|
+              if obj.send(field.to_sym).length > option_value
+                obj.errors.add(field.to_sym, "Must be less than #{option_value} characters.") 
+              end
+            end
+            self.validator.add(validator_proc)
+          when :is
+            raise ArgumentError, ":#{option} must be an Integer" unless option_value.is_a?(Integer)
+            validator_proc = lambda do |obj|
+              puts "#{field} is #{option_value}"
+              unless obj.send(field.to_sym).length == option_value
+                obj.errors.add(field.to_sym, "Must be #{option_value} characters.") 
+              end
+            end
+            self.validator.add(validator_proc)
+          end
+        end
+      end
+      
+      alias_method :validates_size_of, :validates_length_of
+      
+      def validates_numericality_of(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        numericality_options = ALL_NUMERICALITY_CHECKS & options.keys
+        
+        case numericality_options
+        when 0
+          raise ArgumentError, "Options Unspecified. Specify an option to use."
+        when 1
+          #continue
+        else
+          raise ArgumentError, "Too many options specified"
+        end
+        
+        option = numericality_options.first
+        option_value = options[numericality_options.first]
+        key = {:is => :wrong_length, :minimum => :too_short, :maximum => :too_long}[option]
+        custom_message = options[:message] || options[key]
+        
+        args.each do |field|
+          numericality_options.each do |option|
+            case option
+              when :odd, :even
+                unless raw_value.to_i.method(ALL_NUMERICALITY_CHECKS[option])[]
+                  record.errors.add(attr_name, option, :value => raw_value, :default => configuration[:message]) 
+                end
+              else
+                record.errors.add(attr_name, option, :default => configuration[:message], :value => raw_value, :count => configuration[option]) unless raw_value.method(ALL_NUMERICALITY_CHECKS[option])[configuration[option]]
+            end
+          end
+        end
+        
+      end
+      
+    end
+    
+    def validator
+      self.class.validator
+    end
+    
+    def valid?
+      validator.validate self
+      self.errors.size == 0
+    end
+    
+    def invalid?
+      !valid?
+    end
+    
+    def errors
+      @errors ||= Errors.new(self)
+    end
+    
+  end
+    
+end

data/lib/roart.rb

@@ -2,7 +2,7 @@ require 'rubygems'
 module Roart
 
   # :stopdoc:
-  VERSION = '0.1.4'
+  VERSION = '0.1.5'
   LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
   PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
   # :startdoc:

data/roart.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{roart}
-  s.version = "0.1.4"
+  s.version = "0.1.5"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["PJ Davis"]
-  s.date = %q{2009-08-19}
+  s.date = %q{2010-01-12}
   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", "spec/test_data/full_history.txt", "spec/test_data/single_history.txt"]
@@ -34,4 +34,4 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<mechanize>, [">= 0.9.0"])
     s.add_dependency(%q<bones>, [">= 2.5.1"])
   end
-end
+end

data/spec/roart/connection_adapter_spec.rb

@@ -0,0 +1,11 @@
+
+require File.join(File.dirname(__FILE__), %w[ .. spec_helper])
+
+describe "ConnectionAdapter" do
+  
+  it 'should give us back a connection' do
+    Roart::ConnectionAdapters::Mechanize.should_receive(:new).with(:adapter => 'mechanize').and_return(mock('mechanize'))
+    Roart::ConnectionAdapter.new(:adapter => 'mechanize')
+  end
+
+end

data/spec/roart/connection_spec.rb

@@ -2,6 +2,49 @@
 require File.join(File.dirname(__FILE__), %w[ .. spec_helper])
 
 describe "Connection" do
+
+  describe 'get and post' do
+
+    before do
+      @agent = mock("agent", :null_object => true)
+      @options = {:server => 'server', :user => 'user', :pass => 'pass', :adapter => 'whatev'}
+      Roart::ConnectionAdapter.should_receive(:new).and_return(@agent)
+    end  
+  
+    it 'should respond to get' do
+      @agent.should_receive(:get).with('some_uri').and_return('body')
+      connection = Roart::Connection.new(@options)
+      connection.get("some_uri").should == 'body'
+    end
+  
+    it 'should respond to post' do
+      @agent.should_receive(:post).with('some_uri', 'a payload').and_return('body')
+      connection = Roart::Connection.new(@options)
+      connection.post("some_uri", "a payload").should == 'body'
+    end
+
+  end
+  
+  it 'should raise an exception if it doesnt have all the options' do
+    lambda{Roart::Connection.new(:user => 'bad')}.should raise_error
+  end
+  
+  it 'should give us the rest path' do
+    @agent = mock("agent", :null_object => true)
+    @options = {:server => 'server', :user => 'user', :pass => 'pass', :adapter => 'whatev'}
+    Roart::ConnectionAdapter.should_receive(:new).and_return(@agent)
+    connection = Roart::Connection.new(@options)
+    connection.rest_path.should == 'server/REST/1.0/'
+  end
   
+  it 'should give us back the whole thing' do
+    mock_mech = mock('mech')
+    @options = {:server => 'server', :user => 'user', :pass => 'pass', :adapter => 'mechanize'}
+    Roart::ConnectionAdapters::Mechanize.should_receive(:new).with(@options).and_return(mock_mech)
+		mock_mech.should_receive(:login).with(@options)
+    mock_mech.should_receive(:get).with('uri').and_return('body')
+    connection = Roart::Connection.new(@options)
+    connection.get('uri').should == 'body'
+  end
   
 end 

data/spec/roart/ticket_spec.rb

@@ -3,8 +3,8 @@ 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
+    Roart::Connection.should_receive(:new).with(:some => 'some options', :adapter => "www").and_return(true)
+    Roart::Ticket.connection(:some => 'some options', :adapter => "www").should == true
   end
   
   it "should find the first ticket" do
@@ -341,7 +341,9 @@ describe "Ticket" do
     
       it 'should be able to save a new ticket' do
         ticket = Roart::Ticket.new(@payload)
+        ticket.new_record?.should be_true
         ticket.save
+        ticket.new_record?.should be_false
       end
       
       it  'should be able to create a ticket' do
@@ -360,8 +362,9 @@ describe "Ticket" do
     describe 'updating tickets' do
     
       before do 
-        @post_data = @payload = {:subject => 'A New Ticket', :queue => 'My Queue'}
-        @post_data[:subject] = 'An Old Ticket'
+        @payload = {:queue => 'My Queue', :subject => 'An Old Ticket'}
+        @post_data = {:queue => 'My Queue', :subject => 'An Old Ticket'}
+        @payload[:subject] = 'A New Ticket'
         @post_data = to_content_format(@post_data)
         @mock_connection = mock('connection')
         @mock_connection.should_receive(:server).and_return('uri')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: roart
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors: 
 - PJ Davis
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-12 00:00:00 -04:00
+date: 2010-01-19 00:00:00 -06:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -50,6 +50,8 @@ files:
 - lib/roart.rb
 - lib/roart/callbacks.rb
 - lib/roart/connection.rb
+- lib/roart/connection_adapter.rb
+- lib/roart/connection_adapters/mechanize_adapter.rb
 - lib/roart/core/array.rb
 - lib/roart/core/hash.rb
 - lib/roart/core/string.rb
@@ -58,8 +60,10 @@ files:
 - lib/roart/roart.rb
 - lib/roart/ticket.rb
 - lib/roart/ticket_page.rb
+- lib/roart/validations.rb
 - roart.gemspec
 - spec/roart/callbacks_spec.rb
+- spec/roart/connection_adapter_spec.rb
 - spec/roart/connection_spec.rb
 - spec/roart/core/array_spec.rb
 - spec/roart/core/hash_spec.rb