evernotable 1.0.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

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

data/README.rdoc

@@ -0,0 +1,57 @@
+= Evernotable
+
+* https://github.com/kmuthupa/evernotable
+
+== Description
+
+A simple commandline task manager that uses Evernote note store. This automatically creates a new distinct Evernote notebook for persistance of tasks. Users can add new tasks, list them and remove existing tasks.
+
+== Usage
+
+  # authenticate 
+  evernotable auth login
+  evernotable auth logout
+  
+  # add a new task
+  evernotable task add 'shave my beard!'
+  
+  # list all existing tasks
+  evernotable task list
+
+  # remove an existing task
+  evernotable task remove #2 => removes task listed #2 
+
+== Dependencies
+
+* evernote
+* thrift
+* thrift_client
+* encrypted_strings
+* highline
+
+== Installation
+
+* gem install evernotable
+
+== License
+
+Copyright 2012 Karthik Muthupalaniappan
+
+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/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/evernotable

@@ -0,0 +1,3 @@
+# start up the CLI
+require "evernotable/cli"
+Evernotable::CLI.start(*ARGV)

data/evernotable.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "evernotable/version"
+
+Gem::Specification.new do |s|
+  s.name        = "evernotable"
+  s.version     = Evernotable::VERSION
+  s.authors     = ["Karthik Muthupalaniappan"]
+  s.email       = ["karthik.m@imaginea.com"]
+  s.homepage    = "http://intellisenze.wordpress.com"
+  s.summary     = %q{A simple commandline task manager that uses Evernote note store}
+  s.description = %q{A simple commandline task manager that uses Evernote note store. This automatically creates a new distinct Evernote notebook for persistance of these task notes.}
+
+  s.rubyforge_project = "evernotable"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency "thrift"
+  s.add_dependency "thrift_client"
+  s.add_dependency "evernote"
+  s.add_dependency "highline"
+  s.add_dependency "encrypted_strings"
+  s.add_development_dependency "rspec"
+end

data/lib/evernotable.rb

@@ -0,0 +1,4 @@
+require 'evernote'
+
+module Evernotable  
+end

data/lib/evernotable/cli.rb

@@ -0,0 +1,13 @@
+require "evernotable"
+require "evernotable/command"
+require "highline"
+
+class Evernotable::CLI
+
+  def self.start(*args)
+    command = args.shift.strip rescue "help"
+    Evernotable::Command.load
+    Evernotable::Command.run(command, args)
+  end
+
+end

data/lib/evernotable/client.rb

@@ -0,0 +1,8 @@
+module Evernotable
+  module Client
+    
+    class ClientException < RuntimeError
+    end
+
+  end
+end

data/lib/evernotable/client/base.rb

@@ -0,0 +1,30 @@
+require 'evernote'
+require 'evernotable/client'
+require 'yaml'
+
+class Evernotable::Client::Base 
+  attr_reader :config
+  attr_reader :current_user
+  attr_reader :client_token
+  
+  def initialize(params={})
+    @config = params[:config] || nil
+    @current_user = params[:current_user] || nil
+    @client_token = params[:client_token] || nil
+  end
+  
+  protected 
+  
+  def wrap_method(message, &block)
+    yield @client_token
+  rescue Exception => ex
+    raise Evernotable::Client::ClientException, "#{message}: #{ex.message}"
+  end
+  
+  attr_writer :current_user
+  attr_writer :client_token
+end
+
+
+
+

data/lib/evernotable/client/note.rb

