glima 0.2.1

data/glima.gemspec

@@ -0,0 +1,39 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+git = File.expand_path('../.git', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'glima/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "glima"
+  spec.version       = Glima::VERSION
+  spec.authors       = ["Yoshinari Nomura"]
+  spec.email         = ["nom@quickhack.net"]
+  spec.summary       = %q{Gmail CLI client}
+  spec.description   = %q{Gmail CLI client}
+  spec.homepage      = "https://github.com/yoshinari-nomura/glima"
+  spec.license       = "MIT"
+
+  spec.files         = if Dir.exist?(git)
+                         `git ls-files -z`.split("\x0")
+                       else
+                         Dir['**/*']
+                       end
+
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = ">= 2.3.0"
+
+  spec.add_runtime_dependency "thor", ">= 0.19.1"
+  spec.add_runtime_dependency "google-api-client", ">0.9"
+  spec.add_runtime_dependency "googleauth"
+  spec.add_runtime_dependency "launchy"
+  spec.add_runtime_dependency "mail"
+  spec.add_runtime_dependency "rubyzip"
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end

data/lib/glima.rb

@@ -0,0 +1,18 @@
+module Glima
+  # Your code goes here...
+  class ConfigurationError < StandardError ; end
+
+  dir = File.dirname(__FILE__) + "/glima"
+
+  autoload :Cli,                  "#{dir}/cli.rb"
+  autoload :Command,              "#{dir}/command.rb"
+  autoload :Config,               "#{dir}/config.rb"
+  autoload :Context,              "#{dir}/context.rb"
+  autoload :DataStore,            "#{dir}/datastore.rb"
+  autoload :GmailClient,          "#{dir}/gmail_client.rb"
+  autoload :ImapWatch,            "#{dir}/imap.rb"
+  autoload :QueryParameter,       "#{dir}/query_parameter.rb"
+  autoload :Resource,             "#{dir}/resource.rb"
+  autoload :Zip,                  "#{dir}/zip.rb"
+  autoload :VERSION,              "#{dir}/version.rb"
+end

data/lib/glima/cli.rb

@@ -0,0 +1,151 @@
+require "thor"
+
+module Glima
+  class Cli < Thor
+    ################################################################
+    # config files
+
+    CONFIG_HOME = File.join((ENV["XDG_CONFIG_HOME"] || "~/.config"), basename)
+    CONFIG_FILE = "config.yml"
+    CONFIG_PATH = File.join(CONFIG_HOME, CONFIG_FILE)
+
+    def self.config_home ; CONFIG_HOME; end
+    def self.config_path ; CONFIG_PATH; end
+
+    ################################################################
+    # register preset options
+
+    def self.named_option(name, options)
+      @named_options ||= {}
+      @named_options[name] = options
+    end
+
+    def self.expand_option(*names)
+      expand_named_option(:method, *names)
+    end
+
+    def self.expand_class_option(*names)
+      expand_named_option(:class, *names)
+    end
+
+    def self.expand_named_option(type, *names)
+      names.each do |name|
+        options = @named_options[name]
+        if type == :class
+          class_option name, options
+        else
+          method_option name, options
+        end
+      end
+    end
+    private_class_method :expand_named_option
+
+    named_option :debug,   :desc => "Set debug flag", :type => :boolean
+    named_option :profile, :desc => "Set profiler flag", :type => :boolean
+    named_option :config,  :desc => "Set config path (default: #{CONFIG_PATH})", :banner => "FILE"
+    named_option :dry_run, :desc => "Perform a trial run with no changes made", :type => :boolean
+
+    ################################################################
+    # command name mappings
+
+    map ["--version", "-v"] => :version
+
+    map ["--help", "-h"] => :help
+
+    default_command :help
+
+    ################################################################
+    # Command: help
+    ################################################################
+
+    desc "help [COMMAND]", "Describe available commands or one specific command"
+
+    def help(command = nil)
+      super(command)
+    end
+
+    ################################################################
+    # Command: version
+    ################################################################
+    desc "version", "Show version"
+
+    def version
+      puts Glima::VERSION
+    end
+
+    ################################################################
+    # Command: completions
+    ################################################################
+    check_unknown_options! :except => :completions
+
+    desc "completions [COMMAND]", "List available commands or options for COMMAND", :hide => true
+
+    long_desc <<-LONGDESC
+      List available commands or options for COMMAND
+      This is supposed to be a zsh compsys helper"
+    LONGDESC
+
+    def completions(*command)
+      help = self.class.commands
+      global_options = self.class.class_options
+      Glima::Command::Completions.new(help, global_options, command, config)
+    end
+
+    ################################################################
+    # add some hooks to Thor
+
+    no_commands do
+      def invoke_command(command, *args)
+        setup_global_options unless command.name == "init"
+        result = super
+        teardown
+        result
+      end
+    end
+
+    ################################################################
+    # private
+
+    private
+
+    def exit_on_error(&block)
+      begin
+        yield if block_given?
+      rescue Glima::ConfigurationError => e
+        STDERR.print "ERROR: #{e.message}.\n"
+        exit 1
+      end
+    end
+
+    attr_reader :builder, :config, :client, :context, :datastore
+
+    def setup_global_options
+      exit_on_error do
+        if options[:profile]
+          require 'profiler'
+          Profiler__.start_profile
+        end
+        if options[:debug]
+          require "pp"
+          $GLIMA_DEBUG = true
+          $GLIMA_DEBUG_FOR_DEVELOPER = true if ENV["GLIMA_DEBUG_FOR_DEVELOPER"]
+        end
+      end
+    end
+
+    def load_plugins
+      config_path = options[:config] || CONFIG_PATH
+      plugin_dir  = File.dirname(config_path)
+
+      Dir.glob(File.expand_path("plugins/*.rb", plugin_dir)) do |rb|
+        require rb
+      end
+    end
+
+    def teardown
+      if options[:profile]
+        Profiler__.print_profile($stdout)
+      end
+    end
+  end
+end

data/lib/glima/command.rb

@@ -0,0 +1,35 @@
+module Glima
+  module Command
+
+    def self.logger
+      @logger
+    end
+
+    def self.client
+      @client
+    end
+
+    class << self
+      attr_writer :logger, :client
+    end
+
+    dir = File.dirname(__FILE__) + "/command"
+
+    autoload :Base,        "#{dir}/base.rb"
+    autoload :Dezip,       "#{dir}/dezip.rb"
+    # autoload :Events,      "#{dir}/events.rb"
+    autoload :Guess,       "#{dir}/guess.rb"
+    autoload :Label,       "#{dir}/label.rb"
+    autoload :Labels,      "#{dir}/labels.rb"
+    # autoload :Open,        "#{dir}/open.rb"
+    autoload :Profile,     "#{dir}/profile.rb"
+    autoload :Push,        "#{dir}/push.rb"
+    autoload :Relabel,     "#{dir}/relabel.rb"
+    autoload :Scan,        "#{dir}/scan.rb"
+    # autoload :Show,        "#{dir}/show.rb"
+    autoload :Trash,       "#{dir}/trash.rb"
+    autoload :Watch,       "#{dir}/watch.rb"
+    autoload :Xzip,        "#{dir}/xzip.rb"
+
+  end # module Command
+end # module Glima

data/lib/glima/command/base.rb

@@ -0,0 +1,23 @@
+module Glima
+  module Command
+    class Base
+
+      private
+
+      def logger
+        Glima::Command.logger
+      end
+
+      def client
+        Glima::Command.client
+      end
+
+      def exit_if_error(message, error, logger)
+        return true unless error
+        logger.error "#{error.message.split(':').last.strip} #{message}."
+        exit 1
+      end
+
+    end # class Scan
+  end # module Command
+end # module Glima

data/lib/glima/command/dezip.rb

@@ -0,0 +1,45 @@
+module Glima
+  module Command
+    class Dezip < Base
+
+      def initialize(gmail_id, directory, password_file = nil, password_dir = nil)
+
+        unless File.writable?(File.expand_path(directory))
+          logger.error "#{directory} is not writable."
+          exit 1
+        end
+
+        mail = client.get_user_smart_message(gmail_id) do |m, err|
+          exit_if_error(gmail_id, err, logger)
+        end
+
+        # get password candidates from config file
+        password_candidates = []
+        if File.exists?(password_file)
+          password_candidates += File.open(password_file) {|f| f.read.split(/\n+/) }
+        end
+
+        # gather password candidates from nearby mails
+        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)
+          logger.info "Password unlock failed."
+          return false
+        end
+
+        # Write to unlocked zip file to DIRECTORY
+        mail.attachments.each do |attachment|
+          next unless attachment.filename =~ /\.zip$/i
+          zip_filename = File.expand_path(attachment.filename, directory)
+          Glima::Zip.new(attachment.body.decoded).write_to_file(zip_filename)
+          logger.info "Wrote to #{zip_filename || 'STDOUT'}."
+        end
+      end
+
+    end # class Dezip
+  end # module Command
+end # module Glima

