olm 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 77901d067605eff56e7e15a667f55f05a4197121
+  data.tar.gz: 80565d0c2965b67bd6cbc088ff206f4cfa88e83e
+SHA512:
+  metadata.gz: 009f350ea5b13ab5b8efe2bc16f2a7f630563fbbf1428e17794aab0962edfce028b7cf1cf9027434119971d26fe0f8e3330c5b5150f0ab15b1eb28cafd93a038
+  data.tar.gz: 187eaa27cdc99f9cbe60ddd474e76b2ea0e5ab1698bff4d2a43d6354cabf027e66ba5d469855e8d2ff52226ce6896bf975e7291d7c2f65b7085a6de960009f22

data/.gitignore

@@ -0,0 +1,34 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Takahiro Noda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,4 @@
+olm
+===
+
+TBA

data/lib/olm/app.rb

@@ -0,0 +1,115 @@
+require 'win32ole'
+require 'singleton'
+require 'nkf'
+
+module Olm
+  class App
+    include Singleton
+
+    def initialize
+      @app = WIN32OLE.connect("Outlook.Application")
+      @ns = @app.Session
+      @enc = @ns.Folders.GetFirst.Name.encoding
+      const_load(self.class)
+    end
+
+    def ls(folder_id = nil)
+      f = folder_id ? @ns.GetFolderFromID(folder_id) : default_folder
+      res = "#{f.Items.Count}\n"
+      f.Items.each do |m|
+        entry_id = m.EntryID
+        received_at = m.ReceivedTime.to_s.split(' ').first
+        from = m.SenderName
+        subject = m.Subject
+        flag = m.IsMarkedAsTask ? '!' : ' '
+        res << sprintf("%s %s  %-12.12s  %-20.20s %s\n",
+          entry_id, flag, received_at, u(from), u(subject))
+      end
+      res
+    end
+
+    def send_and_receive
+      @ns.SendAndReceive(false)
+    end
+
+    def message(entry_id)
+      m = @ns.GetItemFromID(entry_id)
+      res = ''
+      res << sprintf("From: %s\n", m.SenderName)
+      res << sprintf("To: %s\n", m.To)
+      res << sprintf("Cc: %s\n", m.CC) if m.CC.to_s.length > 0
+      res << sprintf("Subject: %s\n", m.Subject)
+      res << sprintf("ReceivedAt: %s\n", m.ReceivedTime)
+      res << sprintf("---- \n")
+      if m.BodyFormat != OlFormatPlain
+        m2 = m.Copy
+        m2.BodyFormat = OlFormatPlain
+        res << m2.Body
+        m2.Move(@ns.GetDefaultFolder(OlFolderDeletedItems))
+      else
+        res << m.Body
+      end
+      NKF.nkf('-w -Lu', res)
+    end
+
+    def toggle_task_flag(entry_id)
+      m = @ns.GetItemFromID(entry_id)
+      if m.IsMarkedAsTask
+        m.ClearTaskFlag()
+      else
+        m.MarkAsTask(OlMarkNoDate)
+      end
+      m.Save
+    end
+
+    def mark_as_read(entry_id)
+      m = @ns.GetItemFromID(entry_id)
+      m.UnRead = false
+      m.Save
+    end
+
+    def create_message(io)
+      x = {:body => ''}
+      header = true
+      io.each_line do |line|
+        line.chomp!
+        if header
+          if line.empty? || /^---- / =~ line
+            header = false
+          else
+            next unless /^(.*?): (.*)/ =~ line
+            x[$1] = $2
+            p $1, $2
+          end
+        else
+          x[:body] << line
+          x[:body] << "\n"
+          p x[:body]
+        end
+      end
+      m = @app.CreateItem(OlMailItem)
+      m.BodyFormat = OlFormatPlain
+      m.To = x['To'] if x['To']
+      m.CC = x['Cc'] if x['Cc']
+      m.BCC = x['Bcc'] if x['Bcc']
+      m.Subject = NKF.nkf('-s', x['Subject']) if x['Subject']
+      m.Body = NKF.nkf('-s', x[:body]) if x[:body]
+      m
+    end
+
+
+    private
+
+    def const_load(klass)
+      WIN32OLE.const_load(@app, klass)
+    end
+
+    def default_folder
+      @ns.GetDefaultFolder(OlFolderInbox)
+    end
+
+    def u(str)
+      str.encode(Encoding::UTF_8)
+    end
+  end
+end