@@ -0,0 +1,69 @@
+require 'evernotable/client/base'
+require 'evernotable/utilities'
+
+class Evernotable::Client::Note < Evernotable::Client::Base 
+  include Evernotable::Utilities
+  attr_reader :notebook_guid
+  
+  def initialize(params={})
+    super(params)
+    @api = @config["note_api"]["sandbox"] #TODO: variablize the api env
+    @notebook_name = @config["notebook"]["name"]
+    @notebook_guid = nil
+    @instance = Evernote::NoteStore.new("#{@api}#{params[:user_shard]}")
+  end
+  
+  def add_notebook
+    wrap_method('attempt to create new notebook') do |client_token| 
+      @notebook_guid = @instance.createNotebook(client_token, Evernote::EDAM::Type::Notebook.new({:name => @notebook_name})).guid 
+    end
+  end
+
+  def add_note(note_text)
+    self.add_notebook unless notebook_exists?
+    wrap_method('attempt to create a new note') do |client_token| 
+      @instance.createNote(client_token, Evernote::EDAM::Type::Note.new({:title => note_text, :content => wrap_enml(note_text), :notebookGuid => @notebook_guid}))
+    end
+  end
+
+  def remove_note(note_guid)
+    return unless notebook_exists?
+    wrap_method('attempt to remove a note') { |client_token| @instance.deleteNote(client_token, note_guid) }
+  end
+  
+  def list_notes
+    return unless notebook_exists?
+    wrap_method('attempt to list notes') do |client_token| 
+      @instance.findNotes(client_token, Evernote::EDAM::NoteStore::NoteFilter.new({:notebookGuid => @notebookGuid}), 0, 100).notes 
+    end
+  end
+  
+  def list_notebooks
+    wrap_method('attempt to list notebooks') { |client_token| @instance.listNotebooks(client_token) }
+  end
+  
+  def expunge_notebook
+    return unless notebook_exists?
+    wrap_method('attempt to expunge the evernotable notebook') do |client_token| 
+      @instance.expungeNotebook(client_token, @notebook_guid) 
+    end
+  end
+  
+  def expunge_trashed_notes
+    wrap_method('attempt to expunge all trashed notes') do |client_token| 
+      @instance.expungeInactiveNotes(client_token) 
+    end
+  end
+  
+  def notebook_exists?
+    notebooks = list_notebooks
+    notebooks.each do |notebook|
+      if notebook.name == 'evernotable'
+        @notebook_guid = notebook.guid
+        return true
+      end
+    end
+    return false
+  end
+  
+end

data/lib/evernotable/client/user.rb

@@ -0,0 +1,27 @@
+require 'evernotable/client/base'
+
+class Evernotable::Client::User < Evernotable::Client::Base 
+  
+  def initialize(params={})
+    super
+    api = @config["user_api"]["sandbox"] #TODO: variablize the api env
+    @instance = Evernote::UserStore.new(api, {:username => params[:user], :password => params[:password], :consumer_key => @config["api_credentials"]["consumer_key"], :consumer_secret => @config["api_credentials"]["consumer_secret"]})
+  end
+  
+  def authenticate
+    self.wrap_method('attempt to authenticate the user') do
+      auth_result = @instance.authenticate
+      self.current_user = auth_result.user
+      self.client_token = auth_result.authenticationToken
+    end
+  end
+  
+  def refresh_authentication
+    self.wrap_method('attempt to refresh auth token') {|client_token| self.client_token = @instance.refreshAuthentication(client_token).authenticationToken}
+  end
+
+  def valid_version?
+    self.wrap_method('attempt to check API version') { @instance.version_valid? }
+  end
+  
+end

data/lib/evernotable/command.rb

@@ -0,0 +1,49 @@
+require 'evernotable/utilities'
+
+module Evernotable
+  module Command
+    
+    extend Evernotable::Utilities
+    
+    class CommandFailed  < RuntimeError
+    end
+
+    def self.load
+      @@commands = []
+      Dir[File.join(File.dirname(__FILE__), "command", "*.rb")].each do |file|
+        require file
+        @@commands << File.basename(file, '.*') 
+      end
+    end
+    
+    def self.commands
+      @@commands ||= []
+    end
+    
+    def self.valid?(cmd)
+       @@commands.include?(cmd)
+    end
+
+    def self.run(cmd, arguments=[])
+      if cmd.nil? || cmd.empty? 
+        output_with_bang("Use *evernotable help* for additional information.")
+        exit(1)
+      end
+      unless valid?(cmd)
+        output_with_bang("*#{cmd}* is not a valid evernotable command.")
+        output_with_bang("Use *evernotable help* for additional information.")
+        exit(1)
+      else
+        #instantiate command and invoke method on it
+        method = arguments.shift || :help
+        obj = eval("Evernotable::Command::#{cmd.capitalize}").new(arguments)
+        obj.send(method)
+      end
+    rescue CommandFailed => ex
+      error "#{ex.message}"
+    rescue Interrupt => e
+      error "\n[command canceled]"
+    end
+
+  end
+end

data/lib/evernotable/command/auth.rb

@@ -0,0 +1,33 @@
+require "evernotable/command/base"
+
+class Evernotable::Command::Auth < Evernotable::Command::Base
+  
+  def login
+    user = [] << @highline.ask("Enter your Evernote username: ")
+    user << @highline.ask("Enter your Evernote password: ") { |q| q.echo = "*" }
+    authenticate_user(user)
+    write_to_file credentials_file, user.join('/')
+    display "You were successfully authenticated."
+  end
+  
+  def logout
+    if File.exist?(credentials_file)
+      File.delete(credentials_file)
+      display "You were successfully logged out."
+    else
+      output_with_bang "You are not logged in."
+    end
+  end
+  
+  def method_missing(method_name, *args)
+    case method_name
+    when :help then
+      display '--------------------------------------------'
+      display '# authenticate 
+      evernotable auth login
+      evernotable auth logout'
+      display '--------------------------------------------'
+    end
+  end
+  
+end