data/lib/glima/command/guess.rb

@@ -0,0 +1,30 @@
+module Glima
+  module Command
+    class Guess < Base
+
+      def initialize(message_id)
+
+        fmt = "minimal"
+        user_label_ids = []
+
+        msg = client.get_user_message('me', message_id, format: fmt)
+        thr = client.get_user_thread('me', msg.thread_id, format: fmt)
+
+        thr.messages.each do |tmsg|
+          # puts tmsg.snippet
+          tmsg.label_ids.each do |label_id|
+            next unless label_id =~ /^Label_\d+$/
+            user_label_ids << label_id unless user_label_ids.member?(label_id)
+            puts "#{tmsg.id} -> #{label_id}"
+          end
+        end
+
+        user_label_ids.each do |label_id|
+          label = client.get_user_label(label_id)
+          puts "#{label_id} -> #{label.name}"
+        end
+      end
+
+    end # class Guess
+  end # module Command
+end # module Glima

data/lib/glima/command/label.rb

@@ -0,0 +1,29 @@
+module Glima
+  module Command
+    class Label < Base
+
+      def initialize(message_id, add, del)
+
+        req = {}
+        req[:add_label_ids]    = add.map(&:id) unless add.empty?
+        req[:remove_label_ids] = del.map(&:id) unless add.empty?
+
+        if req.empty?
+          puts "Do nothing."
+          return 0
+        end
+
+        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 # class Label
+  end # module Command
+end # module Glima

