pidgin2adium 3.0.1 → 3.1.0

data/lib/pidgin2adium.rb

@@ -3,8 +3,6 @@
 # A ruby program to convert Pidgin log files to Adium log files, then place
 # them in the Adium log directory.
 
-$:.unshift(File.dirname(__FILE__)) unless $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
-
 require 'fileutils'
 require 'pidgin2adium/log_parser'
 
@@ -14,120 +12,122 @@ module Pidgin2Adium
   ADIUM_LOG_DIR = File.expand_path('~/Library/Application Support/Adium 2.0/Users/Default/Logs/') << '/'
   # These files/directories show up in Dir.entries()
   BAD_DIRS = %w{. .. .DS_Store Thumbs.db .system}
-  VERSION = "3.0.1"
+  VERSION = "3.1.0"
   # For displaying after we finish converting
   @@oops_messages = []
   @@error_messages = []
 
-  def log_msg(str) #:nodoc:
-    puts str.to_s
-  end
+    def log_msg(str) #:nodoc:
+      puts str.to_s
+    end
 
-  def oops(str) #:nodoc:
-    @@oops_messages << str
-    warn("Oops: #{str}")
-  end
+    def oops(str) #:nodoc:
+      @@oops_messages << str
+      warn("Oops: #{str}")
+    end
 
-  def error(str) #:nodoc:
-    @@error_messages << str
-    warn("Error: #{str}")
-  end
+    def error(str) #:nodoc:
+      @@error_messages << str
+      warn("Error: #{str}")
+    end
 
-  #######################
-  #So that we can use log_msg when calling delete_search_indexes() by itself
-  module_function :log_msg, :oops, :error
-  #######################
+    #######################
+    #So that we can use log_msg when calling delete_search_indexes() by itself
+    module_function :log_msg, :oops, :error
+    #######################
 
-  # Parses the provided log.
-  # Returns a LogFile instance or false if an error occurred.
-  def parse(logfile_path, my_aliases)
-    logfile_path = File.expand_path(logfile_path)
-    ext = File.extname(logfile_path).sub('.', '').downcase
+    # Parses the provided log.
+    # Returns a LogFile instance or false if an error occurred.
+    def parse(logfile_path, my_aliases)
+      logfile_path = File.expand_path(logfile_path)
+      ext = File.extname(logfile_path).sub('.', '').downcase
+
+      if(ext == "html" || ext == "htm")
+        parser = HtmlLogParser.new(logfile_path, my_aliases)
+      elsif(ext == "txt")
+        parser = TextLogParser.new(logfile_path, my_aliases)
+      else
+        error("Doing nothing, logfile is not a text or html file. Path: #{logfile_path}.")
+        return false
+      end
 
-    if(ext == "html" || ext == "htm")
-      parser = HtmlLogParser.new(logfile_path, my_aliases)
-    elsif(ext == "txt")
-      parser = TextLogParser.new(logfile_path, my_aliases)
-    else
-      error("Doing nothing, logfile is not a text or html file. Path: #{logfile_path}.")
-      return false
+      return parser.parse()
     end
 
-    return parser.parse()
-  end
+    # Parses the provided log and writes out the log in Adium format.
+    # Returns:
+    #  * true if it successfully converted and wrote out the log,
+    #  * false if an error occurred, or
+    #  * Pidgin2Adium::FILE_EXISTS if file already exists AND
+    #    opts[:overwrite] = false.
+    #
+    # You can add options using the _opts_ hash, which can have the following
+    # keys, all of which are optional:
+    # * *overwrite*: If true, then overwrite even if log is found.
+    #	Defaults to false.
+    # * *output_dir*: The top-level dir to put the logs in.
+    #   Logs under output_dir are still each in their own folders, etc.
+    #   Defaults to Pidgin2Adium::ADIUM_LOG_DIR
+    def parse_and_generate(logfile_path, my_aliases, opts = {})
+      opts = {} unless opts.is_a?(Hash)
+      overwrite = !!opts[:overwrite]
+      if opts.key?(:output_dir)
+        output_dir = opts[:output_dir]
+      else
+        output_dir = ADIUM_LOG_DIR
+      end
 