data/lib/evernotable/command/base.rb

@@ -0,0 +1,47 @@
+require "evernotable/command"
+require "evernotable/client/user"
+require "evernotable/client/note"
+require 'evernotable/utilities'
+
+class Evernotable::Command::Base
+  
+  include Evernotable::Utilities
+  
+  def initialize(params=[])
+    @config = YAML.load(File.read('lib/evernotable_config.yml'))
+    @args = params.map {|p| p.strip}
+    @highline = HighLine.new
+  end
+  
+  def authenticate_user(user=[])
+    user = read_from_file(credentials_file).split('/') if user.empty?
+    @user_client = Evernotable::Client::User.new({:user => user.first, :password => user.last, :config => @config})
+    begin
+      @user_client.authenticate
+    rescue Evernotable::Client::ClientException => ex
+      raise Evernotable::Command::CommandFailed, "Invalid Evernote credentials."
+    end
+  end
+  
+  def note_client
+    authenticate_user
+    Evernotable::Client::Note.new({:user_shard => @user_client.current_user.shardId, :client_token => @user_client.client_token, :config => @config})
+  end
+  
+  def invoke_client
+    begin
+      yield
+    rescue Evernotable::Client::ClientException => ex
+      raise Evernotable::Command::CommandFailed, "Oops. That didn't work."
+    end
+  end
+  
+  def method_missing(method_name, *args)
+  end
+  
+  protected
+  
+  def credentials_file
+    @config["credentials_file"]["path"]
+  end
+end

data/lib/evernotable/command/help.rb

@@ -0,0 +1,24 @@
+require "evernotable/command/base"
+
+class Evernotable::Command::Help < Evernotable::Command::Base
+  
+  def method_missing(method_name, *args)
+    case method_name
+    when :help then
+      display 'Evernotable is a simple commandline task/todo manager that uses Evernote note store.'
+      display 'This automatically creates a new distinct Evernote notebook for persistance of tasks. Users can add new tasks, list them and remove existing tasks after authenticating using their Evernote credentials.'
+      display '--------------------------------------------'
+      display '# authenticate 
+      evernotable auth login
+      evernotable auth logout'
+      display '# add a new task
+      evernotable task add shave my beard!'
+      display '# list all existing tasks
+      evernotable task list'
+      display '# remove an existing task
+      evernotable task remove #2 => removes task listed #2'
+      display '--------------------------------------------'
+    end
+  end
+  
+end

data/lib/evernotable/command/task.rb

@@ -0,0 +1,39 @@
+require "evernotable/command/base"
+
+class Evernotable::Command::Task < Evernotable::Command::Base
+  
+  def add
+    invoke_client do
+      note_client.add_note(@args.first)
+      display 'Done.'
+    end
+  end
+
+  def list
+    invoke_client do
+      notes = note_client.list_notes
+      notes.collect{|n| n.title}.each_with_index{|n, i| display "#{i+1}. #{n}"}
+    end
+  end
+
+  def remove
+    invoke_client do
+      note_client.remove_note(@args.first)
+      display 'Done.'
+    end
+  end
+
+  def method_missing(method_name, *args)
+    case method_name
+    when :help then
+      display '--------------------------------------------'
+      display '# add a new task
+      evernotable task add shave my beard!'
+      display '# list all existing tasks
+      evernotable task list'
+      display '# remove an existing task
+      evernotable task remove #2 => removes task listed #2'
+      display '--------------------------------------------'
+    end
+  end
+end

data/lib/evernotable/utilities.rb

