rnote 0.0.1

data/bin/rnote

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+require 'gli'
+require 'rnote'
+
+include GLI::App
+
+program_desc 'Evernote Command Line'
+
+# version Rnote::VERSION
+
+desc 'prompt for input and run an editor when necessary'
+default_value true
+switch :interactive
+
+pre do |global,command,options,args|
+  # Pre logic here
+  # Return true to proceed; false to abort and not call the
+  # chosen command
+  # Use skips_pre before a command to skip this block
+  # on that command only
+  true
+end
+
+post do |global,command,options,args|
+  # Post logic here
+  # Use skips_post before a command to skip this
+  # block on that command only
+end
+
+def error_code_to_name(error_code)
+  Evernote::EDAM::Error::EDAMErrorCode.constants.select { |constant| Evernote::EDAM::Error::EDAMErrorCode.const_get(constant) == error_code }.first.to_s
+end
+
+on_error do |exception|
+  # Error logic here
+  # return false to skip default error handling
+
+  if exception.instance_of?(Evernote::EDAM::Error::EDAMUserException)
+    if exception.errorCode == Evernote::EDAM::Error::EDAMErrorCode::AUTH_EXPIRED
+      puts "Authorization issue. perhaps your password is incorrect or expired."
+      false
+    else
+      puts exception.error_message
+      true
+    end
+  elsif exception.instance_of?(Evernote::EDAM::Error::EDAMSystemException)
+    puts exception.error_message
+    true
+  elsif exception.class == Evernote::EDAM::Error::InvalidXmlError
+    puts exception.xml
+    true
+  else
+    true
+  end
+
+end
+
+$app = Rnote::App.new
+
+exit run(ARGV)

data/lib/rnote.rb

@@ -0,0 +1,75 @@
+
+
+# environment detection
+begin
+  # this file only exists in development
+  # its not included in the gem, 
+  # and thus not found in production (the installed gem)
+  require_relative 'rnote/environment'
+rescue LoadError
+  # production environment
+  # should only happen in the installed gem.
+  RNOTE_HOME ||= ENV['HOME'] + '/.rnote' 
+  RNOTE_TESTING_OK = false
+  RNOTE_SANDBOX_ONLY = false
+end
+
+require 'rnote/version'
+require 'rnote/converter'
+require 'rnote/persister'
+require 'rnote/auth'
+
+# verbs
+Dir[File.absolute_path(File.dirname(__FILE__)) + '/rnote/cmd/*.rb'].each do |file|
+ require file
+end
+
+
+module Rnote
+
+  class App
+
+    attr_reader :persister,:auth
+
+    def initialize
+      @persister = Persister.new
+      @auth = Auth.new(@persister)
+    end
+
+    def client
+      auth.client
+    end
+
+  end
+
+end
+
+module EDAMErrors
+  
+  def error_code_string
+    Evernote::EDAM::Error::EDAMErrorCode.constants.select { |constant_sym|
+      Evernote::EDAM::Error::EDAMErrorCode.const_get(constant_sym) == self.errorCode
+    }.first.to_s
+  end
+  
+end
+
+class Evernote::EDAM::Error::EDAMSystemException
+  
+  include EDAMErrors
+  
+  def error_message
+    "#{self.error_code_string}(#{self.errorCode}: #{self.message})"
+  end
+  
+end
+
+class Evernote::EDAM::Error::EDAMUserException
+
+  include EDAMErrors
+ 
+  def error_message
+    "#{self.error_code_string}(#{self.errorCode}): #{self.parameter}"
+  end
+  
+end

data/lib/rnote/auth.rb

