glima 0.2.1

data/lib/glima/query_parameter.rb

@@ -0,0 +1,30 @@
+module Glima
+  class QueryParameter
+    class FormatError < StandardError; end
+
+    def initialize(folder, query_string, context = nil)
+      @params = {}
+      @folder, @query_string = folder, query_string
+
+      if folder == "+all"
+        @params[:q] = ""
+      elsif /^\+(\S+)/ =~ folder
+        @params[:q] = "in:\"#{$1}\""
+      else
+        fail "Unknown folder: #{folder}."
+      end
+
+      if query_string == "next"
+        @params[:page_token] = context&.load_page_token
+        raise FormatError.new("No more page") if @params[:page_token].to_s == ""
+      else
+        @params[:q] += " #{query_string}"
+      end
+    end
+
+    def to_hash
+      @params
+    end
+
+  end # class QueryParameter
+end # module Glima

data/lib/glima/resource.rb

@@ -0,0 +1,31 @@
+class String
+  def indent_heredoc(indent = 0)
+    strip_heredoc.gsub(/^/, ' ' * indent)
+  end
+
+  def strip_heredoc
+    indent = scan(/^[ \t]*(?=\S)/).min.size rescue 0
+    gsub(/^[ \t]{#{indent}}/, '')
+  end
+end
+
+module Glima
+  module Resource
+    class ParseError < StandardError; end
+
+    class Base
+      def initialize(raw_resource)
+        @raw_resource = raw_resource
+      end
+    end
+
+    dir = File.dirname(__FILE__) + "/resource"
+
+    autoload :History,             "#{dir}/history.rb"
+    autoload :Label,               "#{dir}/label.rb"
+    autoload :Mail,                "#{dir}/mail.rb"
+    autoload :Message,             "#{dir}/message.rb"
+    autoload :Thread,              "#{dir}/thread.rb"
+    autoload :User,                "#{dir}/user.rb"
+  end # modlue Resource
+end # module Glima

data/lib/glima/resource/history.rb

@@ -0,0 +1,94 @@
+module Glima
+  module Resource
+    class History < Base
+      class Event
+        attr_reader :history_id, :message, :type, :label_ids
+
+        def initialize(history_id:, message:, type:, label_ids: nil)
+          @history_id, @message, @type, @label_ids = history_id, message, type, label_ids
+        end
+
+        def dump
+          str = "history: #{history_id}, messgae: #{message.id}, type: #{type}"
+          str += ", label_ids: #{label_ids.join(',')}" if label_ids
+          str
+        end
+      end
+
+      # Single history entry will be converted to multiple events
+      def to_events
+        events = []
+        h = @raw_resource
+        id = h.id
+
+        h.messages_added.each do |ent|
+          events << Event.new(history_id: id, message: ent.message, type: :added)
+        end if h.messages_added
+
+        h.messages_deleted.each do |ent|
+          events << Event.new(history_id: id, message: ent.message, type: :deleted)
+        end if h.messages_deleted
+
+        h.labels_added.each do |ent|
+          events << Event.new(history_id: id, message: ent.message, type: :labels_added, label_ids: ent.label_ids)
+        end if h.labels_added
+
+        h.labels_removed.each do |ent|
+          events << Event.new(history_id: id, message: ent.message, type: :labels_removed, label_ids: ent.label_ids)
+        end if h.labels_removed
+
+        return events
+      end
+
+      def dump
+        h = @raw_resource
+
+        str = ""
+        types = []
+
+        msgs = h.messages
+        str += "** Messages: (#{msgs.length})\n"
+        msgs.each do |m|
+          str += Message.new(m).dump
+        end
+
+        if msgs = h.messages_added
+          types << :messages_added
+          str += "** Messages Added (#{msgs.length}):\n"
+          msgs.map(&:message).each do |m|
+            str += Message.new(m).dump
+          end
+        end
+
+        if msgs = h.messages_deleted
+          types << :messages_deleted
+          str += "** Messages Deleted (#{msgs.length}):\n"
+          msgs.map(&:message).each do |m|
+            str += Message.new(m).dump
+          end
+        end
+
+        if msgs = h.labels_added
+          types << :labels_added
+          str += "** Labels Added (#{msgs.length}):\n"
+          h.labels_added.each do |lm|
+            str += Message.new(lm.message).dump
+            str += "   label_ids: " + lm.label_ids.join(',')
+          end
+        end
+
+        if msgs = h.labels_removed
+          types << :labels_removed
+          str += "** Labels Removed (#{msgs.length}):\n"
+          h.labels_removed.each do |lm|
+            str += Message.new(lm.message).dump
+            str += "   label_ids: " + lm.label_ids.join(',')
+          end
+        end
+
+        return "* Id: #{h.id}, types: " + types.join(",") + "\n" + str
+      end
+
+    end # class History
+  end # module Resource
+end # modlue Glima

data/lib/glima/resource/label.rb

@@ -0,0 +1,22 @@
+module Glima
+  module Resource
+    class Label < Base
+
+      def dump
+        label = @raw_resource
+        str =
+          "id: #{label.id}\n" +
+          "name: #{label.name}\n" +
+          "messageListVisibility: #{label.message_list_visibility}\n" +
+          "labelListVisibility: #{label.label_list_visibility}\n" +
+          "type: #{label.type}\n" +
+          "messagesTotal: #{label.messages_total}\n" +
+          "messagesUnread: #{label.messages_unread}\n" +
+          "threadsTotal: #{label.threads_total}\n" +
+          "threadsUnread: #{label.threads_unread}\n"
+        return str
+      end
+
+    end # class Label
+  end # module Resource
+end # modlue Glima

data/lib/glima/resource/mail.rb

@@ -0,0 +1,155 @@
+require "mail"
+require 'forwardable'
+
+module Glima
+  module Resource
+    class Mail < ::Mail::Message
+      extend Forwardable
+
+      def_delegators :@gmail_message,
+      # Users.histoy
+      :internal_date,
+      :snippet
+
+      def self.read(mail_filename)
+        new(File.open(mail_filename, 'rb') {|f| f.read })
+      end
+
+      def initialize(message)
+        if message.respond_to?(:raw)
+          @gmail_message = message
+          super(message.raw)
+        else
+          super(message)
+        end
+      end
+
+      def gm_msgid
+        @gmail_message&.id
+      end
+      alias_method :id, :gm_msgid
+
+      def gm_thrid
+        @gmail_message&.thread_id
+      end
+      alias_method :thread_id, :gm_thrid
+
+      def gm_label_ids
+        @gmail_message&.label_ids
+      end
+      alias_method :label_ids, :gm_label_ids
+
+      def raw
+        @gmail_message&.raw
+      end
+
+      def to_plain_text
+        mail_to_plain_text(self)
+      end
+
+      def find_passwordish_strings
+        mail = self
+        body = mail.to_plain_text
+
+        password_candidates = []
+
+        # gather passwordish ASCII strings.
+        body.scan(/(?:^|[^!-~])([!-~]{4,16})[^!-~]/) do |str|
+          password_candidates += str
+        end
+        return password_candidates
+      end
+
+      def unlock_zip!(password_candidates = [""], logger = nil)
+        # Unlock all zip attachments in mail
+        transformed = false
+
+        self.attachments.each do |attachment|
+          next unless attachment.filename =~ /\.zip$/i
+
+          zip = Glima::Zip.new(attachment.body.decoded)
+          # try all passwords
+          if zip.unlock_password!(password_candidates, logger)
+            attachment.body = zip.to_decrypted_unicode_zip.to_base64
+            attachment.content_transfer_encoding = "base64"
+            transformed = true
+          end
+        end
+        return transformed
+      end
+
+      def format_summary(count = nil)
+        date = Time.at(internal_date.to_i/1000).strftime("%m/%d %H:%M")
+        count = if count then ("%4d " % count) else "" end
+        return "#{count}#{date} #{id} #{CGI.unescapeHTML(snippet)[0..30]}"
+      end
+
+      def format_mew(count = nil)
+        date = Time.at(internal_date.to_i/1000).strftime("%m/%d ")
+
+        mark1 = " "
+        mark1 = "U" if label_ids.include?("UNREAD")
+
+        mark2 = " "
+        mark2 = "-" if content_type =~ /multipart\/alternative/
+        mark2 = "M" unless attachments.empty?
+
+        folder = File.expand_path("~/Mail/all") # XXX
+
+        summary = "#{mark1}#{mark2}#{date} #{CGI.unescapeHTML(snippet)}"
+        summary += "\r +#{folder} #{id} <#{id}>"
+        summary += if id != thread_id then " <#{thread_id}>" else " " end
+
+        return summary + " 1 2"
+      end
+
+      private
+
+      def mail_to_plain_text(mail)
+        parts = if mail.multipart? then mail.parts else [mail] end
+
+        body = parts.map do |part|
+          part_to_plain_text(part)
+        end.join("----PART----PART----PART----PART----PART----\n")
+
+        return pretty_hearder + "\n" + body
+      end
+
+      def part_to_plain_text(part)
+        case part.content_type
+        when /text\/plain/
+          convert_to_utf8(part.body.decoded.to_s,
+                          part.content_type_parameters["charset"])
+        when /multipart\/alternative/
+          part_to_plain_text(part.text_part)
+
+        when /message\/rfc822/
+          mail_to_plain_text(::Mail.new(part.body.decoded.to_s))
+
+        else
+          "NOT_TEXT_PART (#{part.content_type})\n"
+        end
+      end
+
+      def convert_to_utf8(string, from_charset = nil)
+        if from_charset && from_charset != "utf-8"
+          string.encode("utf-8", from_charset,
+                        :invalid => :replace, :undef => :replace)
+        else
+          string.force_encoding("utf-8")
+        end
+      end
+
+      def pretty_hearder
+        mail = self
+        ["Subject: #{mail.subject}",
+         "From: #{mail.header['from']&.decoded}",
+         "Date: #{mail.header['date']}",
+         "Message-Id: #{mail.header['message_id']}",
+         "To: #{mail.header['to']&.decoded}",
+         "Cc: #{mail.header['cc']&.decoded}"
+        ].join("\n") + "\n"
+      end
+    end # class Mail
+  end # module Resource
+end # module Glima

data/lib/glima/resource/message.rb

@@ -0,0 +1,74 @@
+module Glima
+  module Resource
+    class Message < Base
+
+      def dump
+        dump_message(@raw_resource)
+      end
+
+      private
+      def dump_message(msg, indent = 0)
+        str1 = <<-EOF.indent_heredoc(indent)
+          id: #{msg.id}
+          threadId: #{msg.thread_id}
+          labelIds: #{msg.label_ids&.join(', ')}
+          snippet: #{msg.snippet&.slice(0..20)}...
+          historyId: #{msg.history_id}
+          internalDate: #{msg.internal_date}
+          sizeEstimate: #{msg.size_estimate}
+          payload:
+        EOF
+        str1 += dump_message_part(msg.payload, indent + 2)
+
+        str2 = <<-EOF.indent_heredoc(indent)
+          raw:
+        EOF
+        str2 += (msg.raw.force_encoding("UTF-8")) if msg.raw
+        return str1 + str2
+      end
+
+      def dump_message_part(part, indent)
+        return (" " * indent) + "part is NULL\n" unless part
+
+        str1 = <<-EOF.indent_heredoc(indent)
+          partId: #{part.part_id}
+          mimeType: #{part.mime_type}
+          filename: #{part.filename}
+          headers: #{dump_message_headers(part.headers)}
+          body:
+        EOF
+        str1 += dump_message_attachment(part.body, indent + 2) if part.body
+
+        str2 = <<-EOF.indent_heredoc(indent)
+          parts:
+        EOF
+        str2 += dump_message_parts(part.parts, indent + 2)
+
+        return str1 + str2
+      end
+
+      def dump_message_headers(headers, all = nil)
+        return "headers is empty" unless headers
+        str = headers.map{|h| h.name + ": " + h.value}.join("\n")
+        return str if all
+        return str.split("\n").first
+      end
+
+      def dump_message_parts(parts, indent = 0)
+        return (' ' * indent) + "parts is empty\n" unless parts
+        return parts.map{|p| dump_message_part(p, indent)}.join("\n") + "\n"
+      end
+
+      def dump_message_body(body, indent)
+        str = <<-EOF.indent_heredoc(indent)
+          attachmentId: #{(body.attachment_id.to_s)[0..20]}
+          size: #{body&.size}
+          data: #{if body.data then body.data.force_encoding("UTF-8")&.gsub(/\r?\n/, "")[0..20] else 'NULL' end}...
+        EOF
+        return str
+      end
+      alias_method :dump_message_attachment, :dump_message_body
+
+    end # class Message
+  end # module Resource
+end # module Glima

data/lib/glima/version.rb

@@ -0,0 +1,3 @@
+module Glima
+  VERSION = "0.2.1"
+end

data/lib/glima/zip.rb

@@ -0,0 +1,156 @@
+require "zip"
+require "base64"
+
+module Glima
+  class Zip
+    attr_accessor :password
+
+    def self.read(zip_filename, password = "")
+      new(File.open(File.expand_path(zip_file)).read, password)
+    end
+
+    def initialize(zip_string, password = "")
+      @zip_string = zip_string
+      @password = password
+    end
+
+    def correct_password?(password)
+      with_input_stream(password) do |zip|
+        begin
+          # Looking the first entry is not enough, because
+          # some zip files have directory entry which size is zero
+          # and no error is emitted even with wrong password.
+          while entry = zip.get_next_entry
+            size = zip.read.size # Exception if invalid password
+            return false if size != entry.size
+            return true  if size > 0 # short cut
+          end
+        rescue Zlib::DataError => e
+          puts "*** #{e} ***" if $DEBUG
+          return false
+        end
+
+        # False-positive if all files are emtpy.
+        return true
+      end
+    end
+
+    def unlock_password!(password_candidates, logger = nil)
+      list = sort_by_password_strength(password_candidates.uniq).unshift("")
+
+      list.each do |password|
+        msg = "Try password:'#{password}' (#{password_strength(password)})..."
+
+        if correct_password?(password)
+          logger.info(msg + " OK.") if logger
+          @password = password
+          return password # Found password
+        else
+          logger.info(msg + " NG.") if logger
+        end
+      end
+      return nil # No luck
+    end
+
+    def encrypted?
+      correct_password?("")
+    end
+
+    def write_to_file(file)
+      return file.write(@zip_string) if file.respond_to?(:write)
+
+      File.open(file, "w") do |f|
+        f.write(@zip_string)
+      end
+    end
+
+    def to_s
+      @zip_string
+    end
+
+    def to_base64
+      Base64.encode64(@zip_string)
+    end
+
+    def to_decrypted_unicode_zip()
+      ::Zip.unicode_names = true
+
+      out = ::Zip::OutputStream.write_buffer(StringIO.new) do |zos|
+        with_input_stream(@password) do |zis|
+          while entry = zis.get_next_entry
+            name = cp932_path_to_utf8_path(entry.name)
+
+            # Two types of Exception will occur on encrypted zip:
+            #  1) "invalid block type (Zlib::DataError)" if password is not specified.
+            #  2) "invalid stored block lengths (Zlib::DataError)" if password is wrong.
+            content = zis.read
+            raise Zlib::DataError if content.size != entry.size
+
+            zos.put_next_entry(name)
+            zos.write(content)
+          end
+        end
+      end
+      Zip.new(out.string)
+    end
+
+    private
+
+    def password_strength(password)
+      password = password.to_s
+      score = Math.log2(password.length + 1)
+
+      password.scan(/[a-z]+|[A-Z]+|\d+|[!"#$%&'()*+,-.\/:;<=>?@\[\\\]^_`{|}~]+/) do |s|
+        score += 1.0
+      end
+      return score
+    end
+
+    def sort_by_password_strength(password_array)
+      password_array.sort{|a,b|
+        password_strength(b) <=> password_strength(a)
+      }
+    end
+
+    def with_input_stream(password = "", &block)
+      ::Zip::InputStream.open(StringIO.new(@zip_string), 0, decrypter(password)) do |zis|
+        yield zis
+      end
+    end
+
+    def decrypter(password = "")
+      if password.empty?
+        nil # return empty decrypter
+      else
+        ::Zip::TraditionalDecrypter.new(password)
+      end
+    end
+
+    # 1) Convert CP932 (SJIS) to UTF8.
+    # 2) Replace path-separators from backslash (\) to slash (/).
+    #
+    # Example:
+    #   path = io.get_next_entry.name # rubyzip returns ASCII-8BIT string as name.
+    #   path is:
+    #    + ASCII-8BIT
+    #    + Every backslash is replaced to '/' even in second-byte of CP932.
+    #
+    # See also:
+    #   https://github.com/rubyzip/rubyzip/blob/master/lib/zip/entry.rb#L223
+    #   Zip::Entry#read_local_entry does gsub('\\', '/')
+    #
+    def cp932_path_to_utf8_path(cp932_path_string)
+      # Replace-back all '/' to '\'
+      name = cp932_path_string.force_encoding("BINARY").gsub('/', '\\')
+
+      # Change endoding to CP932 (SJIS) and replace all '\' to '/'
+      # In this replacement, '\' in second-byte of CP932 will be preserved.
+      name = name.force_encoding("CP932").gsub('\\', '/')
+
+      # Convert CP932 to UTF-8
+      return name.encode("utf-8", "CP932",
+                         :invalid => :replace, :undef => :replace)
+    end
+
+  end # class Zip
+end # module Glima