@@ -0,0 +1,48 @@
+require 'encrypted_strings'
+
+module Evernotable
+  module Utilities
+    
+    def format_with_bang(message)
+      return '' if message.to_s.strip == ""
+      "! " + message.split("\n").join("\n ! ")
+    end
+
+    def output_with_bang(message="", new_line=true)
+      return if message.to_s.strip == ""
+      display(format_with_bang(message), new_line)
+    end
+
+    def display(msg="", new_line=true)
+      if new_line
+        STDOUT.puts(msg)
+      else
+        STDOUT.print(msg)
+        STDOUT.flush
+      end
+    end
+    
+    def error(msg)
+      STDERR.puts(format_with_bang(msg))
+      exit(1)
+    end
+    
+    def wrap_enml(content)
+      "<?xml version='1.0' encoding='UTF-8'?><!DOCTYPE en-note SYSTEM 'http://xml.evernote.com/pub/enml2.dtd'><en-note>#{content}</en-note>"
+    end
+    
+    def write_to_file(file, content)
+      File.open(file, 'w') {|f| f.write(content.encrypt(:symmetric, :password => encrypt_key))}
+    end
+    
+    def read_from_file(file)
+      File.exist?(file) ? File.read(file).decrypt(:symmetric, :password => encrypt_key) : '' 
+    end
+    
+    def encrypt_key
+      config = YAML.load(File.read('lib/evernotable_config.yml'))
+      return config["encryption"]["key"]
+    end
+    
+  end
+end

data/lib/evernotable/version.rb

@@ -0,0 +1,3 @@
+module Evernotable
+  VERSION = "1.0.0"
+end

data/lib/evernotable_config.yml

@@ -0,0 +1,17 @@
+api_credentials:
+    consumer_key: kswamin
+    consumer_secret: dbd87f40e8507b16
+user_api: 
+    sandbox: https://sandbox.evernote.com/edam/user
+    production: https://www.evernote.com/edam/user
+note_api:
+    sandbox: http://sandbox.evernote.com/edam/note/
+    production: http://www.evernote.com/edam/note/
+notebook: 
+    name: evernotable
+credentials_file: 
+    path: /tmp/evernotable
+encryption:
+    key: 'evern0te'
+    
+    

data/spec/client/base_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'evernotable/client/base'
+
+describe Evernotable::Client::Base do
+  before(:all) do
+    @config = YAML.load(File.read('lib/evernotable_config.yml'))
+  end
+  
+  it 'should appropriately be initialized' do
+    base_client = Evernotable::Client::Base.new({:config => @config})
+    base_client.should_not be_nil
+    base_client.current_user.should be_nil
+    base_client.config.should_not be_nil
+    base_client.config["api_credentials"]["consumer_key"].should == 'kswamin'
+    base_client.config["api_credentials"]["consumer_secret"].should == 'dbd87f40e8507b16'
+  end
+end

data/spec/client/note_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'evernotable/client/note'
+
+describe Evernotable::Client::Note do
+
+  before(:all) do
+    @config = YAML.load(File.read('lib/evernotable_config.yml'))
+    @user_client = Evernotable::Client::User.new({:user => 'kswamin', :password => 'dumbass', :config => @config})
+    @user_client.authenticate
+    @note_client = Evernotable::Client::Note.new({:user_shard => @user_client.current_user.shardId, :client_token => @user_client.client_token, :config => @config})
+    #@note_client.expunge_notebook #TODO: doesn't work for some weird reason, investigate
+  end
+
+  it 'should appropriately be initialized' do
+    @note_client.should_not be_nil
+    @note_client.config.should_not be_nil
+    @note_client.notebook_guid.should be_nil
+  end
+
+  it 'should add a new notebook successfully' do
+    lambda { @note_client.add_notebook }.should_not raise_error
+    @note_client.notebook_guid.should_not be_nil
+  end
+
+  it 'should list notebooks successfully' do
+    list = []
+    lambda {list = @note_client.list_notebooks}.should_not raise_error
+    list.size.should == 2
+    list.collect {|n| n.name}.include?('evernotable').should be_true
+  end
+
+  it 'should check if the notebook exists?' do
+    @note_client.notebook_exists?.should be_true
+  end
+
+  it 'should add a note successfully' do
+    notes = nil
+    lambda {notes = @note_client.list_notes}.should_not raise_error
+    notes.size.should == 0
+    lambda { @note_client.add_note('note 1') }.should_not raise_error
+    lambda { @note_client.add_note('note 2') }.should_not raise_error
+    lambda { @note_client.add_note('note 3') }.should_not raise_error
+    lambda {notes = @note_client.list_notes}.should_not raise_error
+    notes.size.should == 3
+  end
+
+  it 'should list notes successfully' do
+    notes = nil
+    lambda {notes = @note_client.list_notes}.should_not raise_error
+    notes.size.should == 3
+    notes.collect{|n| n.title}.should == ['note 1', 'note 2', 'note 3']
+  end
+
+  it 'should remove a note successfully' do
+    note = nil
+    lambda { note = @note_client.add_note('note 4') }.should_not raise_error
+    count = @note_client.list_notes.size
+    count.should == 4
+    lambda { @note_client.remove_note(note.guid) }.should_not raise_error
+    count = @note_client.list_notes.size
+    count.should == 3
+  end
+  
+end

