glima 0.2.1

data/lib/glima/command/push.rb

@@ -0,0 +1,26 @@
+module Glima
+  module Command
+    class Push < Base
+
+      def initialize(email_file, date, thread, labels)
+        label_ids = labels.map(&:id) + ["INBOX", "UNREAD"]
+
+        File.open(email_file) do |source|
+          client.insert_user_message(
+            'me',
+            Google::Apis::GmailV1::Message.new(label_ids: label_ids, thread_id: thread),
+            content_type: "message/rfc822",
+            internal_date_source: date,
+            upload_source: source) do |msg, err|
+            if msg
+              puts "pushed to: #{msg.id}"
+            else
+              STDERR.puts "Error: #{err}"
+            end
+          end
+        end
+      end
+
+    end # class Push
+  end # module Command
+end # module Glima

data/lib/glima/command/relabel.rb

@@ -0,0 +1,65 @@
+module Glima
+  module Command
+    class Relabel < Base
+
+      def initialize(source_name, dest_name, dry_run)
+
+        all_labels = client.list_user_labels('me').labels.sort_by(&:name)
+
+        if /\/$/ =~ dest_name
+          move_to_dir = true
+          dest_name = dest_name.sub(/\/$/, '')
+        else
+          move_to_dir = false
+        end
+
+        source_labels = all_labels.find_all {|x| File.fnmatch(source_name, x.name, File::FNM_PATHNAME)}
+        dest_label    = all_labels.find {|x| x.name == dest_name}
+
+        if source_labels.empty?
+          puts "Error: source #{source_name} not found"
+          return nil
+        end
+
+        if dest_label && !move_to_dir
+          puts "Error: dest #{dest_name} already exists"
+          return nil
+        end
+
+        if !dest_label && move_to_dir
+          puts "Error: dest #{dest_name} not found"
+          return nil
+        end
+
+        source_labels.each do |source_label|
+          dirtop = File.dirname(source_label.name)
+          sub_labels = all_labels.find_all {|x| File.fnmatch(source_label.name + '/*', x.name)}
+
+          ([source_label] + sub_labels).each do |label|
+            src = label.name
+            dst = dest_name + '/' + (label.name.sub(/^#{dirtop}\//, ''))
+
+            if all_labels.find {|x| x.name == dst}
+              puts "Error: relabel #{src} -> #{dst}: Destination already exists"
+              next
+            else
+              puts "relabel #{src} -> #{dst}"
+            end
+
+            unless dry_run
+              label_obj = Google::Apis::GmailV1::Label.new(id: label.id, name: dst)
+              client.patch_user_label('me', label.id, label_obj) do |response, err|
+                if response
+                  # puts dump_label(response)
+                else
+                  puts "Error: #{err}"
+                end
+              end
+            end
+          end
+        end
+      end
+
+    end # class Relabel
+  end # module Command
+end # module Glima

data/lib/glima/command/scan.rb

@@ -0,0 +1,32 @@
+module Glima
+  module Command
+    class Scan < Base
+
+      def initialize(folder, format, search_or_range)
+
+        index = 1
+        client.scan_batch(folder, search_or_range) do |mail|
+          case format
+          when :mew
+            puts mail.format_mew(index)
+          when :archive
+            puts format_archive_friendly(mail)
+          else
+            puts mail.format_summary(index)
+          end
+          index += 1
+        end
+      end
+
+      private
+
+      def format_archive_friendly(mail)
+        date = mail.date.strftime("%Y-%m-%d-%H%M%S")
+        # Replace unsafe chars for filename
+        subject = mail.subject.tr('!/:*?"<>|\\', '！／：＊？″＜＞｜＼').gsub(/[\s　]/, '')
+        return "#{mail.id} #{date}-#{mail.id}-#{subject}.eml"
+      end
+
+    end # class Scan
+  end # module Command
+end # module Glima

data/lib/glima/command/trash.rb

@@ -0,0 +1,22 @@
+module Glima
+  module Command
+    class Trash < Base
+
+      def initialize(message_ids)
+
+        client.batch do |batch_client|
+          message_ids.each do |id|
+            batch_client.trash_user_message(id) do |res, err|
+              if res
+                puts "Trash #{id} successfully."
+              else
+                puts "Error: #{err}"
+              end
+            end
+          end
+        end
+      end
+
+    end # class Trash
+  end # module Command
+end # module Glima

data/lib/glima/command/watch.rb

@@ -0,0 +1,45 @@
+module Glima
+  module Command
+    class Watch < Base
+
+      def initialize(queue_label = nil, mark_label = nil)
+
+        # Watch "[Gmail]/All Mail" by IMAP idle
+        client.watch(nil) do |ev|
+          next unless ev.type == :added
+
+          # Scan messages in queue_label or new message itself.
+          #
+          # If Xzip process is successful, remove queue_label
+          # from the source message.
+          #
+          if queue_label
+            target      = "label:#{queue_label.name}"
+            target     += " -label:#{mark_label.name}" if mark_label
+            del_labels  = [queue_label]
+          else
+            target      = ev.message.id
+            del_labels  = []
+          end
+
+          # Also, mark_label will be added to the xzipped message.
+          # It is for avoidance of infinite loop.
+          #
+          if mark_label
+            add_labels = [mark_label]
+          else
+            add_labels = []
+          end
+
+          logger.info "Xzip #{target}"
+
+          Glima::Command::Xzip.new(client, logger, target,
+                                   add_dst_labels: add_labels,
+                                   del_dst_labels: del_labels,
+                                   del_src_labels: del_labels)
+        end
+      end
+
+    end # class Watch
+  end # module Command
+end # module Glima

data/lib/glima/command/xzip.rb

@@ -0,0 +1,103 @@
+module Glima
+  module Command
+    class Xzip < Base
+      def initialize(target,
+                     add_src_labels: [],
+                     del_src_labels: [],
+                     add_dst_labels: [],
+                     del_dst_labels: [])
+
+        add_src_label_ids = add_src_labels.map(&:id)
+        del_src_label_ids = del_src_labels.map(&:id)
+        add_dst_label_ids = add_dst_labels.map(&:id)
+        del_dst_label_ids = del_dst_labels.map(&:id)
+
+        ids = if target =~ /^[\da-fA-F]{16}$/
+                [target]
+              else
+                client.find_messages(target)
+              end
+
+        ids.each do |message_id|
+          # get target mail
+          mail = client.get_user_smart_message(message_id) do |m, err|
+            if err
+              puts "Error: #{err}"
+              next
+            end
+          end
+
+          # find password candidates from nearby mails
+          password_candidates = []
+          client.nearby_mails(mail) do |nm|
+            logger.info "Passwordish mail: " + nm.format_summary
+            password_candidates += nm.find_passwordish_strings
+          end
+
+          # try to unlock zip attachments
+          unless mail.unlock_zip!(password_candidates, logger)
+            puts "Password unlock failed."
+            next
+          end
+
+          # push back unlocked mail to server
+          unless push_mail(mail, "dateHeader", add_dst_label_ids, del_dst_label_ids)
+            puts "Push mail failed."
+            next
+          end
+
+          # add/remove labels from the target
+          if add_src_label_ids.empty? && del_src_label_ids.empty?
+            next
+          end
+
+          req = {}
+          req[:add_label_ids]    = add_src_label_ids
+          req[:remove_label_ids] = del_src_label_ids
+
+          req = Google::Apis::GmailV1::ModifyMessageRequest.new(req)
+
+          client.modify_message('me', message_id, req) do |res,err|
+            if res
+              puts "Update #{message_id} successfully."
+            else
+              puts "Error: #{err}"
+            end
+          end
+        end
+      end # def initialize
+
+      private
+
+      def push_mail(mail, date_source = "receivedTime", add_label_ids = [], del_label_ids = [])
+        label_ids = (mail.label_ids +
+                     add_label_ids  -
+                     del_label_ids  +
+                     ["INBOX", "UNREAD"]).uniq
+        thid = mail.thread_id
+
+        unless date_source == "dateHeader" || date_source == "receivedTime"
+          raise "Unknown date type: #{date_source}"
+        end
+
+        mail.header["X-Glima-Processed"] = DateTime.now.rfc2822
+
+        client.insert_user_message(
+          'me',
+          Google::Apis::GmailV1::Message.new(label_ids: label_ids, thread_id: thid),
+          content_type: "message/rfc822",
+          internal_date_source: date_source,
+          upload_source: StringIO.new(mail.to_s)) do |msg, err|
+          if msg
+            puts "pushed to: #{msg.id}"
+            return true
+          else
+            STDERR.puts "Error: #{err}"
+            return false
+          end
+        end
+      end
+
+    end # class Xzip
+  end # module Command
+end # module Glima

data/lib/glima/config.rb

@@ -0,0 +1,205 @@
+require 'yaml'
+require 'pp'
+
+module Glima
+  class Config
+    # Syntax table manipulation
+    class Syntax
+      def initialize(syntax_config)
+        @syntax_config = syntax_config
+      end
+
+      def keyword_symbols
+        @syntax_config.keys
+      end
+
+      def keywords
+        keyword_symbols.map {|sym| sym.to_s.upcase }
+      end
+
+      def keyword?(word)
+        if word.is_a?(Symbol)
+          keyword_symbols.member?(word)
+        else
+          # String
+          keywords.member?(word)
+        end
+      end
+
+      def instance_variable_name(word)
+        return nil unless keyword?(word)
+        return '@' + as_symbol(word).to_s
+      end
+
+      def item_class(word)
+        return nil unless keyword?(word)
+        @syntax_config[as_symbol(word)]
+      end
+
+      private
+      def as_symbol(word)
+        word.to_s.downcase.sub(/^@+/, "").to_sym
+      end
+    end # class Syntax
+
+    # Parse Key-Value object in YAML
+    class Base
+      # attr_accessor :name
+
+      def self.create_from_yaml_file(yaml_file)
+        yaml_string = File.open(File.expand_path(yaml_file)).read
+        return create_from_yaml_string(yaml_string, yaml_file)
+      end
+
+      def self.create_from_yaml_string(yaml_string, filename = nil)
+        hash = YAML.load(yaml_string, filename) || {}
+        return new(hash)
+      end
+
+      def self.define_syntax(config)
+        @syntax = Syntax.new(config)
+        @syntax.keyword_symbols.each do |sym|
+          attr_accessor sym # XXX: attr_reader is enough?
+        end
+      end
+
+      def self.syntax
+        return @syntax
+      end
+
+      def initialize(hash = {})
+        @original_hash = hash
+        (hash || {}).each do |key, val|
+          raise Glima::ConfigurationError, "config syntax error (#{key})" unless syntax.keyword?(key)
+          var = syntax.instance_variable_name(key)
+          obj = create_subnode(key, val)
+          instance_variable_set(var, obj)
+        end
+      end
+
+      attr_reader :original_hash
+
+      def get_value(dot_separated_string = nil)
+        if dot_separated_string.to_s == ""
+          return original_hash
+        end
+
+        key, subkey = dot_separated_string.to_s.upcase.split(".", 2)
+        subnode = get_subnode(key)
+
+        if subnode.respond_to?(:get_value)
+          return subnode.get_value(subkey)
+        else
+          return subnode.to_s
+        end
+      end
+
+      def to_yaml
+        return self.to_hash.to_yaml
+      end
+
+      def to_hash
+        hash = {}
+        syntax.keywords.each do |key|
+          var = syntax.instance_variable_name(key)
+          obj = instance_variable_get(var)
+          obj = obj.respond_to?(:to_hash) ? obj.to_hash : obj.to_s
+          hash[key] = obj
+        end
+        return hash
+      end
+
+      private
+      def syntax
+        self.class.syntax
+      end
+
+      def get_subnode(key)
+        raise Glima::ConfigurationError, "Invalid key: #{key}" unless syntax.keyword?(key)
+        return instance_variable_get(syntax.instance_variable_name(key))
+      end
+
+      def create_subnode(keyword, value)
+        item_class = syntax.item_class(keyword)
+        if item_class.is_a?(Array)
+          return List.new(item_class.first, value)
+        elsif item_class == String
+          return value.to_s
+        else
+          return item_class.new(value)
+        end
+      end
+
+    end # class Base
+
+    # Parse Array object in YAML
+    class List < Base
+      include Enumerable
+
+      def initialize(item_class, array = [])
+        @original_hash = array
+        @configs = []
+        (array || []).each do |value|
+          item = item_class.new(value)
+          @configs << item
+        end
+      end
+
+      def [](key)
+        @configs.find {|c| c.name == key}
+      end
+
+      alias_method :get_subnode, :[]
+
+      def <<(conf)
+        @configs << conf
+      end
+
+      def to_hash # XXX: actually, it returns a Array
+        return @configs.map {|c| c.respond_to?(:to_hash) ? c.to_hash : c.to_s}
+      end
+
+      def each
+        @configs.each do |conf|
+          yield conf
+        end
+      end
+    end # List
+
+    ## concrete config classes
+
+    class General < Base
+      define_syntax :client_id => String,
+                    :client_secret => String,
+                    :token_store => String,
+                    :context_store => String,
+                    :zip_passwords_file => String,
+                    :default_user => String
+    end # class General
+
+    # Top-Level Config
+    class Top < Base
+      define_syntax :general => General
+    end # class Top
+
+    def self.create_from_file(file_name)
+      unless File.exists?(File.expand_path(file_name))
+        raise Glima::ConfigurationError, "config file '#{file_name}' not found"
+      end
+      begin
+        return Top.create_from_yaml_file(file_name)
+      rescue Psych::SyntaxError => e
+        raise Glima::ConfigurationError, e.message
+      end
+    end
+
+    def self.create_from_string(string)
+      begin
+        return Top.create_from_yaml_string(string)
+      rescue Psych::SyntaxError => e
+        raise Glima::ConfigurationError, e.message
+      end
+    end
+
+  end # class Config
+end # module Glima