roart 0.1.5.1 → 0.1.6

data/History.txt

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

data/lib/roart.rb

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

data/lib/roart/connection.rb

@@ -17,7 +17,7 @@ module Roart
     def initialize(conf)
       if conf.is_a?(String)
         raise "Loading Config File not yet implemented"
-      elsif conf.is_a?(Hash)
+      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)

data/lib/roart/core/array.rb

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

data/lib/roart/core/hash.rb

@@ -1,15 +1,22 @@
+require "#{File.dirname(__FILE__)}/hash/indifferent_access.rb"
 class Hash
   def to_content_format
-    fields = self.map do |key,value| 
+    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}"
+          "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.join("\n")
+    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,133 @@
+# 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
+

data/lib/roart/roart.rb

@@ -1,25 +1,24 @@
 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
+    unless required.inject(true) do |inc, attr|
+        inc ? hash.keys.include?(attr) : nil
       end
-      raise ArgumentError, "Not all required fields entered" 
+      raise ArgumentError, "Not all required fields entered"
     end
   end
-  
+
   def self.check_keys(hash, required)
-    unless required.inject(true) do |inc, attr| 
+    unless required.inject(true) do |inc, attr|
         inc ? hash.keys.include?(attr.to_sym) : nil
       end
       return false
     end
     return true
   end
-  
+
   module MethodFunctions
-    
+
     def add_methods!
       @attributes.each do |key, value|
         (class << self; self; end).send :define_method, key do
@@ -28,9 +27,9 @@ module Roart
         (class << self; self; end).send :define_method, "#{key}=" do |new_val|
           @attributes[key] = new_val
         end
-      end 
+      end
     end
-    
+
   end
-  
+
 end

data/lib/roart/ticket.rb

@@ -2,7 +2,7 @@ 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)
+    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 text)
     RequiredAttributes = %w(queue subject)
 
   end
@@ -62,17 +62,25 @@ module Roart
         self.before_update
         uri = "#{self.class.connection.server}/REST/1.0/ticket/#{self.id}/edit"
         payload = @attributes.clone
-        payload.delete(:id)
+        payload.delete("text")
+        payload.delete("id") # Can't have text in an update, only create, use comment for updateing
         payload = payload.to_content_format
+        puts payload
         resp = self.class.connection.post(uri, :content => payload)
+        puts resp
         resp = resp.split("\n")
         raise "Ticket Update Failed" unless resp.first.include?("200")
-        if resp[2].match(/^# Ticket (\d+) updated./)
-          self.after_update
-          true
-        else
-          false
+        resp.each do |line|
+          puts "line"
+          if line.match(/^# Ticket (\d+) updated./)
+            self.after_update
+            puts "FOUND"
+            return true
+          else
+            #TODO: Add warnign to ticket
+          end
         end
+        return false
       end
     end
 
@@ -111,14 +119,17 @@ module Roart
         resp = self.class.connection.post(uri, :content => payload)
         resp = resp.split("\n")
         raise "Ticket Create Failed" unless resp.first.include?("200")
-        if tid = resp[2].match(/^# Ticket (\d+) created./)
-          @attributes[:id] = tid[1].to_i
-          self.after_create
-          @new_record = false
-          true
-        else
-          false
+        resp.each do |line|
+          if tid = line.match(/^# Ticket (\d+) created./)
+            @attributes[:id] = tid[1].to_i
+            self.after_create
+            @new_record = false
+            return true
+          else
+            #TODO: Add Warnings To Ticket
+          end
         end
+        return false
       end
 
       def create! #:nodoc:
@@ -241,7 +252,7 @@ module Roart
             array << object
           end
           return array
-        elsif attrs.is_a?(Hash)
+        elsif attrs.is_a?(Hash) || attrs.is_a?(HashWithIndifferentAccess)
           object = self.allocate
           object.instance_variable_set("@attributes", attrs)
           object.send("add_methods!")
@@ -279,11 +290,37 @@ module Roart
         end
       end
 
+      def page_list_array(uri) #:nodoc:
+        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 = page.join("\n")
+          chunks = page.split(/^--$/)
+          page = []
+          for chunk in chunks
+            chunk = chunk.split("\n")
+            chunk.delete_if{|x| !x.include?(":")}
+            page << chunk
+          end
+          page
+        else
+          raise TicketSystemInterfaceError, "Error Getting Ticket: #{status}"
+        end
+      end
+
       def get_tickets_from_search_uri(uri) #:nodoc:
-        page = page_array(uri)
+        page = page_list_array(uri + "&format=l")
         page.extend(Roart::TicketPage)
-        page = page.to_search_array
-        self.instantiate(page)
+        page = page.to_search_list_array
+        array = Array.new
+        for ticket in page
+          ticket = self.instantiate(ticket)
+          ticket.instance_variable_set("@full", true)
+          array << ticket
+        end
+        array
       end
 
       def get_ticket_from_uri(uri) #:nodoc:

data/lib/roart/ticket_page.rb

@@ -5,7 +5,7 @@ module Roart
     IntKeys = %w[id]
 
     def to_hash
-      hash = Hash.new
+      hash = HashWithIndifferentAccess.new
       self.delete_if{|x| !x.include?(":")}
       self.each do |ln|
         ln = ln.split(":")
@@ -17,12 +17,21 @@ module Roart
           key = ln.delete_at(0).strip.underscore
         end
         value = ln.join(":").strip
-        hash[key.to_sym] = value if key
+        hash[key] = value if key
       end
-      hash[:id] = hash[:id].split("/").last.to_i
+      hash["id"] = hash["id"].split("/").last.to_i
       hash
     end
 
+    def to_search_list_array
+      array = Array.new
+      self.each do |ticket|
+        ticket.extend(Roart::TicketPage)
+        array << ticket.to_hash
+      end
+      array
+    end
+
     def to_search_array
       array = Array.new
       self.delete_if{|x| !x.include?(":")}
@@ -42,7 +51,7 @@ module Roart
 
 # TODO: Don't throw away attachments (/^ {13})
     def to_history_hash
-      hash = Hash.new
+      hash = HashWithIndifferentAccess.new
       self.delete_if{|x| !x.include?(":") && !x.match(/^ {9}/) && !x.match(/^ {13}/)}
       self.each do |ln|
         if ln.match(/^ {9}/) && !ln.match(/^ {13}/)
@@ -54,7 +63,7 @@ module Roart
           unless ln.size == 1 || ln.first == 'Ticket' # we don't want to override the ticket method.
             key = ln.delete_at(0).strip.underscore
             value = ln.join(":").strip
-            hash[key.to_sym] = IntKeys.include?(key) ? value.to_i : value
+            hash[key] = IntKeys.include?(key) ? value.to_i : value
           end
         end
       end

data/lib/roart/validations.rb

@@ -1,37 +1,37 @@
 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?
@@ -41,42 +41,42 @@ module Roart
     def clear
       @errors = {}
     end
-    
-    # Returns the total number of errors added. Two errors added to the same attribute will be counted as such.    
+
+    # 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 => '<=',
@@ -85,23 +85,23 @@ module Roart
       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") 
+              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.
@@ -114,19 +114,19 @@ module Roart
         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)          
+            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.") 
+                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")
@@ -137,7 +137,7 @@ module Roart
             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.") 
+                obj.errors.add(field.to_sym, "Must be more than #{option_value} characters.")
               end
             end
             self.validator.add(validator_proc)
@@ -145,29 +145,28 @@ module Roart
             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.") 
+                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.") 
+                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."
@@ -176,46 +175,46 @@ module Roart
         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]) 
+                  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