data/spec/client/user_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+require 'evernotable/client/user'
+
+describe Evernotable::Client::User do
+  
+  before(:all) do
+    @config = YAML.load(File.read('lib/evernotable_config.yml'))
+  end
+  
+  it 'should appropriately be initialized' do
+    user_client = Evernotable::Client::User.new({:user => 'kswamin', :password => 'dumbass', :config => @config})
+    user_client.should_not be_nil
+    user_client.config.should_not be_nil
+  end
+  
+  describe '#authenticate' do
+    it 'should authenticate the user successfully' do
+      user_client = Evernotable::Client::User.new({:user => 'kswamin', :password => 'dumbass', :config => @config})
+      user_client.should_not be_nil
+      user_client.authenticate
+      user_client.current_user.should_not be_nil
+      user_client.client_token.should_not be_nil
+    end 
+    it 'should not authenticate the user successfully' do
+      user_client = Evernotable::Client::User.new({:user => 'kswamin', :password => 'thewrongpassword', :config => @config})
+      user_client.should_not be_nil
+      lambda { user_client.authenticate }.should raise_error(Evernotable::Client::ClientException)
+      user_client.current_user.should be_nil
+      user_client.client_token.should be_nil
+    end
+  end
+  
+  describe '#refresh authentication' do
+    before(:all) do
+      @user_client = Evernotable::Client::User.new({:user => 'kswamin', :password => 'dumbass', :config => @config})
+      @user_client.authenticate
+    end
+    it 'should refresh the authentication for the user successfully' do
+      prev_token = @user_client.client_token
+      @user_client.refresh_authentication
+      @user_client.client_token.should_not be_nil
+      new_token = @user_client.client_token
+      prev_token.should_not == new_token
+    end
+  end
+  
+  describe '#check valid version' do
+    before(:all) do
+      @user_client = Evernotable::Client::User.new({:user => 'kswamin', :password => 'dumbass', :config => @config})
+    end
+    it 'should check if the version is valid' do
+      @user_client.valid_version?.should be_true
+    end
+  end
+  
+end

data/spec/command/auth_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+require 'evernotable/command/auth'
+
+describe Evernotable::Command::Auth do
+  it 'displays relevant information when help is invoked' do 
+    auth_command = Evernotable::Command::Auth.new
+    auth_command.should_not be_nil
+    STDOUT.should_receive(:puts).exactly(3).times.with(any_args())
+    lambda {auth_command.send(:help)}.should_not raise_error(Evernotable::Command::CommandFailed)
+  end
+  
+  describe '#login' do
+    pending 'TODO: fix auth login specs'
+    # it 'should log the user in successfully using user input' do
+    #   user_mock = mock("Evernotable::Client::User")
+    #   Evernotable::Client::User.stub(:new).and_return(user_mock)
+    #   user_mock.stub!(:read_from_file).and_return(nil)
+    #   highline = mock("HighLine")
+    #   HighLine.stub(:new).and_return(highline)
+    #   highline.stub!(:ask).and_return('kswamin', 'dumbass') 
+    #   user_mock.stub!(:authenticate).and_return(true)
+    #   user_mock.stub!(:write_to_file).and_return(true)
+    #   STDOUT.should_receive(:puts).exactly(1).times.with('You were successfully authenticated.')
+    #   auth_command = Evernotable::Command::Auth.new
+    #   lambda {auth_command.send(:login)}.should_not raise_error(Evernotable::Command::CommandFailed)
+    # end
+
+    # it 'should fail authenticating the user' do
+    #   user_mock = mock("Evernotable::Client::User")
+    #   Evernotable::Client::User.stub(:new).and_return(user_mock)
+    #   File.stub!(:exist?).and_return(true)
+    #   File.stub!(:read).and_return('kswamin/wrongpass')
+    #   user_mock.stub!(:authenticate).and_raise(Evernotable::Client::ClientException)
+    #   auth_command = Evernotable::Command::Auth.new
+    #   lambda {auth_command.send(:login)}.should raise_error(Evernotable::Command::CommandFailed)
+    # end
+  end
+  
+  describe '#logout' do
+    it 'should log the user out successfully' do
+      File.stub!(:exist?).and_return(true)
+      File.stub!(:delete).and_return(true)
+      STDOUT.should_receive(:puts).exactly(1).times.with('You were successfully logged out.')
+      auth_command = Evernotable::Command::Auth.new
+      lambda {auth_command.send(:logout)}.should_not raise_error(Evernotable::Command::CommandFailed)
+    end
+    
+    it 'should not log out if the user is not logged in already' do
+      File.stub!(:exist?).and_return(false)
+      STDOUT.should_receive(:puts).exactly(1).times.with(any_args())
+      auth_command = Evernotable::Command::Auth.new
+      lambda {auth_command.send(:logout)}.should_not raise_error(Evernotable::Command::CommandFailed)
+    end
+  end
+end

