rnote 0.0.1

data/lib/rnote/cmd/remove.rb

@@ -0,0 +1,38 @@
+
+require 'rnote/find'
+require 'highline/import'
+
+include GLI::App
+
+
+
+desc 'remove an item from evernote'
+arg_name 'Describe arguments to remove here'
+command :remove 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)
+      note = find.find_note(options.merge(global_options),args) 
+      
+      puts note.summarize
+      
+      answer = agree("Delete this note. Are you sure?  ")
+      if answer
+        $app.client.note_store.deleteNote(note.guid)
+      else
+        puts "Alright, delete cancelled."
+      end
+      
+    end
+    
+  end
+  
+  verb.default_command :note
+end
+
+

data/lib/rnote/cmd/show.rb

@@ -0,0 +1,37 @@
+
+require 'rnote/find'
+
+include GLI::App
+
+
+desc 'output notes to the console'
+command :show do |verb|
+
+  verb.desc 'find and output notes to the console'
+  verb.command :note do |noun|
+
+    Rnote::Find.include_search_options(noun)
+    
+    noun.desc 'include title in the output'
+    noun.default_value true
+    noun.switch :'include-title', :'inc-title'
+
+    noun.action do |global_options,options,args|
+
+      find = Rnote::Find.new($app.auth,$app.persister)
+      note = find.find_note(options.merge(global_options),args)
+      
+      content = note.txt_content
+      
+      puts note.title if options[:'include-title']
+      puts content
+
+    end
+
+  end
+  
+  verb.default_command :note
+end
+
+
+

data/lib/rnote/cmd/who.rb

@@ -0,0 +1,16 @@
+
+include GLI::App
+
+desc 'see which user you are logged in as'
+command :who do |c|
+  c.action do |global_options,options,args|
+    raise unless args.length == 0
+
+    if $app.auth.is_logged_in
+      puts $app.auth.who
+    else
+      puts 'You are not logged in as any user.'
+    end
+
+  end
+end

data/lib/rnote/converter.rb

@@ -0,0 +1,127 @@
+
+require 'nokogiri'
+require 'yaml'
+
+require 'evernote-thrift'
+
+module Evernote::EDAM::Error
+
+  # converting between text formats and enml
+  #
+  # we have two types of conversion
+  #
+  # simple,
+  # single document conversion.
+  # which is enml <=> markdown
+  #
+  # then our own additional wrappers we put on top of those 2 document types
+  # adding metadata to them.
+  # yaml_stream <=> notes attributes
+  # content is just considered an 'attribute' in the latter
+  #
+  # the yaml_stream is just a string
+  # the note attributes get its own class and thats where we stick the conversion routines.
+  
+  class InvalidFormatError < Exception
+  end
+  
+  class InvalidXmlError < InvalidFormatError
+    
+    attr_reader :xml
+    
+    def initialize(message, xml=nil)
+      @xml = xml
+      super(message)
+    end
+  end
+  
+  class InvalidMarkdownError < InvalidFormatError
+    def initialize(message, markdown=nil)
+      @markdown = markdown
+      super(message)
+    end
+  end
+  
+end
+  
+class Evernote::EDAM::Type::Note
+  
+  def self.enml_to_markdown(enml)
+    enml_to_txt(enml)
+  end
+
+  def self.markdown_to_enml(markdown)
+    txt_to_enml(markdown)
+  end
+  
+  def markdown_content=(markdown_content)
+    self.content = self.class.markdown_to_enml(markdown_content)
+  end
+  
+  def markdown_content
+    self.class.enml_to_markdown(content)
+  end
+  
+  def self.enml_to_txt(enml)
+    document =  Nokogiri::XML::Document.parse(enml)
+    raise Evernote::EDAM::Error::InvalidXmlError.new("invalid xml",enml) unless document.root
+    pre_node = document.root.xpath('pre').first
+    if pre_node
+      pre_node.children.to_ary.select { |child| child.text? }.map { |child| child.to_s }.join('')
+    else
+      document.root.xpath("//text()").text
+    end  
+  end
+  
+  def self.txt_to_enml(txt)
+    if txt.start_with? '<?xml'
+      raise Evernote::EDAM::Error::InvalidMarkdownError.new('given xml instead of txt')
+    end
+    <<EOF
+<?xml version='1.0' encoding='utf-8'?>
+<!DOCTYPE en-note SYSTEM "http://xml.evernote.com/pub/enml2.dtd">
+<en-note>
+<pre>#{txt}</pre>
+</en-note>
+EOF
+  end
+  
+  def txt_content=(txt_content)
+    self.content = self.class.txt_to_enml(txt_content)
+  end
+  
+  def txt_content
+    self.class.enml_to_txt(content)
+  end
+  
+  # The yaml stream is what we give to the user to edit in their editor
+  # 
+  # Its just a string, but its composed of 2 parts. the note attributes and the note content.
+  #
+  # 1. a small yaml document with the note attributes as a hash.
+  # 2. followed by the note content as markdown
+  def yaml_stream=(yaml_stream)
+
+    m = yaml_stream.match /^(---.+?---\n)(.*)$/m
+    raise "failed to parse yaml stream\n#{yaml_stream}" unless m
+
+    attributes_yaml = m[1]
+    markdown = m[2]
+
+    enml = self.class.txt_to_enml(markdown)
+    attributes_hash = YAML.load(attributes_yaml)
+
+    self.title = attributes_hash['title']
+    self.tagNames = attributes_hash['tagNames']
+    self.content = enml
+  end
+  
+  def yaml_stream
+    YAML.dump({ 'title' => title, 'tagNames' => tagNames }) + "\n---\n" + self.class.enml_to_txt(content)
+  end
+  
+  def summarize
+    self.txt_content[0..30]
+  end
+
+end