data/lib/olm.rb

@@ -0,0 +1,35 @@
+require 'olm/app'
+
+module Olm
+  VERSION = '0.0.1'
+
+  extend self
+
+  def ls(folder_id = nil)
+    puts Olm::App.instance.ls(folder_id)
+  end
+
+  def send_and_receive
+    Olm::App.instance.send_and_receive
+  end
+
+  def message(entry_id)
+    puts Olm::App.instance.message(entry_id)
+  end
+
+  def toggle_task_flag(entry_id)
+    Olm::App.instance.toggle_task_flag(entry_id)
+  end
+
+  def mark_as_read(entry_id)
+    Olm::App.instance.mark_as_read(entry_id)
+  end
+
+  def save_message
+    Olm::App.instance.create_message(ARGF).Save
+  end
+
+  def send_message
+    Olm::App.instance.create_message(ARGF).Send
+  end
+end

data/olm.el

@@ -0,0 +1,334 @@
+(require 'dash)
+
+(defvar olm-folder-id nil)
+(defvar olm-default-bcc nil)
+
+(defun olm
+  ()
+  (interactive)
+  (olm-scan))
+
+(defun olm-scan
+  ()
+  (interactive)
+  (let* ((ret (olm-ls))
+         (lbuf (olm-buf-ls))
+         (n (with-current-buffer lbuf
+              (goto-char (point-min))
+              (let ((point (point)))
+                (forward-word)
+                (string-to-int (buffer-substring point (point))))))
+         (sbuf (let ((buf (olm-buf-summary)))
+                 (with-current-buffer buf
+                   (setq-local buffer-read-only nil)
+                   (erase-buffer))
+                 buf))
+         (ibuf (let ((buf (olm-buf-entry-ids)))
+                 (with-current-buffer buf
+                   (erase-buffer))
+                 buf)))
+    (with-current-buffer lbuf
+      (--dotimes n
+        (progn
+          (forward-line)
+          (let* ((p0 (point))
+                 (p1 (progn
+                       (forward-word)
+                       (point)))
+                 (entry-id (buffer-substring p0 p1))
+                 (item-line (buffer-substring p1 (line-end-position))))
+            (with-current-buffer sbuf
+              (insert item-line "\n"))
+            (with-current-buffer ibuf
+              (insert entry-id "\n"))))))
+    (with-current-buffer sbuf
+      (olm-summary-mode))
+    (switch-to-buffer sbuf)))
+
+;;; A helper function invoked by olm-scan
+(defun olm-ls
+  ()
+  (with-current-buffer (olm-buf-ls)
+    (setq-local buffer-read-only nil)
+    (erase-buffer)
+    (let ((command (if olm-folder-id
+                       (concat "Olm.ls '" olm-folder-id "'")
+                     "Olm.ls")))
+      (olm-do-command command t))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;; gereral helper functions
+;;; 
+(defun olm-do-command
+  (command &optional buf)
+  (let ((buf (or buf (get-buffer-create "*Messages*"))))
+    (call-process "ruby" nil buf nil
+                "-r" "rubygems" "-r" "olm" "-e" command)))
+
+(defun olm-sync
+  ()
+  (interactive)
+  (with-current-buffer (get-buffer-create "*olm-sync*")
+    (message "Olm: synchronizing all objects ...")
+    (olm-do-command "Olm.send_and_receive" t)
+    (message "Olm: synchronizing all objects ...")
+    (sit-for 1)
+    (let ((w 3))
+      (--dotimes w
+          (progn
+            (message (number-to-string (- w it)))
+            (sit-for 1))))
+    (message "done.")))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;; buffers
+;;; 
+(defun olm-buf-ls
+  ()
+  (get-buffer-create "*olm-ls*"))
+
+(defun olm-buf-summary
+  ()
+  (get-buffer-create "*olm-summary*"))
+
+(defun olm-buf-entry-ids
+  ()
+  (get-buffer-create "*olm-entry-ids*"))
+
+(defun olm-buf-message
+  ()
+  (let ((buf (get-buffer-create "*olm-message*")))
+    (with-current-buffer buf
+      (setq-local buffer-read-only nil)
+      (erase-buffer))
+    buf))
+
+(defun olm-buf-draft
+  ()
+  (let ((buf (get-buffer-create "*olm-draft*")))
+    (with-current-buffer buf
+      (setq-local buffer-read-only nil)
+      (erase-buffer)
+      (insert "To: \n")
+      (insert "Cc: \n")
+      (when olm-default-bcc
+        (insert "Bcc: " olm-default-bcc "\n"))
+      (insert "Subject: \n")
+      (insert "---- \n"))
+    buf))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;; olm-message
+;;; 
+(defvar olm-message-mode-map nil)
+(defvar olm-message-mode-hook nil)
+
+(defun olm-message-mode
+  ()
+  (interactive)
+  (setq major-mode 'olm-summary-mode)
+  (setq mode-name "Olm Message")
+  (font-lock-mode 1)
+  (setq-local buffer-read-only t)
+  (setq-local line-move-ignore-invisible t)
+  (run-hooks 'olm-message-mode-hook))
+
+(defun olm-message-mode-keyword
+  ()
+  (font-lock-add-keywords
+   nil
+   '(("^From:" . font-lock-keyword-face)
+     ("^To:" . font-lock-keyword-face)
+     ("^Cc:" . font-lock-keyword-face)
+     ("^Subject:" . font-lock-keyword-face)
+     ("^ReceivedAt:" . font-lock-keyword-face)
+     ("^> .*$" . font-lock-comment-face)
+     ("^From: \\(.*\\)$" 1 font-lock-warning-face)
+     ("^To: \\(.*\\)$" 1 font-lock-negation-char-face)
+     ("^Cc: \\(.*\\)$" 1 font-lock-constant-face)
+     ("^Subject: \\(.*\\)$" 1 font-lock-variable-name-face)
+     ("^ReceivedAt: \\(.*\\)$" 1 font-lock-type-face))))
+
+(add-hook 'olm-message-mode-hook 'olm-message-mode-keyword)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;; olm-summary
+;;;
+(defvar olm-summary-mode-map nil)
+(defvar olm-summary-mode-hook nil)
+(defvar olm-summary-scroll-lines 12)
+
+(unless olm-summary-mode-map
+  (setq olm-summary-mode-map (make-sparse-keymap))
+  (define-key olm-summary-mode-map "s" 'olm-scan)
+  (define-key olm-summary-mode-map "i" 'olm-summary-inc)
+  (define-key olm-summary-mode-map "q" 'olm-summary-quit)
+  (define-key olm-summary-mode-map "." 'olm-summary-open-message)
+  (define-key olm-summary-mode-map " " 'olm-summary-scroll-message-forward)
+  (define-key olm-summary-mode-map [backspace] 'olm-summary-scroll-message-backward)
+  (define-key olm-summary-mode-map "p" 'olm-summary-display-up)
+  (define-key olm-summary-mode-map "n" 'olm-summary-display-down)
+  (define-key olm-summary-mode-map "!" 'olm-summary-toggle-flag)
+  (define-key olm-summary-mode-map "w" 'olm-summary-write))
+
+(defun olm-summary-inc
+  ()
+  (interactive)
+  (olm-sync)
+  (olm-scan))
+
+(defun olm-summary-quit
+  ()
+  (interactive)
+  (delete-other-windows-vertically)
+  (quit-window))
+
+(defun olm-summary-mode
+  ()
+  (interactive)
+  (use-local-map olm-summary-mode-map)
+  (setq major-mode 'olm-summary-mode)
+  (setq mode-name "Olm Summary")
+  (setq-local buffer-read-only t)
+  (setq-local truncate-lines t)
+  (setq-local line-move-ignore-invisible t)
+  (run-hooks 'olm-summary-mode-hook))
+
+(defun olm-summary-open-message
+  ()
+  (interactive)
+  (delete-other-windows-vertically)
+  (let* ((ln0 (line-number-at-pos))
+         (msg-window (split-window-below 10))
+         (mbuf (olm-buf-message))
+         (entry-id (progn
+                     (goto-line ln0)
+                     (olm-mail-item-entry-id-at))))
+    (with-current-buffer mbuf
+      (setq-local buffer-file-coding-system 'utf-8-dos))
+    (olm-do-command (concat "Olm.message '" entry-id "'") mbuf)
+    (with-current-buffer mbuf
+      (olm-message-mode)
+      (goto-char (point-min)))
+    (set-window-buffer msg-window mbuf)
+    (olm-summary-mark-message-as-read)))
+
+(defun olm-summary-mark-message-as-read
+  ()
+  (interactive)
+  (olm-do-command (concat "Olm.mark_as_read '"
+                          (olm-mail-item-entry-id-at)
+                          "'")))
+
+(defun olm-summary-scroll-message-forward
+  ()
+  (interactive)
+  (recenter)
+  (scroll-other-window olm-summary-scroll-lines))
+
+(defun olm-summary-scroll-message-backward
+  ()
+  (interactive)
+  (recenter)
+  (scroll-other-window (- olm-summary-scroll-lines)))
+
+(defun olm-summary-display-up
+  ()
+  (interactive)
+  (forward-line -1)
+  (recenter)
+  (olm-summary-open-message))
+
+(defun olm-summary-display-down
+  ()
+  (interactive)
+  (forward-line 1)
+  (recenter)
+  (olm-summary-open-message))
+
+(defun olm-summary-toggle-flag
+  ()
+  (interactive)
+  (let ((n (line-number-at-pos)))
+    (olm-do-command (concat "Olm.toggle_task_flag '"
+                          (olm-mail-item-entry-id-at)
+                          "'"))
+    (olm-scan)
+    (goto-line n)))
+
+(defun olm-summary-write
+  ()
+  (interactive)
+  (delete-other-windows-vertically)
+  (let ((buf (olm-buf-draft)))
+    (with-current-buffer buf
+      (olm-draft-mode))
+    (switch-to-buffer buf)))
+
+
+;;; A helper function for olm-summary-mode functions.
+(defun olm-mail-item-entry-id-at
+  ()
+  (interactive)
+  (let ((n (line-number-at-pos)))
+    (with-current-buffer (olm-buf-entry-ids)
+      (goto-line n)
+      (buffer-substring (line-beginning-position) (line-end-position)))))
+
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;;
+;;; olm-draft
+;;;
+(defvar olm-draft-mode-map nil)
+(defvar olm-draft-mode-hook nil)
+
+(unless olm-draft-mode-map
+  (setq olm-draft-mode-map (make-sparse-keymap))
+  (define-key olm-draft-mode-map "\C-c\C-q" 'olm-draft-kill)
+  (define-key olm-draft-mode-map "\C-c\C-c" 'olm-draft-send-message)
+  (define-key olm-draft-mode-map "\C-c\C-s" 'olm-draft-save-message))
+
+(defun olm-draft-mode
+  ()
+  (interactive)
+  (setq major-mode 'olm-draft-mode)
+  (setq mode-name "Olm Draft")
+  (setq-local line-move-ignore-invisible t)
+  (font-lock-mode 1)
+  (use-local-map olm-draft-mode-map)
+  (run-hooks 'olm-draft-mode-hook))
+
+(add-hook 'olm-draft-mode-hook 'olm-message-mode-keyword)
+
+(defun olm-draft-kill
+  ()
+  (interactive)
+  (kill-buffer)
+  (olm-scan))
+
+(defun olm-draft-do-message
+  (command)
+  (call-process-region (point-min) (point-max)
+                       "ruby" nil (get-buffer-create "*Messages*") nil
+                       "-r" "rubygems" "-r" "olm" "-e" command))
+
+(defun olm-draft-save-message
+  ()
+  (interactive)
+  (message "Olm: saving message ...")
+  (olm-draft-do-message "Olm.save_message")
+  (olm-draft-kill))
+
+(defun olm-draft-send-message
+  ()
+  (interactive)
+  (message "Olm: sending message ...")
+  (olm-draft-do-message "Olm.send_message")
+  (olm-draft-kill))

data/olm.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'olm'
+
+Gem::Specification.new do |spec|
+  spec.name          = "olm"
+  spec.version       = Olm::VERSION
+  spec.authors       = ["Takahiro Noda"]
+  spec.email         = ["takahiro.noda+rubygems@gmail.com"]
+  spec.summary       = %q{A glue library to manipulate MS Outlook Mail.}
+  spec.description   = %q{Olm is designed for reading and writing Outlook mail using the win32ole library and against Outlook 2007.}
+  spec.homepage      = "https://github.com/tnoda/olm"
+  spec.license       = "MIT"
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: olm
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Takahiro Noda
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-07-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Olm is designed for reading and writing Outlook mail using the win32ole
+  library and against Outlook 2007.
+email:
+- takahiro.noda+rubygems@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- LICENSE
+- README.md
+- lib/olm.rb
+- lib/olm/app.rb
+- olm.el
+- olm.gemspec
+homepage: https://github.com/tnoda/olm
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: A glue library to manipulate MS Outlook Mail.
+test_files: []