data/spec/command/base_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'evernotable/command/base'
+
+describe Evernotable::Command::Base do
+  it 'should appropriately be initialized' do
+    base_command = Evernotable::Command::Base.new(['remove', '2'])
+    base_command.should_not be_nil
+  end
+  
+  it 'should log the user in successfully using user input' do
+    user_mock = mock("Evernotable::Client::User")
+    Evernotable::Client::User.stub(:new).and_return(user_mock)
+    user_mock.stub!(:authenticate).and_return(true)
+    base_command = Evernotable::Command::Base.new
+    lambda {base_command.authenticate_user(['kswamin', 'dumbass'])}.should_not raise_error(Evernotable::Command::CommandFailed)
+  end
+
+  it 'should fail authenticating the user' do
+    user_mock = mock("Evernotable::Client::User")
+    Evernotable::Client::User.stub(:new).and_return(user_mock)
+    user_mock.stub!(:authenticate).and_raise(Evernotable::Client::ClientException)
+    base_command = Evernotable::Command::Base.new
+    lambda {base_command.authenticate_user(['kswamin', 'wrongpass'])}.should raise_error(Evernotable::Command::CommandFailed)
+  end
+  
+  describe '#invoke client' do
+    it 'should invoke the client method without exceptions' do
+      base_command = Evernotable::Command::Base.new
+      base_command.invoke_client do
+        true
+      end.should_not raise_error(Evernotable::Command::CommandFailed)
+    end
+    
+    it 'should invoke the client method resulting in exception' do
+      base_command = Evernotable::Command::Base.new
+      lambda do
+        base_command.invoke_client do
+          raise Evernotable::Client::ClientException
+        end
+      end.should raise_error(Evernotable::Command::CommandFailed)
+    end
+  end
+end

data/spec/command/help_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+require 'evernotable/command/help'
+
+describe Evernotable::Command::Help do
+  it 'displays useful information when help is invoked' do 
+    help_command = Evernotable::Command::Help.new
+    help_command.should_not be_nil
+    STDOUT.should_receive(:puts).with(/Evernotable is a simple commandline/)
+    STDOUT.should_receive(:puts).with(/This automatically creates/)
+    lambda {help_command.send(:help)}.should_not raise_error(Evernotable::Command::CommandFailed)
+  end
+end

data/spec/command/task_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'evernotable/command/task'
+
+describe Evernotable::Command::Task do
+  before(:all) do
+    @task_command = Evernotable::Command::Task.new(['dude!'])
+  end
+  
+  it 'displays relevant information when help is invoked' do 
+    @task_command.should_not be_nil
+    STDOUT.should_receive(:puts).exactly(5).times.with(any_args())
+    lambda {@task_command.send(:help)}.should_not raise_error(Evernotable::Command::CommandFailed)
+  end
+  
+  it 'should add note successfully' do
+    mock_note_client = mock('Evernotable::Client::Note')
+    mock_note_client.stub!(:add_note).and_return(true)
+    @task_command.stub!(:note_client).and_return(mock_note_client)
+    STDOUT.should_receive(:puts).exactly(1).times.with('Done.')
+    lambda {@task_command.add}.should_not raise_error(Evernotable::Command::CommandFailed)
+  end
+  
+  it 'should list notes successfully' do
+    mock_note_client = mock('Evernotable::Client::Note')
+    mock_note_client.stub!(:list_notes).and_return(['note1', 'note2'])
+    @task_command.stub!(:note_client).and_return(mock_note_client)
+    lambda {@task_command.list}.should_not raise_error(Evernotable::Command::CommandFailed)
+  end
+  
+  it 'should remove note successfully' do
+    mock_note_client = mock('Evernotable::Client::Note')
+    mock_note_client.stub!(:remove_note).and_return(true)
+    @task_command.stub!(:note_client).and_return(mock_note_client)
+    STDOUT.should_receive(:puts).exactly(1).times.with('Done.')
+    lambda {@task_command.remove}.should_not raise_error(Evernotable::Command::CommandFailed)
+  end
+end