-  # Parses the provided log and writes out the log in Adium format.
-  # Returns the path to the converted log, false if an error occurred, or
-  # Pidgin2Adium::FILE_EXISTS if file already exists AND opts[:overwrite] =
-  # false.
-  #
-  # You can add options using the _opts_ hash, which can have the following
-  # keys, all of which are optional:
-  # * *overwrite*: If true, then overwrite even if log is found.
-  #	Defaults to false.
-  # * *output_dir*: The top-level dir to put the logs in.
-  #   Logs under output_dir are still each in their own folders, etc.
-  #   Defaults to Pidgin2Adium::ADIUM_LOG_DIR
-  def parse_and_generate(logfile_path, my_aliases, opts = {})
-    opts = {} unless opts.is_a?(Hash)
-    overwrite = !!opts[:overwrite]
-    if opts.key?(:output_dir)
-      output_dir = opts[:output_dir]
-    else
-      output_dir = ADIUM_LOG_DIR
-    end
+      unless File.directory?(output_dir)
+        puts "Output log directory (#{output_dir}) does not exist or is not a directory."
+        begin
+          FileUtils.mkdir_p(output_dir)
+        rescue Errno::EACCES
+          puts "Permission denied, could not create output directory (#{output_dir})"
+          return false
+        end
+      end
 
-    unless File.directory?(output_dir)
-      puts "Output log directory (#{output_dir}) does not exist or is not a directory."
-      begin
-        FileUtils.mkdir_p(output_dir)
-      rescue Errno::EACCES
-        puts "Permission denied, could not create output directory (#{output_dir})"
+      logfile_obj = parse(logfile_path, my_aliases)
+      return false if logfile_obj == false
+      dest_file_path = logfile_obj.write_out(overwrite, output_dir)
+      if dest_file_path == false
+        error("Successfully parsed file, but failed to write it out. Path: #{logfile_path}.")
         return false
+      elsif dest_file_path == FILE_EXISTS
+        log_msg("File already exists.")
+        return FILE_EXISTS
+      else
+        log_msg("Output to: #{dest_file_path}")
+        return true
       end
     end
 
-    logfile_obj = parse(logfile_path, my_aliases)
-    return false if logfile_obj == false
-    dest_file_path = logfile_obj.write_out(overwrite, output_dir)
-    if dest_file_path == false
-      error("Successfully parsed file, but failed to write it out. Path: #{logfile_path}.")
-      return false
-    elsif dest_file_path == FILE_EXISTS
-      log_msg("File already exists.")
-      return FILE_EXISTS
-    else
-      log_msg("Output to: #{dest_file_path}")
-      return true
-    end
-  end
-
-  # Newly-converted logs are viewable in the Adium Chat Transcript
-  # Viewer, but are not indexed, so a search of the logs doesn't give
-  # results from the converted logs. To fix this, we delete the cached log
-  # indexes, which forces Adium to re-index.
-  #
-  # Note: This function is run by LogConverter after converting all of its
-  # files.  LogFile.write_out intentionally does _not_ run it in order to
-  # allow for batch-processing of files. Thus, you will probably want to run
-  # Pidgin2Adium.delete_search_indexes after running LogFile.write_out in
-  # your own scripts.
-  def delete_search_indexes()
-    log_msg "Deleting log search indexes in order to force re-indexing of imported logs..."
-    dirty_file = File.expand_path("~/Library/Caches/Adium/Default/DirtyLogs.plist")
-    log_index_file = File.expand_path("~/Library/Caches/Adium/Default/Logs.index")
-    [dirty_file, log_index_file].each do |f|
-      if File.exist?(f)
-        if File.writable?(f)
-          File.delete(f)
-        else
-          error("File exists but is not writable. Please delete it yourself: #{f}")
+    # Newly-converted logs are viewable in the Adium Chat Transcript
+    # Viewer, but are not indexed, so a search of the logs doesn't give
+    # results from the converted logs. To fix this, we delete the cached log
+    # indexes, which forces Adium to re-index.
+    #
+    # Note: This function is run by LogConverter after converting all of its
+    # files.  LogFile.write_out intentionally does _not_ run it in order to
+    # allow for batch-processing of files. Thus, you will probably want to run
+    # Pidgin2Adium.delete_search_indexes after running LogFile.write_out in
+    # your own scripts.
+    def delete_search_indexes()
+      log_msg "Deleting log search indexes in order to force re-indexing of imported logs..."
+      dirty_file = File.expand_path("~/Library/Caches/Adium/Default/DirtyLogs.plist")
+      log_index_file = File.expand_path("~/Library/Caches/Adium/Default/Logs.index")
+      [dirty_file, log_index_file].each do |f|
+        if File.exist?(f)
+          if File.writable?(f)
+            File.delete(f)
+          else
+            error("File exists but is not writable. Please delete it yourself: #{f}")
+          end
         end
       end
