fiddler 0.0.1 → 1.0.1

data/lib/fiddler/parsers.rb

@@ -1,2 +1,4 @@
 require 'fiddler/parsers/base_parser'
-require 'fiddler/parsers/ticket_parser'
+require 'fiddler/parsers/ticket_parser'
+require 'fiddler/parsers/history_parser'
+require 'fiddler/parsers/attachment_parser'

data/lib/fiddler/parsers/attachment_parser.rb

@@ -0,0 +1,54 @@
+module Fiddler
+   module Parsers
+      class AttachmentParser < BaseParser
+         def self.parse_single(response)
+            response = check_response_code(response)
+            response = check_for_errors(response)
+            attachment_from_response(response)
+         end
+
+         def self.parse_content(response)
+            response = check_response_code(response,false,false)
+            return response.join("\n")
+         end
+
+         protected
+
+         def self.check_for_errors(response)
+            if response.length == 1
+               raise Fiddler::FiddlerError, response.first
+            end
+            response
+         end
+
+         def self.attachment_from_response(response)
+            result = {}
+            collect_headers = false
+            headers = []
+            response.each do |line|
+               matches = /^(\S*?):\s(.*)/.match(line)
+               if(matches)
+                  key = matches[1].underscore
+                  result[key] = matches[2]
+
+                  if key == "headers"
+                     collect_headers = true
+                     next
+                  elsif key == "content"
+                     break
+                  end
+               end
+
+               spaced_content_matches = /^\s{9}(.*)$/.match(line)
+               if spaced_content_matches and collect_headers
+                  headers << spaced_content_matches[1]
+               end
+            end
+            result.delete("content")
+            headers.unshift(result["headers"])
+            result["headers"] = headers
+            attachment = Fiddler::Attachment.new(result)
+         end
+      end
+   end
+end

data/lib/fiddler/parsers/base_parser.rb

@@ -5,19 +5,57 @@ module Fiddler
          SUCCESS_CODES = (200..299).to_a
          ERROR_CODES = (400..499).to_a
          
-         def self.check_response_code(response)
-            lines = response.split("\n").reject { |l| l.nil? or l == "" }
+         def self.check_response_code(response, reject_blank_lines=true, raise_error_for_empty_response=true)
+            response = safe_encode(response)
+            lines = response.split("\n")
+            lines = lines.delete_if { |l| l.nil? or l == "" } if reject_blank_lines
             if lines.count == 0
-               raise RequestError, "Empty Response"
+               if raise_error_for_empty_response
+                  raise RequestError, "Empty Response"
+               else
+                  return []
+               end
             else
                status_line = lines.shift
                version, status_code, status_text = status_line.split(/\s+/,2)
                unless SUCCESS_CODES.include?(status_code.to_i)
                   raise RequestError, status_text
                end
+               lines.shift unless reject_blank_lines
                lines
             end
          end
+
+         def self.tokenize_response(response)
+            tokens = Array.new
+            current = Array.new
+            response.each do |item|
+               if(item == "--")
+                  tokens << current
+                  current = Array.new
+                  next
+               end
+               current << item
+            end
+            tokens << current unless current.empty?
+            tokens
+         end
+
+         protected
+
+         def self.safe_encode(response)
+            require 'iconv' unless String.method_defined?(:encode)
+            if String.method_defined?(:encode)
+               response.encode!('UTF-8', 'UTF-8', :invalid => :replace)
+            else
+               begin
+                  Iconv.iconv("UTF-8//IGNORE", "UTF-8", response).join("")
+               rescue Exception => e
+                  raise IllegalCharacterError, "Attachment contains illegal characters"
+               end 
+            end
+            response
+         end
       end
    end
 end

data/lib/fiddler/parsers/history_parser.rb