data/spec/command_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+require 'evernotable/command'
+
+describe Evernotable::Command do
+  before(:all) do
+    Evernotable::Command.load
+  end
+
+  it 'should raise command failed error' do
+    begin
+      raise Evernotable::Command::CommandFailed, 'testing commandfailed'
+    rescue Evernotable::Command::CommandFailed => ex
+      ex.message.should == 'testing commandfailed'
+      ex.is_a?(Evernotable::Command::CommandFailed).should be_true
+    end
+  end
+
+  it 'should load all the commands successfully' do
+    Evernotable::Command::Base.should_not be_nil
+    Evernotable::Command::Auth.should_not be_nil
+    Evernotable::Command::Task.should_not be_nil
+  end
+
+  it 'should build the list of commands available' do
+    Evernotable::Command.commands.should =~ ['auth', 'base', 'task', 'help']
+  end
+
+  it 'should test valid' do
+    Evernotable::Command.valid?('auth').should be_true
+    Evernotable::Command.valid?('task').should be_true
+    Evernotable::Command.valid?('wrong-one').should be_false
+  end
+
+  describe '#run' do
+    it 'should display errors and exit on invalid command' do
+      STDOUT.should_receive(:puts).with("! *uncommand* is not a valid evernotable command.")
+      STDOUT.should_receive(:puts).with("! Use *evernotable help* for additional information.")
+      lambda { Evernotable::Command.run('uncommand') }.should raise_error(SystemExit)
+    end
+    it 'should display error and exit on blank command' do
+      STDOUT.should_receive(:puts).with("! Use *evernotable help* for additional information.")
+      lambda { Evernotable::Command.run('') }.should raise_error(SystemExit)
+    end
+    it 'should display error and exit on nil command' do
+      STDOUT.should_receive(:puts).with("! Use *evernotable help* for additional information.")
+      lambda { Evernotable::Command.run(nil) }.should raise_error(SystemExit)
+    end
+    it 'should instantiate the right command and invoke the appropriate method on it' do
+      auth_mock = mock("Evernotable::Command::Auth")
+      task_mock = mock("Evernotable::Command::Task")
+      help_mock = mock("Evernotable::Command::Help")
+      Evernotable::Command::Auth.stub(:new).and_return(auth_mock)
+      Evernotable::Command::Task.stub(:new).and_return(task_mock)
+      Evernotable::Command::Help.stub(:new).and_return(help_mock)
+      auth_mock.should_receive(:login).with(no_args())
+      auth_mock.should_receive(:logout).with(no_args())
+      lambda { Evernotable::Command.run('auth', ['login']) }.should_not raise_error(SystemExit)
+      lambda { Evernotable::Command.run('auth', ['logout']) }.should_not raise_error(SystemExit)
+      task_mock.should_receive(:add)
+      task_mock.should_receive(:remove)
+      task_mock.should_receive(:help)
+      help_mock.should_receive(:help)
+      lambda { Evernotable::Command.run('task', ['add', 'do this right away!']) }.should_not raise_error(SystemExit)
+      lambda { Evernotable::Command.run('task', ['remove', '3']) }.should_not raise_error(SystemExit)
+      lambda { Evernotable::Command.run('task') }.should_not raise_error(SystemExit)
+      lambda { Evernotable::Command.run('help') }.should_not raise_error(SystemExit)
+    end
+  end
+end

data/spec/display_matcher.rb

@@ -0,0 +1,48 @@
+module DisplayMatcher
+
+  def display_message(command, message)
+    DisplayMessageMatcher::DisplayMessage.new command, message
+  end
+
+  class DisplayMessage
+    def initialize(command, message)
+      @command = command
+      @message = message
+    end
+
+    def matches?(given_proc)
+      displayed_expected_message = false
+      @given_messages = []
+
+      @command.should_receive(:display).
+        any_number_of_times do |message, newline|
+        @given_messages << message
+        displayed_expected_message = displayed_expected_message ||
+          message == @message
+      end
+
+      given_proc.call
+      displayed_expected_message
+    end
+
+    def failure_message
+      "expected #{ @command } to display the message #{ @message.inspect } but #{ given_messages }"
+    end
+
+    def negative_failure_message
+      "expected #{ @command } to not display the message #{ @message.inspect } but it was displayed"
+    end
+
+    private
+
+    def given_messages
+      if @given_messages.empty?
+        'no messages were displayed'
+      else
+        formatted_given_messages = @given_messages.map(&:inspect).join ', '
+        "the following messages were displayed: #{ formatted_given_messages }"
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+$stdin = File.new("/dev/null")
+
+require "rubygems"
+require "bundler/setup"
+require "rspec"
+require 'highline'
+require "display_matcher"
+
+def fail_command(message)
+  raise_error(Evernotable::Command::CommandFailed, message)
+end
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.include DisplayMatcher
+end

