everdone 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f6a233c262926369ff671d05bc39ca7c4851473b
+  data.tar.gz: 243e02fe226c50a3ef411ba9579dbf83522fde1e
+SHA512:
+  metadata.gz: 57f67c9233a73baddda008eda39c9d503ec45e4ddc70f8c6cf32cb2703eebca87af26c803d361442171ae1f43855ac5e066f7856b6ccac2e431944af34d72380
+  data.tar.gz: 123e4d163fe238d566d665ae132dc6abf60f828adaf06917d36fdc99cd0f1d1815e4a68d560e1d735a2de2aa3f3b06f8816dde34502bb702f6b5a8d13d99c05e

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+everdone.sublime-project
+everdone.sublime-workspace
+.DS_Store
+*.swp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Steve Heckt
+
+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,95 @@
+# Everdone
+
+A command line utility that takes completed tasks from Todooist and inserts them as entries into Evernote.
+
+_Full disclosure: [Zapier](http://zapier.com) now supports pushing Todoist items to Evernote_
+
+I still like my solution better as it gives finer control - and I wrote it.  :)
+
+Likely this best serves as simple examples of using the Evernote and Todoist API's from Ruby.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'everdone'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install everdone
+
+This utility depends on Todoist having a project named "EvernoteSync".  An item is added to this project to track all the Todoist item IDs that have already been added to Evernote.  This keeps the utility from needing to query Evernote to see if an item has already been copied.  Not as elegant a solution as I'd like.  (BTW, the utility does double-check with Evernote before adding a new item.)
+
+## Usage
+
+Everdone was written to be a command line utility, but to use it from a Ruby script...
+
+    require 'everdone'
+
+    Everdone.sync
+
+Someday it should take options at the sync() call, but for now it starts with default options (included in this gem) and merges in options specified in the '.everdone' file in the caller's home directory.  The full set of options are:
+
+```json
+    {
+        "default_notebook" : "<set to one of your Evernote notebooks>",
+        "tag" : "Todoist",
+        "evernote_datetime_format" : "%a %e %b %Y %H:%M",
+        "use_evernote_sandbox" : false,
+        "evernote_token" : "<get from: https://www.evernote.com/api/DeveloperToken.action>",
+
+        "todoist_token" : "<get from your Todoist settings Account tab>",
+        "todoist_completed_window" : "past 2 weeks",
+        "todoist_datetime_format" : "%a %e %b %Y %H:%M:%S %z",
+        "todoist_project_url" : "https://todoist.com/app?v=204#project/",
+        "todoist_label_url" : "https://todoist.com/app?v=204#agenda/@",
+        "todoist_sync_tracking_project" : "EvernoteSync",
+        "todoist_content_tag" : "TodoistItemId",
+        "todoist_link_title_regex" : "/\[\[[\w\s]+=[\h]+\s*,\s*([ -~]+)\]\]/",
+
+        "todoist_evernote_map" : {
+        }
+    }
+```
+
+A basic set of options, in JSON format within your .everdone file, might look like:
+
+    $ cat ~/.everdone 
+    {
+        "default_notebook" : "My Work Notebook",
+        "evernote_token" : "S=s1:U=1f14:E=14c1<your Evernote dev token bits>de0626b34bc5ede7",
+        "todoist_token" : "582a9<your Todoist API token bits>71ef5",
+        "todoist_evernote_map" : {
+            "Home" : "My Personal Notebook",
+            "Hobby" : "My Hobby Notebook"
+        }
+    }
+
+From the command line it looks like:
+
+    $ everdone
+    INFO: Returned 39 items
+    INFO: Done! Of 39 found...
+      1 added to Evernote
+      All time total processed now 340
+
+## The Present
+
+Contains a nacent set of tests.
+
+## The Future
+
+See everdone.rb for a list of TODO's I have in mind.  Other, more minor TODO ideas are sprinked throughout the code. 
+But I suspect this need will soon be fully met by Zapier.com or IFTTT.com.
+
+## Contributing
+
+1. Fork it ( http://github.com/heck/everdone/fork )
+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

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+ # t.libs << './lib'
+ t.libs << 'test'
+ t.pattern = 'test/**/*Test.rb'
+end

data/bin/everdone

@@ -0,0 +1,5 @@
+#!/usr/bin/ruby
+
+require 'everdone'
+Everdone.sync
+

data/everdone.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'everdone/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "everdone"
+  spec.version       = Everdone::VERSION
+  spec.authors       = ["Steve Heckt"]
+  spec.email         = ["home@u2me.com"]
+  spec.summary       = %q{Syncs completed Todoist items into Evernote}
+  spec.description   = %q{Uses Todoist and Evernote web services (and their respective API tokesn) }
+  spec.homepage      = "http://github.com/heck/everdone"
+  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_runtime_dependency "evernote-thrift", "~> 1.25"
+  spec.add_runtime_dependency "evernote_oauth", "~> 0.2"
+  spec.add_runtime_dependency "httparty", "~> 0.13"
+  spec.add_runtime_dependency "json", "~> 1.8"
+  spec.add_runtime_dependency "oauth", "~> 0.4"
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "awesome_print"
+end

data/lib/everdone.rb

@@ -0,0 +1,89 @@
+# TODO: Add real error and corner case handling
+# TODO: command line options such as "create user config", "pre-flight test", "dry run", "verbose"
+# TODO: Test on Windows
+# TODO: Templatize Evernote entry format
+# TODO: Allow Todoist content to be in markdown and covert before posting to Evernote
+
+require "everdone/version"
+
+require 'awesome_print'
+require 'time'
+
+# Everdone local stuff
+require 'everdone/config'
+require 'everdone/evernote'
+require 'everdone/enmlformatter'
+require 'everdone/todoist'
+require 'everdone/sync'
+
+module Everdone
+    def self.init
+        @@config = Config.new(File.expand_path("../everdone/default_config.json", __FILE__), "#{Dir.home}/.everdone")
+        @@evernote = Evernote.new(@@config)
+        @@todoist = Todoist.new(@@config)
+    end
+
+    def self.get_notebook_from_project(project)
+        notebook = @@config.todoist_evernote_map[project]  # It is possible the project is in the map but the value is nil.  This means: don't add items from this project to Evernote
+        if not @@config.todoist_evernote_map.has_key?(project)  # If the project is not in the map at all then put it in the default notebook
+            notebook = @@config.default_notebook
+        end
+        return notebook
+    end
+
+    def self.sync
+        self.init
+        
+        sync = Sync.new(@@config, @@todoist)
+
+        items = @@todoist.get_completed_items()
+        puts "INFO: Returned #{items.length} items"
+        processed = []  # list of Todoist item ids that were processed
+        found = []  # list of Todoist item ids not in the already processed list but subsequently found in Evernote
+        excluded = [] # a list of Todoist item ids that were not added because they belong to a project that is blacklisted
+        items.each { |item|
+            if not sync.is_already_processed(item.id)
+                # Map the project to an Evernote notebook
+                notebook = get_notebook_from_project(item.projects[0])
+                find_count = @@evernote.find_note_counts("#{@@config.todoist_content_tag}#{item.id}", notebook) if notebook
+                if notebook.nil?
+                    excluded.push(item.id)  # project did not map to any notebook => don't add to Evernote
+                elsif find_count > 0
+                    found.push(item.id)  # Todoist item already in Evernote => don't add
+                else  # not already processed nor in an ignored project nor was it found in Evernote.  Make a new one!
+                    # Create the note's content
+                    content = EnmlFormatter.new(@@config)
+                    content.text("Project: ").link(item.projects[0], item.get_project_url(0))
+                    if item.labels.length > 0
+                        content.space.space.space.space
+                        content.text("Labels: ")
+                        item.labels.each { |label| 
+                            content.link(label, item.get_label_url(label)).space 
+                        }
+                    end
+                    content.space.space.space.text("#{@@config.todoist_content_tag}#{item.id}")
+                    item.notes.each { |note|  
+                        content.h3("Note created #{content.datetime_to_string(note.created, @@config.todoist_datetime_format)}   [Todoist note id: #{note.id}]")
+                        content.rawtext(note.content)
+                    }
+
+                    # Create the note in Evernote
+                    @@evernote.create_note(item.title, 
+                        content.to_s, 
+                        notebook,
+                        Evernote.convert_text_to_timestamp(item.created, @@config.todoist_datetime_format))
+                end
+                processed.push(item.id)  # whether item was added to Evernote or not don't process it again.
+            end
+        }
+
+        # Finish up by doing the syncing bookwork
+        sync.close(processed)
+
+        puts "INFO: Done! Of #{items.length} found..."
+        puts "  #{processed.length - (found.length+excluded.length)} added to Evernote"
+        puts "  #{found.length} were already in Evernote" if found.length > 0
+        puts "  #{excluded.length} were not added as they are in blacklisted Todoist projects" if excluded.length > 0
+        puts "  All time total processed now #{sync.get_processed_total()}"
+    end
+end

data/lib/everdone/config.rb

@@ -0,0 +1,65 @@
+#
+# Class to handle reading, writing, and encapsulating JSON-based app config
+
+# TODO: Preflight check vs. config.  Tokens work?  Projects, notebooks, tags needed all there?
+
+require 'json'
+
+module Everdone
+    class Config
+        def initialize(default_hash_file, user_settings_file)
+            @defaults = unmarshall_from_file(default_hash_file)
+            @user_settings_file = user_settings_file
+            @users = unmarshall_from_file(@user_settings_file)
+            @current = {}
+
+            collate_settings()
+        end
+
+        private
+
+        def define_instance_var(name, value)
+            self.class.module_eval { attr_accessor name.to_sym }
+            instance_variable_set("@#{name}", value)
+        end
+
+        # return a string of JSON for the current settings
+        def marshall_to_string()
+            current = JSON.generate(@current)
+            return current
+        end
+
+        def unmarshall_from_string(new_config)
+            return JSON.parse(new_config)
+        end 
+
+        def marshall_to_file(filename)
+        end
+
+        def unmarshall_from_file(filename)
+            users = {}
+            return users if not File.exist?(filename)
+            File.open(filename, "r") do |f|
+                users = JSON.load(f)
+            end
+            return users
+        end
+
+        def collate_settings
+            # add all the settings (every setting has a default) as a member variable of this class
+            @defaults.each { |name, val|  
+                define_instance_var(name,val)
+            }
+            # combine the default settings and the settings from the user file into the current settings
+            @current = @defaults
+            @users.each { |name, val|  
+                if @current.has_key?(name)
+                    @current[name] = val
+                    instance_variable_set("@#{name}", val)
+                else
+                    puts "WARN: the settings file #{@user_settings_file} contained an unrecognized setting #{name} (value = #{val})"
+                end
+            }
+        end
+    end
+end

data/lib/everdone/default_config.json

@@ -0,0 +1,19 @@
+{
+    "default_notebook" : "<set to one of your Evernote notebooks>",
+    "tag" : "Todoist",
+    "evernote_datetime_format" : "%a %e %b %Y %H:%M",
+    "use_evernote_sandbox" : false,
+    "evernote_token" : "<get from: https://www.evernote.com/api/DeveloperToken.action>",
+
+    "todoist_token" : "<get from your Todoist settings Account tab>",
+    "todoist_completed_window" : "past 2 weeks",
+    "todoist_datetime_format" : "%a %e %b %Y %H:%M:%S %z",
+    "todoist_project_url" : "https://todoist.com/app?v=204#project/",
+    "todoist_label_url" : "https://todoist.com/app?v=204#agenda/@",
+    "todoist_sync_tracking_project" : "EvernoteSync",
+    "todoist_content_tag" : "TodoistItemId",
+    "todoist_link_title_regex" : "/\[\[[\w\s]+=[\h]+\s*,\s*([ -~]+)\]\]/",
+
+    "todoist_evernote_map" : {
+    }
+}

data/lib/everdone/enmlformatter.rb

@@ -0,0 +1,103 @@
+require 'cgi'
+require 'time'
+require 'awesome_print'
+
+require 'everdone/config'
+
+#
+# Class to help create the ENML (EverNote Markup Language) content
+#
+
+module Everdone
+    class EnmlFormatter
+        attr_reader :body
+
+        def initialize(config)
+            @config = config
+            @body = ""
+        end
+
+        def text(text)
+            @body = @body + text
+            return self
+        end
+
+        # from: http://code.tutsplus.com/tutorials/8-regular-expressions-you-should-know--net-6149
+        # match only url's that take the form http://..., https://... 
+        # but NOT <whatever>@<url> or <host>.<domain>.<tld>
+        URL_REGEX = /((https?:\/\/)([\da-zA-Z\.-]+)\.([a-z\.]{2,6})(:[\d]+)?([\/\w \.?%_&=+-]*)*\/?)/
+        def rawtext(text)
+            # Take text and do some cooking
+            #
+            # Escape HTML tags so Evernote doesn't freak out on them
+            text = CGI::escapeHTML(text)
+            # Remove newlines and insert HTML breaks (<br/>)
+            text_lines = text.split(/\n/)
+            text = ""
+            text_lines.each { |line|  
+                # Find URL-looking text and turn it into a link
+                url_match = line.match(URL_REGEX)
+                if url_match
+                    url = url_match[1]
+                    line.gsub!(url, "<a href='#{url}'>#{url}</a>") if url
+                end
+                text = text + "#{line}<br/>"
+            }
+            # Fix up some Todoist crap: It’s -> It's
+            text.gsub!("’", "'");
+            # Put it in the body
+            @body = @body + text
+            return self
+        end
+
+        def newline()
+            @body = @body + "<br/>"
+            return self
+        end
+
+        def h1(text)
+            @body = @body + "<h1>#{text}</h1>"
+            return self
+        end
+
+        def h2(text)
+            @body = @body + "<h2>#{text}</h2>"
+            return self
+        end
+
+        def h3(text)
+            @body = @body + "<h3>#{text}</h3>"
+            return self
+        end
+
+        def space
+            @body = @body + "&nbsp;"
+            return self
+        end
+
+        def link(text, url)
+            @body = @body + "<a href='#{url}'>#{text}</a>"
+            return self
+        end
+
+        def datetime_to_string(text, source_format)
+            return DateTime.strptime(text, source_format).new_offset(DateTime.now.offset).strftime(@config.evernote_datetime_format)
+        end
+
+        def datetime(text, source_format)
+            @body = @body + self.datetime_to_string(text, source_format)
+            return self
+        end
+
+        def clear
+            @body = ""
+        end
+
+        def to_s
+            ret = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
+            ret = "<!DOCTYPE en-note SYSTEM \"http://xml.evernote.com/pub/enml2.dtd\">"
+            ret += "<en-note>#{@body}</en-note>"
+            return ret
+        end
+    end
+end

data/lib/everdone/evernote.rb

@@ -0,0 +1,73 @@
+# Load libraries required by the Evernote OAuth
+require 'time'
+require 'oauth'
+require 'oauth/consumer'
+
+# Load Thrift & Evernote Ruby libraries
+require "evernote_oauth"
+
+require "everdone/config"
+
+module Everdone
+    class Evernote
+        def initialize(config)
+            @config = config
+            # Set up the NoteStore client 
+            @evernote_client = EvernoteOAuth::Client.new(
+                token: @config.evernote_token,
+                sandbox: @config.use_evernote_sandbox
+            )
+            @note_store = @evernote_client.note_store
+            @notebook_guids = {}
+            notebooks = @note_store.listNotebooks
+            notebooks.each do |notebook|
+                @notebook_guids[notebook.name] = notebook.guid
+            end
+            @tags = @note_store.listTags
+            @tags.each { |tag| 
+                if @config.tag and tag.name == @config.tag then
+                    @tag_guid = tag.guid
+                    break
+                end
+            }
+        end
+
+        def create_note(title, content, notebook, created)
+            new_note = ::Evernote::EDAM::Type::Note.new()
+            new_note.notebookGuid = @notebook_guids[notebook]
+            new_note.title = title.strip.slice(0..254).scan(/[[:print:]]/).join
+            new_note.created = created
+            new_note.content = content
+            new_note.tagNames = [@config.tag] if @config.tag
+
+            begin
+                created_note = @note_store.createNote(@config.evernote_token, new_note)
+            rescue => err
+                puts "ERROR: ----------- Evernote exception ------------------!!!"
+                ap err
+                puts "Note info:"
+                puts "Title: #{title}"
+                puts "Created: #{created}"
+                puts "Content:\n#{content}"
+            end
+            
+        end
+
+        # returns the count of notes within the context:
+        #     In the notebook NOTEBOOK_TARGET with tag (if defined) TAG_WITH and having content (if defined) content_text
+        def find_note_counts(content_text, notebook)
+            filter = ::Evernote::EDAM::NoteStore::NoteFilter.new()
+            filter.notebookGuid = @notebook_guids[notebook] if notebook
+            filter.tagGuids = [@tag_guid] if @config.tag
+            filter.words = content_text if content_text
+            ret = @note_store.findNoteCounts(filter, false)
+            # also: ret.tagCounts[@@tag_guid]
+            return !ret.notebookCounts.nil? && notebook && ret.notebookCounts[@notebook_guids[notebook]] ? ret.notebookCounts[@notebook_guids[notebook]] : 0
+        end
+
+        def self.convert_text_to_timestamp(dateText, date_format)
+            ret = DateTime.strptime(dateText, date_format).to_time.to_i * 1000
+            return ret
+        end
+    end
+end

data/lib/everdone/sync.rb

@@ -0,0 +1,63 @@
+#
+# Class that keeps track of what's been synced
+#
+require 'time'
+require 'json'
+
+require 'everdone/todoist.rb'
+
+module Everdone
+    class Sync
+        def initialize(config, todoist)
+            @config = config
+            @todoist = todoist
+            @data = {}
+            @current_item_id = nil
+            items = @todoist.get_items_by_project_name(@config.todoist_sync_tracking_project)
+            raise "Too many items in Todoist project used for syncing (#{@config.todoist_sync_tracking_project}): #{items.length}" if items.length > 1
+            if items.length == 0 then
+                initData()
+            else
+                @current_item_id = items[0]['id']
+                notes = @todoist.get_notes(@current_item_id)
+                unmarshall(notes[0]['content']) if notes and notes.length > 0
+            end
+        end
+
+        def init_data
+            @data['created'] = DateTime.now
+            @data['processed'] = []
+        end
+
+        def is_already_processed(item_id)
+            return  !@data['processed'].find_index(item_id).nil?
+        end
+
+        def close(new_processed)
+            @data['processed'].concat(new_processed)
+            new_item_id = @todoist.add_item_to_project_by_name(@config.todoist_sync_tracking_project, 
+                "Evernote sync data from #{DateTime.now.to_s} total processed = #{self.get_processed_total()}",
+                1)
+            new_data = self.marshall
+            @todoist.add_note(new_item_id, new_data)
+            @todoist.delete_item_by_id(@current_item_id) if @current_item_id
+        end
+
+        def get_processed_total()
+            return @data['processed'].length
+        end
+
+        def add_to_processed(new_processed)
+            @data['processed'].push(new_processed)
+        end
+
+        def marshall
+            data = JSON.generate(@data)
+            return data
+        end
+
+        def unmarshall(data)
+            @data = JSON.parse(data)
+        end
+    end
+end

data/lib/everdone/todoItem.rb

@@ -0,0 +1,61 @@
+#
+# TodoItem
+#   Handle mapping a single Todoist itme to something EverTodo can work with
+#
+require 'awesome_print'
+
+require 'everdone/config'
+
+module Everdone
+    class TodoNote
+        attr_reader :id, :created, :content
+        def initialize(todoist_note)
+            note = todoist_note
+            @id = note['id']
+            @created = note['posted']
+            @content = note['content']
+        end
+    end
+
+    class TodoItem
+        attr_reader :id, :title, :created, :projects, :project_ids, :labels, :notes, :priority, :due_date
+        def initialize(config, todoist_item, projects, labels)
+            @config = config
+            item = todoist_item
+            @id = item['id']
+            @title = item['content']
+            clean_title()  # strip off all (known) Todoist detritus
+            @created = item['completed_date']
+            @projects = []  # Just the parent for now.  TODO: array of projects starting with senior parent and working down to immediate parent
+            @projects.push(projects[item['project_id']])
+            @project_ids = []  # Just the parent for now.  TODO: array of project ids starting with senior... (see above)
+            @project_ids.push(item['project_id'])
+            @labels = []  # arrary of associated labels (random order)
+            item['labels'].each { |labelId|
+                @labels.push(labels[labelId])
+            }
+            @priority = item['priority']
+            @due_date = item['due_date']
+            @notes = []  # array of notes
+            if not item['notes'].nil?
+                item['notes'].each { |note|
+                    new_note = TodoNote.new(note)
+                    @notes.push(new_note)
+                }
+            end
+        end
+
+        def clean_title()
+            cleaned_title = @title.match(@config.todoist_link_title_regex)
+            @title = cleaned_title.nil? ? @title : cleaned_title[1].strip
+        end
+
+        def get_project_url(project_index)
+            return @config.todoist_project_url + @project_ids[project_index].to_s
+        end
+
+        def get_label_url(label)
+            return @config.todoist_label_url + label
+        end
+    end
+end

data/lib/everdone/todoist.rb

@@ -0,0 +1,111 @@
+require 'httparty'
+require 'awesome_print'
+
+require 'everdone/config'
+
+require 'everdone/todoItem'
+
+module Everdone
+    class Todoist
+        def initialize(config)
+            @config = config
+            @projects = {}  # map of project id's to project names
+            @project_id_by_name = {}  # map of project names to id's
+            projects = self.call_api('https://todoist.com/API/getProjects')
+            projects.each { |project|
+                @projects[project['id']] = project['name']
+                @project_id_by_name[project['name']] = project['id']
+            }
+            @labels = {}  # map of label id's to their name strings
+            labels = self.call_api('https://todoist.com/API/getLabels')
+            labels.each { |label|
+                @labels[label[1]['id']] = label[1]['name']
+            }
+        end
+
+        # helper function for making RESTful calls
+        def call_api(url, params=nil)
+            query = { 'token' => @config.todoist_token }
+            query.merge!(params) if params
+            ret = HTTParty.post(url, {
+              :query => query
+            })
+
+            if ret.response.code != "200"
+              raise "ERROR: Error calling Todoist API #{url}\n   Response Code: #{ret.response.code}\n  Response: \n#{ret.response.body}"
+            end
+            return ret
+        end
+
+        def add_item_to_project_by_name(project_name, content, priority)
+            ret = self.call_api('https://todoist.com/API/addItem',
+                params={'project_id'=>@project_id_by_name[project_name],'content'=>content, 'priority'=>priority})
+            return ret['id']
+        end
+
+        def add_note(item_id, content)
+            ret = self.call_api('https://todoist.com/API/addNote', params={'item_id'=>item_id,'content'=>content})
+            return ret
+        end
+
+        def get_completed_items()
+            ret = [] # list of completed items converted into TodoItem objects
+            interval = @config.todoist_completed_window
+            items = self.call_api('https://todoist.com/API/getAllCompletedItems', params={'interval'=>interval})
+            items['items'].each { |item|
+                todo_item = TodoItem.new(@config, item, @projects, @labels)
+                ret.push(todo_item)
+            }
+            return ret
+        end
+
+        def get_item_by_id(id)
+            items = self.call_api('https://todoist.com/API/getItemsById', params={'ids'=>id})  # get a single item based on id
+            todo_item = TodoItem.new(@config, items[0], @projects, @labels)
+            return todo_item
+        end
+
+        def get_items_by_project_name(project_name)
+            ret = self.call_api('https://todoist.com/API/getUncompletedItems', params={'project_id'=>@project_id_by_name[project_name]})
+            return ret
+        end
+
+        def get_notes(item_id)
+            ret = self.call_api('https://todoist.com/API/getNotes', params={'item_id'=>item_id})
+            return ret
+        end
+
+        def complete_item_by_id(id)
+            ret = self.call_api('https://todoist.com/API/completeItems', params={'ids'=>"[#{id}]"})
+            return ret
+        end
+
+        def delete_item_by_id(id)
+            ret = self.call_api('https://todoist.com/API/deleteItems', params={'ids'=>"[#{id}]"})
+            return ret
+        end
+    end
+
+    #
+    ## getting a token via login
+    #
+    #login = HTTParty.post('https://todoist.com/API/login', {
+    #  :query => {
+    #    'email'=>'home@u2me.com',
+    #    'password'=>'<insert password here>'
+    #  }
+    #})
+    #
+    #if login.response.code != "200"
+    #  raise "Login unsuccessful.\n#{login.response.code}\n#{login.response.body}"
+    #end
+    #
+    #puts "Login response was:"
+    #puts login.body
+    #puts
+    #
+
+    # for JSON responses, you can address keys in the response directly
+    #token = login['token']
+
+end

data/lib/everdone/version.rb

@@ -0,0 +1,3 @@
+module Everdone
+  VERSION = "0.0.3"
+end

data/test/configTest.rb

@@ -0,0 +1,28 @@
+require 'everdone'
+require 'awesome_print'
+
+require 'minitest/autorun'
+
+require 'everdone/config.rb'
+require 'json'
+
+class ConfigTest < MiniTest::Unit::TestCase
+    def setup
+    end
+
+    def test_initialize
+        config = Everdone::Config.new("test/config_1.json", "test/config_empty")
+        assert_equal "this is string_1", config.string_1
+        assert_equal 1, config.int_1
+        assert_equal 1.1, config.float_1
+        assert_equal "second_string", config.string_array_1[1]
+        assert_equal "value 1", config.hash_1["key_1"]
+    end
+
+    def test_initialze_with_user_settings
+        config = Everdone::Config.new("test/config_1.json", "test/config_partial")
+        assert_equal "this is THE NEW string_2", config.string_2
+        assert_equal 2.2, config.float_1
+        assert_equal 3, config.hash_1["key_2"]
+    end
+end

data/test/config_1.json

@@ -0,0 +1,10 @@
+{
+    "string_1": "this is string_1",
+    "string_2": "this is string_2",
+    "int_1": 1,
+    "float_1": 1.1,
+    "string_array_1": ["first_string", "second_string"],
+    "hash_1": { 
+        "key_1":"value 1", "key_2":2 
+    }
+}

data/test/config_partial

@@ -0,0 +1,7 @@
+{
+    "string_2": "this is THE NEW string_2",
+    "float_1": 2.2,
+    "hash_1": { 
+        "key_1":"value replaced", "key_2":3 
+    }
+}

data/test/enmlformatterTest.rb

@@ -0,0 +1,57 @@
+require 'everdone'
+
+require 'minitest/autorun'
+
+require 'everdone/config'
+require 'everdone/enmlformatter'
+
+class EnmlFormatterTest < MiniTest::Unit::TestCase
+    def setup
+        config = Everdone::Config.new("lib/everdone/default_config.json", "#{Dir.home}/.everdone")
+        @targ = Everdone::EnmlFormatter.new(config)
+    end
+
+    def test_text
+        # assert_equal "Hello World!", @main.hello
+        added_text = "this is some text"
+        @targ.text(added_text)
+        assert_equal added_text, @targ.body
+    end
+
+    def test_rawtext_todoist_crap
+        @targ.rawtext("It’s")
+        assert_match "It's", @targ.body
+    end
+
+    def check_url_good(url_text)
+        @targ.rawtext(url_text)
+        assert_match "<a href='#{url_text}'>#{url_text}</a>", @targ.body
+        @targ.clear
+    end
+
+    def check_url_bad(url_text)
+        @targ.rawtext(url_text)
+        refute_match "<a href=", @targ.body
+        @targ.clear
+    end
+
+    def test_rawtext_url_links
+        # the good
+        check_url_good "http://www.google.com"
+        check_url_good "https://www.google.com"
+        check_url_good "http://code.tutsplus.com/tutorials/8-regular-expressions-you-should-know--net-6149"
+        check_url_good "http://jira.nmwco.com:8080"
+        check_url_good "http://jira.nmwco.com:8080/browse/LOC-6847"
+        check_url_good "http://jira.nmwco.com:8080/browse/LOC-6847?filter=14192"
+        check_url_good "https://d1x0mwiac2rqwt.cloudfront.net/fec77b1148704f78bdf87a49d0a6e6b3/as/2014-03-18_Performance_log_Olson%2C_Erik.docx"
+        # the bad
+        check_url_bad "www.google.com"
+        check_url_bad "google.com"
+        check_url_bad "Knopf@NetMotionWireless.com"
+    end
+
+    TESTING_DATETIME_FORMAT = "%a %e %b %Y %H:%M:%S %z"
+    def test_datetimeToString
+        assert_equal "Mon 10 Mar 2014 08:45", @targ.datetime_to_string("Mon 10 Mar 2014 15:45:01 +0000", TESTING_DATETIME_FORMAT)
+    end
+end

data/test/evernoteTest.rb

@@ -0,0 +1,19 @@
+require 'everdone'
+
+require 'minitest/autorun'
+
+require 'everdone/config'
+require 'everdone/evernote'
+
+class EvernoteTest < MiniTest::Unit::TestCase
+    def setup
+        @config = Everdone::Config.new("lib/everdone/default_config.json", "#{Dir.home}/.everdone")
+        @evernote = Everdone::Evernote.new(@config)
+    end
+
+    def test_findNoteCounts
+        assert_equal 0, @evernote.find_note_counts("%$$%%$^@&& NOT IN EVERNOTE RIGHT? ^^{$^&*", @config.default_notebook)  # should not be found
+        assert_equal 1, @evernote.find_note_counts("#{@config.todoist_content_tag}4653498", @config.default_notebook)  # known to be
+        assert_equal 0, @evernote.find_note_counts("#{@config.todoist_content_tag}4653498", nil)  # known but not in this notebook
+    end
+end

data/test/todoistTest.rb

@@ -0,0 +1,19 @@
+require 'everdone'
+
+require 'minitest/autorun'
+
+require 'everdone/config'
+require 'everdone/todoist'
+require 'everdone/todoItem'
+
+class TodoistTest < MiniTest::Unit::TestCase
+    def setup
+        @config = Everdone::Config.new("lib/everdone/default_config.json", "#{Dir.home}/.everdone")
+        @todoist = Everdone::Todoist.new(@config)
+    end
+
+    KNOWN_TODOIST_COMPLETED_ID = 1155724
+    def test_todoItem
+        todo_item = @todoist.get_item_by_id(KNOWN_TODOIST_COMPLETED_ID)
+    end
+end

metadata

@@ -0,0 +1,199 @@
+--- !ruby/object:Gem::Specification
+name: everdone
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Steve Heckt
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: evernote-thrift
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.25'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.25'
+- !ruby/object:Gem::Dependency
+  name: evernote_oauth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.13'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: oauth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.4'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !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: minitest
+  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: awesome_print
+  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: 'Uses Todoist and Evernote web services (and their respective API tokesn) '
+email:
+- home@u2me.com
+executables:
+- everdone
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/everdone
+- everdone.gemspec
+- lib/everdone.rb
+- lib/everdone/config.rb
+- lib/everdone/default_config.json
+- lib/everdone/enmlformatter.rb
+- lib/everdone/evernote.rb
+- lib/everdone/sync.rb
+- lib/everdone/todoItem.rb
+- lib/everdone/todoist.rb
+- lib/everdone/version.rb
+- test/configTest.rb
+- test/config_1.json
+- test/config_partial
+- test/enmlformatterTest.rb
+- test/evernoteTest.rb
+- test/todoistTest.rb
+homepage: http://github.com/heck/everdone
+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.3
+signing_key: 
+specification_version: 4
+summary: Syncs completed Todoist items into Evernote
+test_files:
+- test/configTest.rb
+- test/config_1.json
+- test/config_partial
+- test/enmlformatterTest.rb
+- test/evernoteTest.rb
+- test/todoistTest.rb