@@ -0,0 +1,72 @@
+module Fiddler
+   module Parsers
+      class HistoryParser < BaseParser
+         def self.parse_single(response)
+            response = check_response_code(response)
+            response = check_for_errors(response)
+            history_from_response(response)
+         end
+
+         def self.parse_multiple(response)
+            response = check_response_code(response)
+            response = check_for_errors(response)
+            token_responses = tokenize_response(response)
+            histories = Array.new
+            token_responses.each do |token_response|
+               histories << history_from_response(token_response)
+            end
+            histories
+         end
+
+         protected
+
+         def self.check_for_errors(response)
+            if response.length == 1
+               raise Fiddler::FiddlerError, response.first
+            else
+               response.shift
+            end
+            response
+         end
+
+         def self.history_from_response(response)
+            result = {}
+            content_lines = []
+            result["attachment_ids"] = []
+            collect_content = false
+            collect_attachments = false
+            response.each do |line|
+               matches = /^(\S*?):\s(.*)/.match(line)
+               if(matches)
+                  key = matches[1].underscore
+                  result[key] = matches[2]
+                  if key == "content"
+                     collect_content = true
+                  elsif key == "attachments"
+                     collect_content = false
+                     collect_attachments = true
+                  end
+               end
+
+               if collect_content
+                  content_matches = /^\s{9}(.*)$/.match(line)
+                  if(content_matches)
+                     content_lines << content_matches[1]
+                  end
+               end
+
+               if collect_attachments
+                  attachment_matches = /^\s{13}(.*?):\s(.*)/.match(line)
+                  if(attachment_matches)
+                     result["attachment_ids"] << attachment_matches[1]
+                  end
+               end
+            end
+            result["attachment_ids"].count.times { content_lines.pop }
+            result["content"] += content_lines.join("\n")
+            result.delete("attachments")
+            history = Fiddler::History.new(result)
+         end
+      end
+   end
+end

data/lib/fiddler/parsers/ticket_parser.rb

@@ -10,12 +10,39 @@ module Fiddler
          def self.parse_multiple(response)
             response = check_response_code(response)
             response = check_for_errors(response)
-            ticket_token_responses = tokenize_response(response)
-            tickets = Array.new
-            ticket_token_responses.each do |token_response|
-               tickets << ticket_from_response(token_response)
+            if response.count == 0
+               []
+            else
+               ticket_token_responses = tokenize_response(response)
+               tickets = Array.new
+               ticket_token_responses.each do |token_response|
+                  tickets << ticket_from_response(token_response)
+               end
+               tickets
+            end
+         end
+
+         def self.parse_reply_response(response)
+            response = check_response_code(response)
+            return !response.first.match(/^# Message recorded/).nil?
+         end
+
+         def self.parse_change_ownership_response(response)
+            response = check_response_code(response)
+            if response.first =~ /^# Owner changed from (\S+) to (\S+)/
+               return $2
+            else
+               return nil
+            end
+         end
+
+         def self.parse_update_response(response, method)
+            response = check_response_code(response)
+            if method == :create
+               return response.first =~ /^# Ticket (\S+) created/ ? $1 : nil
+            elsif method == :update
+               return response.first =~ /^# Ticket (\S+) updated/ ? $1 : nil
             end
-            tickets
          end
 
          protected
@@ -24,35 +51,39 @@ module Fiddler
             message = response.first.strip
             if message =~ /^#/
                raise Fiddler::TicketNotFoundError, message
+            elsif message == "No matching results."
+               response = []
             end
             response
          end
 
          def self.ticket_from_response(response)
             result = {}
+            prev_key = nil
             response.each do |line|
-               matches = /^(.*?):\s(.*)/.match(line)
+               matches = /^(\S*?):\s(.*)/.match(line)
                if(matches)
                   key = matches[1].underscore
+                  prev_key = key
                   result[key] = matches[2]
+               else
+                  whitespace_matches = /^\s{12}(.*)/.match(line)
+                  if whitespace_matches and prev_key
+                     values = result[prev_key]
+                     values = values.split(",") unless values.is_a?(Array)
+                     result[prev_key] = values.concat(whitespace_matches[1].split(",")).collect { |x| x.strip }
+                  end
                end
             end
-            Fiddler::Ticket.new(result)
-         end
-
-         def self.tokenize_response(response)
-            tokens = Array.new
-            current = Array.new
-            response.each do |item|
-               if(item == "--")
-                  tokens << current
-                  current = Array.new
-                  next
-               end
-               current << item
+            begin
+               id = result['id'].scan(/^ticket\/(\d*)$/).first.first.to_i
+            rescue
+               raise RequestError, "Unexpected response for id : #{result['id']}"
             end
-            tokens
+            ticket = Fiddler::Ticket.new(result)
+            ticket.id = id
+            return ticket
          end
       end
    end
-end
+end

data/lib/fiddler/ticket.rb

@@ -1,42 +1,147 @@
+require 'active_attr'
 module Fiddler
    class Ticket
+      include ActiveAttr::Model
 
-      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).inject({}){|memo, k| memo[k] = nil; memo}
-      RequiredAttributes = %w(queue subject)
+      attribute :id, :default => 'ticket/new'
+      attribute :queue
+      attribute :owner
+      attribute :creator
+      attribute :subject
+      attribute :status
+      attribute :priority
+      attribute :initial_priority
+      attribute :final_priority
+      attribute :requestors
+      attribute :cc
+      attribute :admin_cc
+      attribute :created
+      attribute :starts
+      attribute :started
+      attribute :due
+      attribute :resolved
+      attribute :told
+      attribute :last_updated
+      attribute :time_estimated
+      attribute :time_worked
+      attribute :time_left
+      attribute :text
 