@@ -0,0 +1,130 @@
+
+require 'mechanize'
+require 'evernote_oauth'
+require 'rnote/persister'
+
+DUMMY_CALLBACK_URL = 'http://www.evernote.com'
+
+module Rnote
+
+  class Auth
+
+    def initialize(persister=Persister.new)
+      @persister = persister
+    end
+    
+    def login_with_developer_token(developer_token,sandbox)
+      if is_logged_in
+        if @persister.get_developer_token == developer_token
+          return
+        else
+          logout
+        end
+      end
+      @persister.persist_developer_token(developer_token)
+      @persister.persist_sandbox(sandbox)
+    end
+
+    def login_with_password(username,password,sandbox)
+      
+      if is_logged_in
+        if who == username
+          # already logged in (we don't check against service though)
+          # if a re-login is truely required, the user can just logout first.
+          return
+        else
+          logout
+        end
+      end
+      
+      ## Get a user key using these crednetials
+      
+      # this client isn't authorized, and can only request authorization. no api calls.
+      auth_client = EvernoteOAuth::Client.new(
+          consumer_key: @persister.get_consumer_key,
+          consumer_secret: @persister.get_consumer_secret,
+          sandbox: sandbox
+      )
+
+      request_token = auth_client.request_token(:oauth_callback => DUMMY_CALLBACK_URL)
+      oauth_verifier = mechanize_login(request_token.authorize_url, username, password)
+      access_token = request_token.get_access_token(oauth_verifier: oauth_verifier)
+      user_token = access_token.token
+
+      @persister.persist_username(username)
+      @persister.persist_user_token(user_token)
+      @persister.persist_sandbox(sandbox)
+
+    end
+
+    def client
+      # not the same as the client used to get the token.
+      # this one is fully authorized and can make actual api calls.
+
+      if not is_logged_in
+        raise "not logged in"
+      end
+      
+      token = @persister.get_user_token || @persister.get_developer_token
+      
+      @client ||= EvernoteOAuth::Client.new(token: token, sandbox: @persister.get_sandbox)
+
+      @client
+    end
+    
+    def note_store
+      client.note_store
+    end
+
+    def mechanize_login(url, username, password)
+
+      agent = Mechanize.new
+      login_page = agent.get(url)
+      login_form = login_page.form('login_form')
+      raise unless login_form
+      login_form.username = username
+      login_form.password = password
+      accept_page = agent.submit(login_form,login_form.buttons.first)
+
+      if accept_page.form('login_form')
+        # sent us back to the login page
+        raise "bad username/password"
+      elsif not accept_page.form('oauth_authorize_form')
+        raise "failed to login"
+      end
+
+      accept_form = accept_page.form('oauth_authorize_form')
+      # we don't need to go so far as to retrieve the callback url.
+      agent.redirect_ok = false
+      callback_redirect = agent.submit(accept_form, accept_form.buttons.first)
+      response_url = callback_redirect.response['location']
+      oauth_verifier = CGI.parse(URI.parse(response_url).query)['oauth_verifier'][0]
+
+      oauth_verifier
+    end
+
+    def is_logged_in
+      @persister.get_user_token or @persister.get_developer_token
+    end
+
+    def who
+      if is_logged_in
+        @persister.get_username or @persister.get_developer_token
+      else
+        nil
+      end
+    end
+
+
+    def logout
+      # unfortunately, no way to revoke a token via API
+      # TODO perhaps I can redo the oauth, and choose revoke instead of re-accept
+      @persister.forget_user_token
+      @persister.forget_username
+      @persister.forget_developer_token
+      @persister.forget_sandbox
+    end
+
+  end
+
+end

data/lib/rnote/cmd/create.rb

@@ -0,0 +1,32 @@
+
+require 'gli'
+
+require 'rnote/edit'
+
+include GLI::App
+
+
+desc 'create a note and launch the editor for it'
+command :create do |verb|
+  verb.command :note do |noun|
+
+
+    Rnote::Edit.include_set_options(noun)
+    Rnote::Edit.include_editor_options(noun)
+
+    noun.action do |global_options,options,args|
+
+      if args.length > 0
+        raise "create doesn't take a search query"
+      end
+
+      edit = Rnote::Edit.new($app.auth)
+      edit.options(options.merge(global_options))
+      edit.edit_action
+
+
+    end
+  end
+  
+  verb.default_command :note
+end

data/lib/rnote/cmd/edit.rb

