memot 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 95e71f2387ebc7f6326acb02c05bbfadf255f58f
+  data.tar.gz: 90bf03bda2664167424ae2d583cb672fa14eb0c7
+SHA512:
+  metadata.gz: 6db31da79d2ba95f4b0cb165f8cc79f2053d3221fcfe145f7357fb02b69b1836103c15c3b84f5219d676873dec6636ffb8bbe1e53008bd3fd10db77c4c5591e7
+  data.tar.gz: 3953eff5818dbde19f0e8ddadb8a448511e1875c00a46276f09d577a2ae7de0ad51b22e32b3d333306b7c73281fd1ace01104ef5b9725bb2fc8851a97f579291

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.memot.yml.sample

@@ -0,0 +1,9 @@
+auth:
+  evernote:
+    token:
+    sandbox:
+  dropbox:
+    app_key:
+    app_secret:
+    access_token:
+notes:

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.0.0

data/Dockerfile

@@ -0,0 +1,8 @@
+FROM ruby:2.2.0
+
+RUN mkdir /app
+COPY . /app
+WORKDIR /app
+RUN bundle install --without development --system
+
+CMD ["bundle", "exec", "bin/memot", "-i", "15"]

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in memot.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 dtan4
+
+MIT License
+
+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,84 @@
+# Memot
+
+Synchronize Evernote and Markdown in Dropbox
+
+(TODO: Add image)
+
+## Installation
+
+```shell
+$ gem install memot
+$ memot
+```
+
+## Usage
+
+## Configure
+
+You can choose configuration style:
+
+- `~/.memot.yml`
+- Environment variables
+
+### `~/.memot.yml`
+
+Create `~/.memot.yml` and fill this.
+
+```yaml
+auth:
+  evernote:
+    token:
+    sandbox: false
+  dropbox:
+    app_key:
+    app_secret:
+    access_token:
+notes:
+  <evernote_notebook>: <dropbox_path>
+  # example
+  daily: /memo/daily
+  reading: /memo/reading
+```
+
+### Environment variables
+
+key | type | example
+----|------|-----
+MEMOT_DROPBOX_APP_KEY | string |
+MEMOT_DROPBOX_APP_SECRET | string |
+MEMOT_DROPBOX_ACCESS_TOKEN | string |
+MEMOT_EVERNOTE_TOKEN | string |
+MEMOT_EVERNOTE_SANDBOX | boolean | `false`
+MEMOT_NOTES | string | `daily:/memo/daily,reading:/memo/reading`
+
+MEMOT_NOTES: `<evernote_notebook1>:<dropbox_path1>[,<evernote_notebook2>:<dropbox_path2> ...]`
+
+## Docker image
+
+Memot Docker image is available at [quay.io/dtan4/memot](https://quay.io/repository/dtan4/memot).
+
+[![Docker Repository on Quay.io](https://quay.io/repository/dtan4/memot/status "Docker Repository on Quay.io")](https://quay.io/repository/dtan4/memot)
+
+```shell
+$ docker run -e MEMOT_DROPBOX_APP_KEY=... quay.io/dtan4/memot
+```
+
+This image runs `memot` every 15 minutes.
+If you'd like to configure interval, specify command explicitly.
+
+```shell
+# Run every 30 minutes
+$ docker run -e MEMOT_DROPBOX_APP_KEY=... quay.io/dtan4/memot bundle exec bin/memot -i 30
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
+
+MIT

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/memot

@@ -0,0 +1,55 @@
+#!/usr/bin/env ruby
+
+require "memot"
+require "optparse"
+
+@options = {
+  auth: false,
+  interval: 0,
+}
+
+OptionParser.new do |opts|
+  opts.on("--auth", "Authenticate Dropbox") { |val| @options[:auth] = true }
+  opts.on("-i", "--interval=INTERVAL", "Sync interval") { |val| @options[:interval] = val.to_i }
+end.parse!(ARGV)
+
+config_dir = ENV["MEMOT_CONFIG_DIR"] || ENV["HOME"]
+config_path = File.join(config_dir, ".memot.yml")
+config = File.exists?(config_path) ? Memot::Config.load_yaml(config_path) : Memot::Config.load_env
+
+if @options[:auth]
+  access_token = Memot::Dropbox.auth(config.auth[:dropbox][:app_key], config.auth[:dropbox][:app_secret])
+  puts access_token
+  exit 0
+end
+
+redis_host = ENV["REDIS_HOST"] || ENV["REDIS_PORT_6379_TCP_ADDR"] || "127.0.0.1"
+redis_port = (ENV["REDIS_PORT"] || ENV["REDIS_PORT_6379_TCP_PORT"] || "6379").to_i
+
+redis = Redis.new(host: redis_host, port: redis_port, driver: :hiredis)
+logger = Logger.new($stdout)
+$stdout.sync = true
+
+dropbox = Memot::Dropbox.new(config.auth[:dropbox][:access_token].to_s, redis)
+evernote = Memot::Evernote.new(config.auth[:evernote][:token], config.auth[:evernote][:sandbox])
+cli = Memot::Client.new(dropbox, evernote, logger)
+
+if @options[:interval] < 1
+  # One-time execution
+  cli.update(config.notes)
+  exit 0
+end
+
+# Continuous execution
+
+trap("INT") do
+  puts "\rExiting..."
+  exit 0
+end
+
+loop do
+  cli.update(config.notes)
+
+  interval = @options[:interval] * 60 - Time.now.subsec + 0.001
+  sleep(interval) if interval > 0
+end

data/lib/memot.rb

@@ -0,0 +1,13 @@
+require "logger"
+require "redis"
+require "yaml"
+
+require "memot/version"
+require "memot/config"
+require "memot/dropbox"
+require "memot/evernote"
+require "memot/markdown"
+require "memot/client"
+
+module Memot
+end

data/lib/memot/client.rb

@@ -0,0 +1,61 @@
+module Memot
+  class Client
+    def initialize(dropbox, evernote, logger)
+      @dropbox = dropbox
+      @evernote = evernote
+      @logger = logger
+    end
+
+    def update(notes)
+      logger.info("Updating...")
+
+      need_update = []
+
+      notes.each_pair do |notebook, dropbox_path|
+        need_update << { notebook: notebook, updates: dropbox.parse_dir_tree!(dropbox_path) }
+      end
+
+      need_update.each do |update|
+        notebook = update[:notebook].to_s
+        update[:updates].each { |u| save_to_evernote(u[:dropbox_path], notebook, u[:revision]) }
+      end
+
+      logger.info("Finish")
+    end
+
+    def save_to_evernote(dropbox_path, notebook, revision)
+      note_body = Memot::Markdown.parse_markdown(dropbox.file_body_of(dropbox_path))
+      note_title = File.basename(dropbox_path)
+
+      begin
+        if (note_guid = evernote.get_note_guid(note_title, notebook)) == ""
+          evernote.create_note(note_title, note_body, notebook)
+          logger.info "Created: #{notebook}/#{note_title} (rev. #{revision})"
+        else
+          evernote.update_note(note_title, note_body, notebook, note_guid)
+          logger.info "Updated: #{notebook}/#{note_title} (rev. #{revision})"
+        end
+
+      rescue Memot::EvernoteRateLimitReachedError => e
+        sleep_interval = e.message.to_i + 60
+        logger.warn "Evernote rate limit exceeded, retry after #{sleep_interval} seconds."
+        sleep sleep_interval
+        retry
+      end
+    end
+
+    private
+
+    def dropbox
+      @dropbox
+    end
+
+    def evernote
+      @evernote
+    end
+
+    def logger
+      @logger
+    end
+  end
+end

data/lib/memot/config.rb

@@ -0,0 +1,73 @@
+module Memot
+  class Config
+    class << self
+      def load_yaml(yaml_path)
+        yaml = symbolize_keys(YAML.load_file(yaml_path))
+        auth = yaml[:auth] || {}
+        notes = yaml[:notes] || {}
+
+        self.new(auth, notes)
+      end
+
+      def load_env
+        auth = {
+          dropbox: {
+            app_key: ENV["MEMOT_DROPBOX_APP_KEY"],
+            app_secret: ENV["MEMOT_DROPBOX_APP_SECRET"],
+            access_token: ENV["MEMOT_DROPBOX_ACCESS_TOKEN"],
+          },
+          evernote: {
+            token: ENV["MEMOT_EVERNOTE_TOKEN"],
+            sandbox: ENV["MEMOT_EVERNOTE_SANDBOX"].downcase == "true",
+          },
+        }
+
+        if ENV["MEMOT_NOTES"]
+          #
+          # daily:/memo/daily,reading:/memo/reading
+          #   -> { daily: "/memo/daily", reading: "/memo/reading" }
+          #
+          notes = ENV["MEMOT_NOTES"].split(",").map { |pair| pair.split(":") }.inject({}) do |nts, kv|
+            nts[kv[0]] = kv[1]
+            nts
+          end
+        else
+          notes = {}
+        end
+
+        self.new(auth, notes)
+      end
+
+      private
+
+      def symbolize_keys(hash)
+        result = {}
+
+        hash.each_pair do |key, value|
+          result[key.to_sym] = if value.is_a? Array
+                                 value.each { |element| symbolize_keys(element) }
+                               elsif value.is_a? Hash
+                                 symbolize_keys(value)
+                               else
+                                 value
+                               end
+        end
+
+        result
+      end
+    end
+
+    def initialize(auth, notes)
+      @auth = auth
+      @notes = notes
+    end
+
+    def auth
+      @auth
+    end
+
+    def notes
+      @notes
+    end
+  end
+end

data/lib/memot/dropbox.rb

@@ -0,0 +1,81 @@
+require "dropbox_sdk"
+
+module Memot
+  class Dropbox
+    class << self
+      def auth(app_key, app_secret)
+        flow = DropboxOAuth2FlowNoRedirect.new(app_key, app_secret)
+        puts "Access to this URL: #{flow.start}"
+        print "PIN code: "
+        code = gets.strip
+        flow.finish(code)
+      end
+    end
+
+    def initialize(access_token, redis)
+      @client = DropboxClient.new(access_token)
+      @redis = redis
+    end
+
+    def parse_dir_tree!(path)
+      latest_revision = get_revision(path)
+      updated_revision = latest_revision
+
+      need_update = []
+
+      client.metadata(path)["contents"].sort_by { |cont| cont["revision"] }.each do |cont|
+        cont_path = cont["path"]
+        cont_revision = cont["revision"]
+
+        unless cont["is_dir"]
+          if (cont_revision > latest_revision) && markdown?(cont_path)
+            need_update << { dropbox_path: cont_path, revision: cont_revision }
+            updated_revision = cont_revision
+          end
+        end
+      end
+
+      set_revision(path, updated_revision) if updated_revision > latest_revision
+
+      need_update
+    end
+
+    def file_body_of(path)
+      client.get_file(path)
+    end
+
+    private
+
+    def client
+      @client
+    end
+
+    def redis
+      @redis
+    end
+
+    def markdown?(path)
+      %w{.md .markdown}.include?(File.extname(path).downcase)
+    end
+
+    def dir_key_of(dir)
+      "memot:#{dir}"
+    end
+
+    def get_revision(dir)
+      key = dir_key_of(dir)
+
+      if redis.exists(key)
+        redis.get(key).to_i
+      else
+        set_revision(key, 0)
+        0
+      end
+    end
+
+    def set_revision(dir, revision)
+      key = dir_key_of(dir)
+      redis.set(key, revision)
+    end
+  end
+end

data/lib/memot/evernote.rb

@@ -0,0 +1,104 @@
+require "evernote_oauth"
+
+module Memot
+  class EvernoteError < StandardError; end
+  class EvernoteRateLimitReachedError < StandardError; end
+
+  class Evernote
+    def initialize(token, sandbox)
+      @token = token
+      @client = EvernoteOAuth::Client.new(token: token, sandbox: sandbox)
+    end
+
+    def create_note(title, body, notebook)
+      note = ::Evernote::EDAM::Type::Note.new
+      note.title = title.force_encoding("UTF-8")
+      note.content = create_note_content(body).force_encoding("UTF-8")
+      note.notebookGuid = get_notebook_guid(notebook)
+      note_store.createNote(token, note)
+
+    rescue ::Evernote::EDAM::Error::EDAMUserException, ::Evernote::EDAM::Error::EDAMSystemException => e
+      raise_error e
+    end
+
+    def update_note(title, body, notebook, note_guid)
+      note = note_store.getNote(token, note_guid, true, true, true, true)
+      note.title = title.force_encoding("UTF-8")
+      note.content = create_note_content(body).force_encoding("UTF-8")
+      note.notebookGuid = get_notebook_guid(notebook, false)
+      note_store.updateNote(token, note)
+
+    rescue ::Evernote::EDAM::Error::EDAMUserException, ::Evernote::EDAM::Error::EDAMSystemException => e
+      raise_error e
+    end
+
+    def get_note_guid(title, notebook)
+      notebook_guid = get_notebook_guid(notebook, false)
+      return "" if notebook_guid == ""
+
+      filter = ::Evernote::EDAM::NoteStore::NoteFilter.new
+      filter.notebookGuid = notebook_guid
+      spec = ::Evernote::EDAM::NoteStore::NotesMetadataResultSpec.new
+      spec.includeTitle = true
+      results = note_store.findNotesMetadata(token, filter, 0, 10000, spec).notes.select { |nt| nt.title == title }
+      results.length > 0 ? results.first.guid : ""
+
+    rescue ::Evernote::EDAM::Error::EDAMSystemException => e
+      raise_error e
+    end
+
+    def create_notebook(name, stack = "")
+      notebook = ::Evernote::EDAM::Type::Notebook.new
+      notebook.name = name
+      notebook.stack = stack unless stack == ""
+      note_store.createNotebook(token, notebook)
+
+    rescue ::Evernote::EDAM::Error::EDAMUserException, ::Evernote::EDAM::Error::EDAMSystemException => e
+      raise_error e
+    end
+
+    def get_notebook_guid(notebook, create = true)
+      results = note_store.listNotebooks.select { |nb| nb.name == notebook }
+
+      if results.length > 0
+        results.first.guid
+      else
+        create ? create_notebook(notebook).guid : ""
+      end
+    rescue ::Evernote::EDAM::Error::EDAMSystemException => e
+      raise_error e
+    end
+
+    private
+
+    def client
+      @client
+    end
+
+    def note_store
+      @note_store ||= client.note_store
+    end
+
+    def token
+      @token
+    end
+
+    def create_note_content(body)
+      content = <<EOS
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd">
+<en-note>
+#{body}
+</en-note>
+EOS
+      content
+    end
+
+    def raise_error(e)
+      raise EvernoteRateLimitReachedError, e.rateLimitDuration if e.errorCode == ::Evernote::EDAM::Error::EDAMErrorCode::RATE_LIMIT_REACHED
+
+      error_text = ::Evernote::EDAM::Error::EDAMErrorCode::VALUE_MAP[e.errorCode]
+      raise EvernoteError, "Exception raised (errorText: #{error_text})"
+    end
+  end
+end

data/lib/memot/markdown.rb

@@ -0,0 +1,12 @@
+require "redcarpet"
+
+module Memot
+  class Markdown
+    def self.parse_markdown(markdown)
+      markdown = markdown.gsub("<", "&lt;").gsub(">", "&gt;")
+      renderer = Redcarpet::Markdown.new(Redcarpet::Render::XHTML, autolink: true)
+
+      renderer.render(markdown) rescue markdown
+    end
+  end
+end

data/lib/memot/version.rb

@@ -0,0 +1,3 @@
+module Memot
+  VERSION = "0.1.0"
+end

data/memot.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'memot/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "memot"
+  spec.version       = Memot::VERSION
+  spec.authors       = ["dtan4"]
+  spec.email         = ["dtanshi45@gmail.com"]
+  spec.description   = %q{Markdown Memo Management Library}
+  spec.summary       = %q{Markdown Memo Management Library}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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_dependency "dropbox-sdk"
+  spec.add_dependency "evernote_oauth"
+  spec.add_dependency "redcarpet"
+
+  spec.add_dependency "redis"
+  spec.add_dependency "hiredis"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "guard-rspec"
+end

data/spec/memot_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Memot do
+  it 'should have a version number' do
+    Memot::VERSION.should_not be_nil
+  end
+
+  it 'should do something useful' do
+    false.should be_true
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'memot'

metadata

@@ -0,0 +1,194 @@
+--- !ruby/object:Gem::Specification
+name: memot
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- dtan4
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dropbox-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: evernote_oauth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hiredis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  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: Markdown Memo Management Library
+email:
+- dtanshi45@gmail.com
+executables:
+- memot
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".memot.yml.sample"
+- ".rspec"
+- ".travis.yml"
+- Dockerfile
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/memot
+- lib/memot.rb
+- lib/memot/client.rb
+- lib/memot/config.rb
+- lib/memot/dropbox.rb
+- lib/memot/evernote.rb
+- lib/memot/markdown.rb
+- lib/memot/version.rb
+- memot.gemspec
+- spec/memot_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: Markdown Memo Management Library
+test_files:
+- spec/memot_spec.rb
+- spec/spec_helper.rb