data/spec/utilities_spec.rb

@@ -0,0 +1,39 @@
+require 'evernotable/utilities'
+
+describe Evernotable::Utilities do
+  include Evernotable::Utilities
+  it 'should test format message with bang' do
+    format_with_bang('').should == ''
+    format_with_bang('hello there').should == '! hello there'
+    format_with_bang("hello there\nWhats up?").should == "! hello there\n ! Whats up?"
+  end
+  
+  it 'should test display message' do
+    STDOUT.should_receive(:puts).with("hello there")
+    display('hello there', true)
+    STDOUT.should_receive(:print).with("hello there")
+    display('hello there', false)
+  end
+  
+  it 'should test output with bang' do
+    STDOUT.should_receive(:puts).with("! hello there is a problem")
+    output_with_bang('hello there is a problem')
+    STDOUT.should_receive(:print).with("! hello there")
+    output_with_bang('hello there', false)
+  end
+  
+  it 'should test error display' do
+    STDERR.should_receive(:puts).with('')
+    lambda {error(nil)}.should raise_error(SystemExit)
+    STDERR.should_receive(:puts).with("! error thrown")
+    lambda {error('error thrown')}.should raise_error(SystemExit)
+  end
+  
+  it 'should wrap enml content around a string' do
+    wrap_enml('test').should == "<?xml version='1.0' encoding='UTF-8'?><!DOCTYPE en-note SYSTEM 'http://xml.evernote.com/pub/enml2.dtd'><en-note>test</en-note>"
+  end
+  
+  it 'should return encrypt_key' do
+    encrypt_key.should_not be_nil
+  end
+end

data/spec/version_spec.rb

@@ -0,0 +1,8 @@
+require "spec_helper"
+require "evernotable/version"
+
+describe Evernotable do
+  it 'returns the correct version of the gem' do
+    Evernotable::VERSION.should == '1.0.0'
+  end
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: evernotable
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Karthik Muthupalaniappan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-29 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: thrift
+  requirement: &70349991702640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70349991702640
+- !ruby/object:Gem::Dependency
+  name: thrift_client
+  requirement: &70349991702220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70349991702220
+- !ruby/object:Gem::Dependency
+  name: evernote
+  requirement: &70349991701800 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70349991701800
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: &70349991701380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70349991701380
+- !ruby/object:Gem::Dependency
+  name: encrypted_strings
+  requirement: &70349991700960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70349991700960
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70349991700540 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70349991700540
+description: A simple commandline task manager that uses Evernote note store. This
+  automatically creates a new distinct Evernote notebook for persistance of these
+  task notes.
+email:
+- karthik.m@imaginea.com
+executables:
+- evernotable
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- bin/evernotable
+- evernotable.gemspec
+- lib/evernotable.rb
+- lib/evernotable/cli.rb
+- lib/evernotable/client.rb
+- lib/evernotable/client/base.rb
+- lib/evernotable/client/note.rb
+- lib/evernotable/client/user.rb
+- lib/evernotable/command.rb
+- lib/evernotable/command/auth.rb
+- lib/evernotable/command/base.rb
+- lib/evernotable/command/help.rb
+- lib/evernotable/command/task.rb
+- lib/evernotable/utilities.rb
+- lib/evernotable/version.rb
+- lib/evernotable_config.yml
+- spec/client/base_spec.rb
+- spec/client/note_spec.rb
+- spec/client/user_spec.rb
+- spec/command/auth_spec.rb
+- spec/command/base_spec.rb
+- spec/command/help_spec.rb
+- spec/command/task_spec.rb
+- spec/command_spec.rb
+- spec/display_matcher.rb
+- spec/spec_helper.rb
+- spec/utilities_spec.rb
+- spec/version_spec.rb
+homepage: http://intellisenze.wordpress.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: evernotable
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A simple commandline task manager that uses Evernote note store
+test_files:
+- spec/client/base_spec.rb
+- spec/client/note_spec.rb
+- spec/client/user_spec.rb
+- spec/command/auth_spec.rb
+- spec/command/base_spec.rb
+- spec/command/help_spec.rb
+- spec/command/task_spec.rb
+- spec/command_spec.rb
+- spec/display_matcher.rb
+- spec/spec_helper.rb
+- spec/utilities_spec.rb
+- spec/version_spec.rb