@@ -0,0 +1,36 @@
+
+require 'rnote/edit'
+require 'rnote/find'
+
+include GLI::App
+
+
+desc 'Describe edit here'
+arg_name 'Describe arguments to edit here'
+command :edit do |verb|
+
+  verb.command :note do |noun|
+
+    Rnote::Edit.include_set_options(noun)
+    Rnote::Edit.include_editor_options(noun)
+    Rnote::Find.include_search_options(noun)
+
+    noun.action do |global_options,options,args|
+
+      find = Rnote::Find.new($app.auth,$app.persister)
+      note = find.find_note(options.merge(global_options),args)
+
+      edit = Rnote::Edit.new($app.auth)
+      edit.options(options.merge(global_options))
+      edit.note(note)
+      edit.edit_action
+
+    end
+
+  end
+  
+  verb.default_command :note
+
+end
+
+

data/lib/rnote/cmd/find.rb

@@ -0,0 +1,24 @@
+
+require 'rnote/find'
+
+include GLI::App
+
+
+desc 'search for notes/tags/notebooks'
+command :find do |verb|
+
+  verb.command :note do |noun|
+
+    Rnote::Find.include_search_options(noun)
+
+    noun.action do |global_options,options,args|
+      
+      find = Rnote::Find.new($app.auth,$app.persister)
+      find.find_cmd(options.merge(global_options),args)
+
+    end
+  end
+  
+  verb.default_command :note
+end
+

data/lib/rnote/cmd/login.rb

@@ -0,0 +1,68 @@
+
+require 'highline/import'
+
+include GLI::App
+
+desc 'provide rnote credentials'
+command :login do |c|
+  
+  c.desc "username"
+  c.flag [:u,:user,:username]
+  
+  c.desc "password (if not provided, will ask)"
+  c.flag [:p,:pass,:password]
+  
+  c.desc "developer token, if you wish to forgoe a password."
+  c.flag [:d,:'dev-token',:'developer-token']
+  
+  c.desc "use the sandbox environment in lue of the production evernote system."
+  c.default_value false
+  c.switch [:s,:sandbox]
+  
+  c.desc "provide a consumer key, instead of the included one."
+  c.flag [:k,:key,:'consumer-key']
+  
+  c.desc "provide a consumer secret to go along with the consumer key."
+  c.flag [:c,:secret,:'consumer-secret']
+  
+  c.action do |global_options,options,args|
+		raise "This command takes no arguments, only options (i.e. --username" unless args.length == 0
+
+    if options[:key]
+      $app.persister.persist_consumer_key(options[:key])
+    end
+    
+    if options[:secret]
+      $app.persister.persist_consumer_secret(options[:secret])
+    end
+    
+    if options[:d]
+      # first check for a dev token
+      $app.auth.login_with_developer_token(options[:d],options[:sandbox])
+      puts "login successful using developer key"
+    else
+      # then fall back to using a username and password
+      
+      if not options[:u]
+        answer = ask("Enter your username:  ")
+        options[:u] = answer
+      end
+  
+      if not options[:p]
+        answer = ask("Enter your password:  ") { |q| q.echo = 'x' }
+        options[:p] = answer
+      end
+  
+      $app.auth.login_with_password(options[:user],options[:password], options[:sandbox])
+      
+      # test the login with a harmless api call.
+      $app.auth.client.user_store.getUser
+      
+      puts "you are now logged in as '#{$app.auth.who}'"
+      
+    end
+
+  end
+end
+
+

data/lib/rnote/cmd/logout.rb

@@ -0,0 +1,24 @@
+
+include GLI::App
+
+=begin
+
+only drops the token.
+there is no way to ask evernote to revoke the token, from an api.
+
+will forget about the user,password or developer key.
+but won't forget about a consumer key, as that by itself is not considered a login.
+
+=end
+
+desc 'log user out of rnote'
+command :logout do |c|
+  c.action do |global_options,options,args|
+    raise unless args.length == 0
+
+    $app.auth.logout
+
+  end
+end
+
+