-      attr_reader :histories, :saved
-      
-      # Initializes a new instance of ticket object
+      validates_presence_of :id, :queue, :subject
+
+      def histories
+         if @histories == nil
+            url = "ticket/#{id}/history"
+            response = Fiddler::ConnectionManager.get(url, {:format => "l"})
+            @histories = Fiddler::Parsers::HistoryParser.parse_multiple(response)
+         end
+         @histories
+      end
+
+      # make the setting and getting of requestors easier
+      def requestor_array
+         self.requestors.split(",").collect { |x| x.strip }
+      end
+
+      def requestor_array=(requestor_array)
+         if requestor_array.is_a?(Array)
+            self.requestors = requestor_array.join(", ")
+         end
+      end
+
+      # Add a comment to a ticket
+      # Example:
+      #   tix = Ticket.get(1000)
+      #   tix.comment("This is a comment", :time_worked => 45, :cc => 'someone@example.com')
+      #
+      #   Attachments
+      #   tix.comment("This is a comment", :attachments => "/tmp/filename.txt")
+      #
+      #   Attachment as a file descriptor
+      #   tix.correspond("This is a comment", :attachments => File.new("/tmp/filename.txt"))
       #
-      # @params [Hash] of the initial options
-      def initialize(attributes={})
-         if attributes
-            @attributes = DefaultAttributes.merge(attributes)
+      #   Attachment as a ActionDispatch::Http::UploadedFile instance
+      #   tix.comment("This is a comment", :attachments => [params[:attachment_1], params[:attachment_2]])
+      #
+      def comment(comment, opt = {})
+         reply('Comment', comment, opt)
+      end
+
+      def correspond(comment, opt = {})
+         reply('Correspond', comment, opt)
+      end
+
+      def steal
+         change_ownership "Steal"
+      end
+
+      def take
+         change_ownership "Take"
+      end
+
+      def untake
+         change_ownership "Untake"
+      end
+
+      def save
+         id == "ticket/new" ? create : update
+      end
+
+      protected
+
+      def reply(method, comment, opt)
+         # make sure the options are only the valid ones.
+         valid_options = [:cc, :bcc, :time_worked, :attachments, :status]
+         opt.delete_if { |key,value| !valid_options.include?(key) }
+
+         payload = { :text => comment, :action => method}.merge(opt)
+         payload.delete(:attachments)
+
+         attachments = Fiddler::AttachmentCollection.fill(opt[:attachments])
+         payload.merge!(:attachment => attachments.map(&:name).join(",")) unless attachments.empty?
+
+         response = Fiddler::ConnectionManager.post_content("ticket/#{id}/comment", { :content => payload.to_content_format }.merge(attachments.to_payload) )
+
+         result = Fiddler::Parsers::TicketParser.parse_reply_response(response)
+
+         # update the ticket parameters if the action was successful
+         if result and opt.has_key?(:status)
+            self.status = opt[:status]
+            result
          else