+      log_msg "...done."
+      log_msg "When you next start the Adium Chat Transcript Viewer, it will re-index the logs, which may take a while."
     end
-    log_msg "...done."
-    log_msg "When you next start the Adium Chat Transcript Viewer, it will re-index the logs, which may take a while."
-  end
 
-  module_function :parse, :parse_and_generate, :delete_search_indexes
+    module_function :parse, :parse_and_generate, :delete_search_indexes
 end

data/lib/pidgin2adium/balance_tags.rb

@@ -20,8 +20,8 @@ module Pidgin2Adium
     # 2: attributes
     tag_regex = /<(\/?\w*)\s*([^>]*)>/
 
-      # WP bug fix for comments - in case you REALLY meant to type '< !--'
-      text.gsub!('< !--', '<    !--')
+    # WP bug fix for comments - in case you REALLY meant to type '< !--'
+    text.gsub!('< !--', '<    !--')
 
     # WP bug fix for LOVE <3 (and other situations with '<' before a number)
     text.gsub!(/<([0-9]{1})/, '&lt;\1')

data/lib/pidgin2adium/basic_parser.rb

@@ -0,0 +1,412 @@
+# Contains the BasicParser class.
+# For its subclasses, see html_log_parser.rb and text_log_parser.rb.
+# The subclasses parse the file passed into it and return a LogFile object.
+# The BasicParser class just provides some common functionality.
+#
+# Please use Pidgin2Adium.parse or Pidgin2Adium.parse_and_generate instead of
+# using these classes directly.
+
+require 'date'
+require 'time'
+
+require 'pidgin2adium/log_file'
+require 'pidgin2adium/message'
+
+module Pidgin2Adium
+  # Empty class. Raise'd by LogParser if the first line of a log is not
+  # parseable.
+  class InvalidFirstLineError < StandardError; end
+
+  # BasicParser is a base class. Its subclasses are TextLogParser and
+  # HtmlLogParser.
+  #
+  # Please use Pidgin2Adium.parse or Pidgin2Adium.parse_and_generate instead of
+  # using this class directly.
+  class BasicParser
+    include Pidgin2Adium
+    def initialize(src_path, user_aliases)
+      @src_path = src_path
+      # Whitespace is removed for easy matching later on.
+      @user_aliases = user_aliases.split(',').map!{|x| x.downcase.gsub(/\s+/,'') }.uniq
+      # @user_alias is set each time get_sender_by_alias is called. It is a non-normalized
+      # alias.
+      # Set an initial value just in case the first message doesn't give
+      # us an alias.
+      @user_alias = user_aliases.split(',')[0]
+
+      @tz_offset = get_time_zone_offset()
+
+      @log_file_is_valid = true
+      begin
+        file = File.new(@src_path, 'r')
+        @first_line = file.readline
+        @file_content = file.read
+        file.close
+      rescue Errno::ENOENT
+        oops("#{@src_path} doesn't exist! Continuing...")
+        @log_file_is_valid = false
+        return nil
+      end
+
+      # Time regexes must be set before pre_parse().
+      # "4/18/2007 11:02:00 AM" => %w{4, 18, 2007, 11, 02, 00, AM}
+      # ONLY used (if at all) in first line of chat ("Conversation with...at...")
+      @time_regex_first_line = %r{^(\d{1,2})/(\d{1,2})/(\d{4}) (\d{1,2}):(\d{2}):(\d{2}) ([AP]M)$}
+      # "2007-04-17 12:33:13" => %w{2007, 04, 17, 12, 33, 13}
+      @time_regex = /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/
+
+      begin
+        @service,
+          @user_SN,
+          @partner_SN,
+          # @basic_time_info is for files that only have the full
+          # timestamp at the top; we can use it to fill in the minimal
+          # per-line timestamps. It is a hash with 3 keys:
+          # * :year
+          # * :mon
+          # * :mday (day of month)
+          # You should be able to fill everything else in. If you can't,
+          # something's wrong.
+          @basic_time_info,
+          # When the chat started, in Adium's format
+          @adium_chat_time_start = pre_parse()
+      rescue InvalidFirstLineError
+        # The first line isn't parseable
+        @log_file_is_valid = false
+        error("Failed to parse, invalid first line: #{@src_path}")
+        return # stop processing
+      end
+
+      # @status_map, @lib_purple_events, and @events are used in
+      # create_status_or_event_msg
+      @status_map = {
+        /(.+) logged in\.$/ => 'online',
+        /(.+) logged out\.$/ => 'offline',
+        /(.+) has signed on\.$/ => 'online',
+        /(.+) has signed off\.$/ => 'offline',
+        /(.+) has gone away\.$/ => 'away',
+        /(.+) is no longer away\.$/ => 'available',
+        /(.+) has become idle\.$/ => 'idle',
+        /(.+) is no longer idle\.$/ => 'available'
+      }
+
+      # lib_purple_events are all of event_type libPurple
+      @lib_purple_events = [
+        # file transfer
+        /Starting transfer of .+ from (.+)/,
+        /^Offering to send .+ to (.+)$/,
+        /(.+) is offering to send file/,
+        /^Transfer of file .+ complete$/,
+        /Error reading|writing|accessing .+: .+/,
+        /You cancell?ed the transfer of/,
+        /File transfer cancelled/,
+        /(.+?) cancell?ed the transfer of/,
+        /(.+?) cancelled the file transfer/,
+        # Direct IM - actual (dis)connect events are their own types
+        /^Attempting to connect to (.+) at .+ for Direct IM\./,
+        /^Asking (.+) to connect to us at .+ for Direct IM\./,
+        /^Attempting to connect via proxy server\.$/,
+        /^Direct IM with (.+) failed/,
+        # encryption
+        /Received message encrypted with wrong key/,
+        /^Requesting key\.\.\.$/,
+        /^Outgoing message lost\.$/,
+        /^Conflicting Key Received!$/,
+        /^Error in decryption- asking for resend\.\.\.$/,
+        /^Making new key pair\.\.\.$/,
+        # sending errors
+        /^Last outgoing message not received properly- resetting$/,
+        /Resending\.\.\./,
+        # connection errors
+        /Lost connection with the remote user:.+/,
+        # chats
+        /^.+ entered the room\.$/,
+        /^.+ left the room\.$/
+      ]
+
+      # non-libpurple events
+      # Each key maps to an event_type string. The keys will be matched against a line of chat
+      # and the partner's alias will be in regex group 1, IF the alias is matched.
+      @event_map = {
+        # .+ is not an alias, it's a proxy server so no grouping
+        /^Attempting to connect to .+\.$/ => 'direct-im-connect',
+        # NB: pidgin doesn't track when Direct IM is disconnected, AFAIK
+        /^Direct IM established$/ => 'directIMConnected',
+        /Unable to send message/ => 'chat-error',
+        /You missed .+ messages from (.+) because they were too large/ => 'chat-error',
+        /User information not available/ => 'chat-error'
+      }
+
+      @ignore_events = [
+        # Adium ignores SN/alias changes.
+        /^.+? is now known as .+?\.<br\/?>$/
+      ]
+    end
+
+    # This method returns a LogFile instance, or false if an error occurred.
+    def parse
+      # Prevent parse from being called directly from BasicParser, since
+      # it uses subclassing magic.
+      if self.class == BasicParser
+        oops("Please don't call parse directly from BasicParser. Use a subclass :)")
+        return false
+      end
+      return false unless @log_file_is_valid
+      @file_content = cleanup(@file_content).split("\n")
+
+      @file_content.map! do |line|
+        # "next" returns nil which is removed by compact
+        next if line =~ /^\s+$/
+        if line =~ @line_regex
+          create_msg($~.captures)
+        elsif line =~ @line_regex_status
+          msg = create_status_or_event_msg($~.captures)
+          # Error occurred while parsing
+          return false if msg == false
+        else
+          error "Could not parse line:"
+          p line
+          return false
+        end
+      end
+      @file_content.compact!
+      return LogFile.new(@file_content, @service, @user_SN, @partner_SN, @adium_chat_time_start)
+    end
+
+    def get_time_zone_offset()
+      # We must have a tz_offset or else the Adium Chat Log viewer
+      # doesn't read the date correctly and then:
+      # 1) the log has an empty start date column in the viewer
+      # 2) The timestamps are all the same for the whole log
+      tz_match = /([-\+]\d+)[A-Z]{3}\.(?:txt|htm|html)/.match(@src_path)
+      if tz_match and tz_match[1]
+        tz_offset = tz_match[1]
+      else
+        # "-0500" (3d rather than 2d to allow for "+")
+        tz_offset = sprintf('%+03d00', Time.zone_offset(Time.now.zone) / 3600)
+      end
+      return tz_offset
+    end
+
+    def try_to_parse_first_line_time(first_line_time)
+      formats = [
+        "%m/%d/%Y %I:%M:%S %P", # 01/22/2008 03:01:45 PM
+        "%Y-%m-%d %H:%M:%S"     # 2008-01-22 23:08:24
+      ]
+      parsed = nil
+      formats.each do |format|
+        begin
+          parsed = Time.strptime(first_line_time, format)
+          break
+        rescue ArgumentError
+        end
+      end
+      parsed
+    end
+
+    def try_to_parse_time(time)
+      formats = [
+        "%Y/%m/%d %H:%M:%S", # 2008/01/22 04:01:45
+        "%Y-%m-%d %H:%M:%S"  # 2008-01-22 04:01:45
+      ]
+      parsed = nil
+      formats.each do |format|
+        begin
+          parsed = Time.strptime(time, format)
+          break
+        rescue ArgumentError
+        end
+      end
+      parsed
+    end
+
+    def try_to_parse_minimal_time(minimal_time)
+      # 04:01:45 AM
+      minimal_format_with_ampm = "%I:%M:%S %P"
+      # 23:01:45
+      minimal_format_without_ampm = "%H:%M:%S"
+
+      time_hash = nil
+
+      # Use Date._strptime to allow filling in the blanks on minimal
+      # timestamps
+      if minimal_time =~ /[AP]M$/
+        time_hash = Date._strptime(minimal_time, minimal_format_with_ampm)
+      else
+        time_hash = Date._strptime(minimal_time, minimal_format_without_ampm)
+      end
+      if time_hash.nil?
+        # Date._strptime returns nil on failure
+        return nil
+      end
+      # Fill in the blanks
+      time_hash[:year] = @basic_time_info[:year]
+      time_hash[:mon] = @basic_time_info[:mon]
+      time_hash[:mday] = @basic_time_info[:mday]
+      new_time = Time.local(time_hash[:year],
+                            time_hash[:mon],
+                            time_hash[:mday],
+                            time_hash[:hour],
+                            time_hash[:min],
+                            time_hash[:sec])
+      new_time
+    end
+
+
+    #--
+    # Adium time format: YYYY-MM-DD\THH:MM:SS[+-]TZ_HRS like:
+    # 2008-10-05T22:26:20-0800
+    # HOWEVER:
+    # If it's the first line, then return it like this (note periods):
+    # 2008-10-05T22.26.20-0800
+    # because it will be used in the filename.
+    #++
+    # Converts a pidgin datestamp to an Adium one.
+    # Returns a string representation of _time_ or
+    # nil if it couldn't parse the provided _time_.
+    def create_adium_time(time, is_first_line = false)
+      return nil if time.nil?
+      if is_first_line
+        new_time = try_to_parse_first_line_time(time)
+      else
+        new_time = try_to_parse_time(time)
+        if new_time.nil?
+          new_time = try_to_parse_minimal_time(time)
+        end
+      end
+
+      return nil if new_time.nil?
+
+      if is_first_line
+        adium_time = new_time.strftime("%Y-%m-%dT%H.%M.%S#{@tz_offset}")
+      else
+        adium_time = new_time.strftime("%Y-%m-%dT%H:%M:%S#{@tz_offset}")
+      end
+      adium_time
+    end
+
+    # Extract required data from the file. Run by parse.
+    def pre_parse
+      # Deal with first line.
+
+      # the first line is special. It tells us (in order of regex groups):
+      # 1) who we're talking to
+      # 2) what time/date
+      # 3) what SN we used
+      # 4) what protocol (AIM, icq, jabber...)
+      first_line_match = /Conversation with (.+?) at (.+?) on (.+?) \((.+?)\)/.match(@first_line)
+      if first_line_match.nil?
+        raise InvalidFirstLineError
+      else
+        service = first_line_match[4]
+        # @user_SN is normalized to avoid "AIM.name" and "AIM.na me" folders
+        user_SN = first_line_match[3].downcase.tr(' ', '')
+        partner_SN = first_line_match[1]
+        pidgin_chat_time_start = first_line_match[2]
+        basic_time_info = case pidgin_chat_time_start
+                          when @time_regex
+                            {:year => $1.to_i,
+                             :mon => $2.to_i,
+                             :mday => $3.to_i}
+                          when @time_regex_first_line
+                            {:year => $3.to_i,
+                             :mon => $1.to_i,
+                             :mday => $2.to_i}
+                          end
+        adium_chat_time_start = create_adium_time(pidgin_chat_time_start, true)
+        return [service,
+          user_SN,
+          partner_SN,
+          basic_time_info,
+          adium_chat_time_start]
+      end
+    end
+
+    def get_sender_by_alias(alias_name)
+      no_action = alias_name.sub(/^\*{3}/, '')
+      if @user_aliases.include? no_action.downcase.gsub(/\s+/, '')
+        # Set the current alias being used of the ones in @user_aliases
+        @user_alias = no_action
+        return @user_SN
+      else
+        return @partner_SN
+      end
+    end
+
+    #--
+    # create_msg takes an array of captures from matching against
+    # @line_regex and returns a Message object or one of its subclasses.
+    # It can be used for TextLogParser and HtmlLogParser because both of
+    # they return data in the same indexes in the matches array.
+    #++
+    def create_msg(matches)
+      msg = nil
+      # Either a regular message line or an auto-reply/away message.
+      time = create_adium_time(matches[0])
+      return nil if time.nil?
+      buddy_alias = matches[1]
+      sender = get_sender_by_alias(buddy_alias)
+      body = matches[3]
+      if matches[2] # auto-reply
+        msg = AutoReplyMessage.new(sender, time, buddy_alias, body)
+      else
+        # normal message
+        msg = XMLMessage.new(sender, time, buddy_alias, body)
+      end
+      return msg
+    end
+
+    #--
+    # create_status_or_event_msg takes an array of +MatchData+ captures from
+    # matching against @line_regex_status and returns an Event or Status.
+    # Returns nil if it's a message that should be ignored, or false if an
+    # error occurred.
+    #++
+    def create_status_or_event_msg(matches)
+      # ["22:58:00", "BuddyName logged in."]
+      # 0: time
+      # 1: status message or event
+      msg = nil
+      time = create_adium_time(matches[0])
+      return nil if time.nil?
+      str = matches[1]
+      # Return nil, which will get compact'ed out
+      return nil if @ignore_events.detect{|regex| str =~ regex }
+
+      regex, status = @status_map.detect{|regex, status| str =~ regex}
+      if regex and status
+        # Status message
+        buddy_alias = regex.match(str)[1]
+        sender = get_sender_by_alias(buddy_alias)
+        msg = StatusMessage.new(sender, time, buddy_alias, status)
+      else
+        # Test for event
+        regex = @lib_purple_events.detect{|regex| str =~ regex }
+        event_type = 'libpurpleEvent' if regex
+        unless regex and event_type
+          # not a libpurple event, try others
+          regex, event_type = @event_map.detect{|regex,event_type| str =~ regex}
+          unless regex and event_type
+            error(sprintf("Error parsing status or event message, no status or event found: %p", str))
+            return false
+          end
+        end
+
+        if regex and event_type
+          regex_matches = regex.match(str)
+          # Event message
+          if regex_matches.size == 1
+            # No alias - this means it's the user
+            buddy_alias = @user_alias
+            sender = @user_SN
+          else
+            buddy_alias = regex_matches[1]
+            sender = get_sender_by_alias(buddy_alias)
+          end
+          msg = Event.new(sender, time, buddy_alias, str, event_type)
+        end
+      end
+      return msg
+    end
+  end # END BasicParser class
+end