data/lib/rnote/edit.rb

@@ -0,0 +1,250 @@
+
+require 'highline'
+require 'nokogiri'
+
+class WaitPidTimeout
+  
+  # wait in ruby doesn't take a timeout parameter
+  # so, join with timeout => wait with timeout
+  # launch a thread that does a wait on the pid.
+  # then its just a matter of joining that thread, with a timeout.
+
+  def initialize(pid,timeout)
+    @pid = pid
+    @timeout = timeout
+  end
+
+  def wait
+
+    @thread ||= Thread.new(@pid) do |pid|
+      Process.waitpid(pid)
+    end
+
+    !!@thread.join(@timeout)
+
+  end
+
+end
+
+class Evernote::EDAM::Type::Note
+  
+  def diff(new_note)
+    # returns a Note that represents a diff of the 2, used for client.updateNote()
+    
+    raise "notes aren't copies of the same note" if self.guid != new_note.guid
+    
+    contains_diff = false
+    
+    diff_note = Evernote::EDAM::Type::Note.new
+    diff_note.guid = new_note.guid
+    
+    if self.title != new_note
+      contains_diff = true
+    end
+    # always contains a title
+    diff_note.title = new_note.title
+    
+    if self.content != new_note.content
+      contains_diff = true
+      diff_note.content = new_note.content
+    end
+    
+    if self.tagNames != new_note.tagNames
+      contains_diff = true
+      diff_note.tagNames = new_note.tagNames
+    end
+    
+    # we dont' diff tagGuids as we always want to modify tagNames instead.
+    # so that the evernote api will handle the tag creation and guids itself.
+    
+    contains_diff ? diff_note : nil
+  end
+  
+  def deep_dup
+    duplicate = self.dup
+    duplicate.tagNames = self.tagNames.dup if self.tagNames
+    duplicate.tagGuids = self.tagGuids.dup if self.tagGuids
+    
+    duplicate
+  end
+  
+end
+
+module Rnote
+
+  class Edit
+  
+    def initialize(auth)
+      @auth = auth
+      @note = Evernote::EDAM::Type::Note.new
+      @note.txt_content = '' # for creating new notes.
+      @last_saved_note = Evernote::EDAM::Type::Note.new
+    end
+  
+    def Edit.include_set_options(noun)
+      noun.desc 'set the title of the note'
+      noun.flag :'set-title'
+    end
+  
+    def Edit.include_editor_options(noun)
+      noun.desc 'watch the file while editing and upload changes (you must save the file)'
+      noun.default_value true
+      noun.switch :watch
+  
+      noun.desc 'open an interactive editor to modify the note'
+      noun.default_value true
+      noun.switch :editor
+    end
+  
+    def Edit.has_set_options(options)
+      options[:'set-title']
+    end
+    
+    def options(options)
+      @options = options
+      @use_editor = options[:editor]
+      @watch_editor = options[:watch]
+    end
+    
+    def note(note)
+      @note = note
+      @last_saved_note = note.deep_dup
+    end
+  
+    def edit_action
+      raise if not @note or not @last_saved_note
+  
+      if Edit.has_set_options(@options)
+  
+        apply_set_options
+  
+        if @use_editor
+          editor
+        else
+          # if not going to open an editor, then just update immediately
+          save_note
+        end
+  
+      elsif @use_editor
+        # no --set options
+        editor
+      else
+        raise "you've specified --no-editor but provided not --set options either."
+      end
+  
+    end
+  
+    def apply_set_options
+      if @options[:'set-title']
+        @note.title = @options[:'set-title']
+      end
+    end
+  
+    def save_note
+      
+      diff_note = @last_saved_note.diff(@note)
+  
+      # only update if necessary
+      if diff_note
+        
+        # create or update
+        if diff_note.guid
+          @auth.client.note_store.updateNote(diff_note)
+        else
+          raise "cannot create note with nil content" if diff_note.content.nil?
+          new_note = @auth.client.note_store.createNote(diff_note)
+          # a few things to copy over
+          @note.guid = new_note.guid
+        end
+        
+        # track what the last version we saved was. for diffing
+        @last_saved_note = @note.deep_dup
+      end
+  
+    end
+  
+    def editor
+  
+      ENV['EDITOR'] ||= 'vim'
+  
+      file = Tempfile.new(['rnote','md'])
+      begin
+  
+        # fill the tempfile with the yaml stream
+        yaml_stream = @note.yaml_stream
+        file.write(yaml_stream)
+        file.close()
+  
+        # error detection loop, to retry editing the file
+        successful_edit = false
+        until successful_edit do
+  
+          last_mtime = File.mtime(file.path)
+  
+          # run editor in background
+          pid = fork do
+            exec(ENV['EDITOR'],file.path)
+          end
+  
+          wwt = WaitPidTimeout.new(pid,1) # 1 second
+  
+          editor_done = false
+          until editor_done do
+            if not @watch_editor
+              Process.waitpid(pid)
+              editor_done = true
+            elsif wwt.wait
+              # process done
+              editor_done = true
+            else
+              # timeout exceeded
+  
+              # has the file changed?
+              this_mtime = File.mtime(file.path)
+              if this_mtime != last_mtime
+                # protect the running editor from our failures.
+                begin
+                  update_note_from_file(file.path)
+                rescue Exception => e
+                  $stderr.puts "rnote: an error occured while updating the note: #{e.message}"
+                end
+                last_mtime = this_mtime
+              end
+            end
+          end
+  
+          # one last update of the note
+          # this time we care if there are errors
+          begin
+            update_note_from_file(file.path)
+          rescue Exception => e
+  
+            puts "There was an error while uploading the note"
+            puts e.message
+            puts e.backtrace.join("\n    ")
+  
+            successful_edit = ! agree("Return to editor? (otherwise changes will be lost)  ")
+          else
+            successful_edit = true
+          end
+  
+        end # successful edit loop
+  
+      ensure
+        file.unlink
+      end
+  
+    end
+  
+    def update_note_from_file(path)
+      
+      yaml_stream = File.open(path,'r').read
+      @note.yaml_stream = yaml_stream
+      
+      save_note
+    end
+  
+  
+  end
+
+end