-            @attributes = DefaultAttributes
+            result
          end
-         @attributes.update(:id => 'ticket/new')
-         @saved = false
-         @histories = []  
-         @new_record = true
-         add_methods!
       end
 
-      def add_methods!
-         @attributes.each do |key, value|
-            (class << self; self; end).send :define_method, key do
-               return @attributes[key]
-            end
-            (class << self; self; end).send :define_method, "#{key}=" do |new_val|
-               @attributes[key] = new_val
-            end
+      def change_ownership(method)
+         payload = { "Action" => method }
+         response = Fiddler::ConnectionManager.post("ticket/#{id}/take", :content => payload.to_content_format)
+         new_owner = Fiddler::Parsers::TicketParser.parse_change_ownership_response(response)
+         if new_owner
+            self.owner = new_owner
+            return self
+         else
+            return nil
          end
       end
 
-      def description
-         @attributes.each do |key,value|
-            puts "#{key} = #{value}"
-         end
+      def create
+         return false unless valid?
+         response = Fiddler::ConnectionManager.post("ticket/new", :content => @attributes.to_content_format)
+         id = Fiddler::Parsers::TicketParser.parse_update_response(response, :create)
+         return false unless id
+         self.id = id.to_i
+         true
+      end
+
+      def update
+         return false unless valid?
+         payload = @attributes.clone
+         payload.delete("text")
+         payload.delete("id")
+         response = Fiddler::ConnectionManager.post("ticket/#{id}/edit", :content => payload.to_content_format)
+         id = Fiddler::Parsers::TicketParser.parse_update_response(response, :update)
+         return !id.nil?
       end
 
       # Class methods
@@ -49,6 +154,7 @@ module Fiddler
             url = "ticket/#{id}"
             response = Fiddler::ConnectionManager.get(url)
             ticket = Fiddler::Parsers::TicketParser.parse_single(response)
+            ticket
          end
 
          # Search the tickets with the given conditions
@@ -56,9 +162,14 @@ module Fiddler
          # @params [Hash] of conditions
          # @returns [Array<Ticket>] of the tickets matching the criteria
          def all(conditions={})
+            tickets = []
             url = "search/ticket"
-            response = Fiddler::ConnectionManager.get(url,Fiddler::Formatters::SearchRequestFormatter.format(conditions))
-            ticket = Fiddler::Parsers::TicketParser.parse_multiple(response)
+            request_hash = Fiddler::Formatters::SearchRequestFormatter.format(conditions)
+            unless request_hash.empty?
+               response = Fiddler::ConnectionManager.get(url,request_hash)
+               tickets = Fiddler::Parsers::TicketParser.parse_multiple(response)
+            end
+            tickets
          end
 
          # Creates a new ticket with the given options, it will not save the ticket
@@ -67,19 +178,6 @@ module Fiddler
          # @returns [Ticket] returns new ticket object
          def create(options)
          end
-
-         # Saves the changes to the ticket object
-         #
-         # @returns [boolean] save succcessful or not
-         def save
-         end
-
-         # Find the tickets with the given options
-         #
-         # @params [Hash] of options
-         # @returns [Array<Ticket>] of ticket matching the criteria
-         def find(options={})
-         end
       end
    end
-end
+end