data/lib/glima/command/labels.rb

@@ -0,0 +1,63 @@
+module Glima
+  module Command
+    class Labels < Base
+
+      def initialize(verbose = nil)
+
+        labels = client.labels
+
+        if labels.empty?
+          puts 'No labels found'
+          return 0
+        end
+
+        total = labels.length
+
+        unless verbose
+          labels.sort_by(&:name).each do |label|
+            puts "#{label.name}"
+          end
+          return 0
+        end
+
+        # Gmail API has rate limit at 250 requests/seccond/user (deps on type of method)
+        # https://developers.google.com/gmail/api/v1/reference/quota
+        # labels.get consumes 1quota unit
+        # It is only an experiment, not practical...
+        #
+        # how to retry batch requests? Issue #444 google/google-api-ruby-client
+        # https://github.com/google/google-api-ruby-client/issues/444
+        # Setting default option should also work, but it has to be done before the service is created.
+        #
+        # Retries on individual operations within a batch isn't yet
+        # supported. It's a bit complicated to do that correctly
+        # (e.g. extract the failed requests/responses, build a new batch,
+        # retry, repeat... merge all the results...)
+        #
+        # I'd caution against using retries with batches unless you know
+        # the operations are safe to repeat. Since the entire batch is
+        # repeated, you may be replaying successful operations as part of
+        # it.
+        #
+        index = 1
+        labels.each_slice(100) do |chunk|
+          client.batch do |batch_client|
+            chunk.each do |lbl|
+              batch_client.get_user_label(lbl.id) do |label, err|
+                if label
+                  puts "--- #{index}/#{total} -------------------------------------------------"
+                  puts Glima::Resource::Label.new(label).dump
+                  index += 1
+                else
+                  puts "Error: #{err}"
+                end
+              end
+            end # chunk
+          end # batch
+          sleep 1
+        end # slice
+      end
+
+    end # class Labels
+  end # module Command
+end # module Glima

data/lib/glima/command/profile.rb

@@ -0,0 +1,15 @@
+module Glima
+  module Command
+    class Profile < Base
+
+      def initialize
+        response = client.get_user_profile('me')
+        puts "emailAddress: #{response.email_address}"
+        puts "messagesTotal: #{response.messages_total}"
+        puts "threadsTotal: #{response.threads_total}"
+        puts "historyId: #{response.history_id}"
+      end
+
+    end # class Profile
+  end # module Command
+end # module Glima