fuzzy_notes 0.0.6 → 0.0.7

data/bin/fnote

@@ -16,12 +16,14 @@ optparse = OptionParser.new do |opts|
 
   opts.on("-c", "--config [CONFIG]", "Specify config file") { |opt| options[:config] = opt}
   opts.on("-p", "--print", "Dump matching notes to stdout") { |opt| options[:print] = true }
-  opts.on("-l", "--list", "List statistics for matching notes") { |opt| options[:list] = true }
-  opts.on("-i", "--info", "Alias for 'list'") { |opt| options[:info] = true }
+  opts.on("-l", "--list", "List matching notes") { |opt| options[:list] = true }
+  opts.on("-i", "--info", "Show statistics for matching notes") { |opt| options[:info] = true }
   opts.on("-s", "--search", "Perform a full text search when matching notes") { |opt| options[:search] = true }
   opts.on("-v", "--verbose", "Enable debug output") { |opt| options[:verbose] = true }
   opts.on("-e", "--encrypt", "Encrypt matching notes") { |opt| options[:encrypt] = true }
   opts.on("-d", "--decrypt", "Decrypt matching notes") { |opt| options[:decrypt] = true }
+  opts.on("-n", "--no-color", "Turn off ANSI color") { |opt| options[:color] = false}
+  opts.on("-u", "--evernote-update", "Synchronize evernote directory") { |opt| options[:evernote_update] = true }
   opts.on("-h", "--help", "Show this message") { 
     puts opts 
     exit
@@ -47,23 +49,25 @@ end
 # fetch config 
 #
 config_path = \
-  options[:config] && File.exists?(options[:config]) && options[:config] ||
+  File.exists?(options[:config].to_s) && options[:config] ||
   File.exists?(CONFIG_PATH) && CONFIG_PATH
 
 config = config_path ? YAML::load_file(config_path) : {}
-puts "Warning: config file not found, using defaults" if config.empty?
+log.info("config file not found, using defaults") if config.empty?
 
-# find matching notes
-# 
 notes = FuzzyNotes::Notes.new(:editor => config[:editor],
                               :note_paths => config[:note_paths], 
+                              :evernote_params => config[:evernote],
                               :full_text_search => options[:search] || config[:full_text_search],
-                              :log_level => (options[:verbose] || config[:verbose]) ? 0 : 1,
+                              :log_level => (options[:verbose] || config[:verbose]) ? :debug : :info,
+                              :color => (options[:color] == false || config[:color] == false) ? false : true,
                               :keywords => ARGV)
                              
-# perform action on matching notes 
-# 
-if options[:list] || options[:info]
+notes.evernote_sync if options[:evernote_update]
+
+if options[:list]
+  notes.list
+elsif options[:info]
   notes.info
 elsif options[:print]
   notes.cat

data/lib/fuzzy_notes/cipher.rb

@@ -2,6 +2,7 @@ require 'gibberish'
 
 class FuzzyNotes::Cipher
   include FuzzyNotes::Logger
+  include FuzzyNotes::PasswordProtected
 
   PLAINTEXT_EXT  = 'txt'
   CIPHERTEXT_EXT = 'enc'
@@ -43,10 +44,10 @@ private
     dirname  = File.dirname(path)
     filename = File.basename(path, '.*')
 
-    log.debug "writing #{decrypt? ? 'un' : ''}encrypted content to: #{dirname}/#{filename}.#{extension}"
+    log.info "#{Colors::CREATE} writing #{decrypt? ? 'un' : ''}encrypted file: #{Colors::PATH} #{dirname}/#{filename}.#{extension}"
     File.open("#{dirname}/#{filename}.#{extension}", 'w') { |f| f << contents }
 
-    log.debug "deleting #{decrypt? ? '' : 'un'}encrypted file: #{path}"
+    log.info "#{Colors::DELETE} deleting #{decrypt? ? '' : 'un'}encrypted file: #{Colors::PATH} #{path}"
     File.delete(path)
   end
 
@@ -58,12 +59,4 @@ private
     @action == :dec
   end
 
-  def get_password
-    printf 'Enter password (will not be shown):'
-    `stty -echo`; password = STDIN.gets.strip;`stty echo`; puts "\n\n"
-    log.debug "entered password: #{password.inspect}"
-    password
-  end
-
-
 end

data/lib/fuzzy_notes/evernote_sync.rb

@@ -1,23 +1,127 @@
 require 'evernote'
-user_store_url = 'https://sandbox.evernote.com/edam/user'
-
-config = {
-  :username => 'rut216',
-  :password => 'password',
-  :consumer_key => 'rut216',
-  :consumer_secret => '160988912605c36c' }
-
-user_store = Evernote::UserStore.new(user_store_url, config)
-auth_result = user_store.authenticate
-user = auth_result.user
-@token = auth_result.authenticationToken
-puts "Authentication was successful for #{user.username}"
-puts "Authentication token = #{@token}"
-
-note_store_url = "http://sandbox.evernote.com/edam/note/#{user.shardId}"
-@note_store = Evernote::NoteStore.new(note_store_url)
-
-#notebooks = note_store.listNotebooks(auth_token)
-#puts "Found #{notebooks.size} notebooks:"
-#default_notebook = notebooks[0]
-#notebooks.each { |notebook| puts "  * #{notebook.name}"}
+require 'fileutils'
+require 'sanitize'
+require 'digest/md5'
+
+class FuzzyNotes::EvernoteSync
+  include FuzzyNotes::Logger
+  include FuzzyNotes::PasswordProtected
+
+USER_STORE_URL = 'https://evernote.com/edam/user'
+NOTE_STORE_URL = 'http://evernote.com/edam/note'
+NOTE_EXT = 'html'
+MAX_NOTES = 1000
+
+  # opts should be a hash with the following keys:
+  # :username, :password, :consumer_key, :consumer_secret
+  #
+  def initialize(params = {})
+    params.merge!(:password => get_password)
+    user_store = Evernote::UserStore.new(USER_STORE_URL, params)
+    begin
+      auth_result = user_store.authenticate
+    rescue Evernote::UserStore::AuthenticationFailure
+      log.error "Evernote authentication failed for #{Colors::USER} #{params[:username]}"
+      return
+    end
+
+    @path = params[:note_path]
+    user = auth_result.user
+    @token = auth_result.authenticationToken
+    note_store_url = "#{NOTE_STORE_URL}/#{user.shardId}"
+    @note_store = Evernote::NoteStore.new(note_store_url)
+    log.info "Evernote authentication was successful for #{Colors::USER} #{params[:username]}"
+  end
+
+  def sync
+    return unless authenticated?
+    unless File.directory?(@path)
+      log.error("#{@path}' is not a directory!")
+      return 
+    end
+
+    log.info "synchronizing with Evernote account..."
+    log.indent(2) do
+      # create notebook directories
+      fetch_notebooks.each do |notebook|
+        notebook_path = get_notebook_path(notebook[:name])
+        FileUtils.mkdir(notebook_path) unless File.exists?(notebook_path)
+
+        # write notes to files
+        notebook[:notes].each do |note|
+          note_path = get_note_path(notebook_path, note[:title])
+          File.open(note_path, 'w') { |f| f << note[:content] }
+        end
+      end
+    end
+  end
+
+  def self.sanitize_evernote(path)
+    html = File.read(path)
+    Sanitize.clean(html)
+  end
+
+private
+
+  def fetch_notebooks
+    notebooks = @note_store.listNotebooks(@token) || []
+    log.info "checking for updates..."
+    log.indent(2) do
+      notebooks.map { |notebook| { :name => notebook.name, 
+                                   :guid => notebook.guid, 
+                                   :notes => fetch_notes(:name => notebook.name, :guid => notebook.guid) } }
+    end
+  end
+
+  def fetch_notes(notebook_params)
+    filter = Evernote::EDAM::NoteStore::NoteFilter.new 
+    filter.notebookGuid = notebook_params[:guid]
+    notes = @note_store.findNotes(@token, filter, nil, MAX_NOTES).notes || []
+    log.indent(2) do
+      notes.inject([]) do |notes, note| 
+        if needs_update?(notebook_params[:name], note)
+          notes << { :title => note.title, :guid => note.guid, :content => fetch_note_content(note.guid) }
+        else
+          notes
+        end
+      end
+    end
+  end
+
+  def fetch_note_content(note_guid)
+    note = @note_store.getNote(@token, note_guid, true, nil, nil, nil)
+    log.info "updating note #{Colors::NOTE} #{note.title} #{Colors::DEFAULT} with content length #{Colors::NUMBER} #{note.contentLength}"
+    note.content
+  end
+
+  def needs_update?(notebook_name, note)
+    local_note_path = get_note_path(get_notebook_path(notebook_name), note.title)
+    return true unless File.exists?(local_note_path)
+
+    evernote_hash = note.contentHash
+    local_note_hash = Digest::MD5.digest(File.read(local_note_path))
+    log.debug "evernote_hash: #{evernote_hash}"
+    log.debug "local_hash: #{local_note_hash}"
+    return evernote_hash != local_note_hash 
+  end
+
+  def get_notebook_path(notebook_name)
+   "#{@path}/#{sanitize_filename(notebook_name)}"
+  end
+
+  def get_note_path(notebook_path, note_title)
+    "#{notebook_path}/#{sanitize_filename(note_title)}.#{NOTE_EXT}" 
+  end
+
+  def authenticated?
+    !@token.nil?
+  end
+
+  def sanitize_filename(filename)
+    name = filename.strip
+    name.gsub!(/[^0-9A-Za-z-]/, '_')
+    name.gsub!(/_+/, '_')
+    name
+  end
+
+end

data/lib/fuzzy_notes/logger.rb

@@ -5,8 +5,9 @@ class FuzzyNotes::Log
   LOG_LEVEL = 1
   
 
-  def self.init_log(log_level)
+  def self.init_log(log_level, color)
     @log = BufferedLogger.new(STDOUT, log_level || LOG_LEVEL, default_format)
+    log.disable_color unless color
   end
 
   def self.log
@@ -16,16 +17,25 @@ class FuzzyNotes::Log
 private
   
   def self.default_format
-    { :debug => "$negative DEBUG: $white %s",
-      :info  => "$green INFO: $white %s",
-      :warn  => "$yellow WARNING: $white %s",
-      :error => "$red ERROR: $white %s" }
+    { :debug => "$negative DEBUG: $reset %s",
+      :warn  => "$yellow WARNING: $reset %s",
+      :error => "$red ERROR: $reset %s" }
   end
 
 end
 
 
 module FuzzyNotes::Logger
+  module Colors
+    PATH = "$blue"
+    USER = "$green"
+    NOTE = "$cyan"
+    NUMBER = "$red"
+    CREATE = "$green"
+    DELETE = "$red"
+    DEFAULT = "$reset"
+  end
+
   def log
     FuzzyNotes::Log.log
   end

data/lib/fuzzy_notes/notes.rb

@@ -2,22 +2,26 @@ class FuzzyNotes::Notes
   include FuzzyNotes::Logger
 
 module Defaults
-  LOG_LEVEL = 1
-  EDITOR='vim'
-  NOTE_PATHS=[ "#{ENV['HOME']}/notes" ]
-  VALID_EXTENSIONS=%w( txt enc )
-  KEYWORDS = []
+  LOG_LEVEL   = 1
+  EDITOR      = 'vim'
+  COLOR       = true
+  KEYWORDS    = []
+  NOTE_PATHS  = [ "#{ENV['HOME']}/notes" ]
+  VALID_EXTENSIONS = [ 'txt', 
+                       FuzzyNotes::Cipher::CIPHERTEXT_EXT, 
+                       FuzzyNotes::Cipher::PLAINTEXT_EXT, 
+                       FuzzyNotes::EvernoteSync::NOTE_EXT ]
 
   def self.const_missing(*args); end
 end
 
-  OPTS = [:log_level, :editor, :note_paths, :valid_extensions, :keywords].freeze
+  OPTS = [:log_level, :color, :editor, :note_paths, :valid_extensions, :keywords, :evernote_params].freeze
 
   attr_reader :matching_notes, :all_notes
 
   def initialize(params = {})
     parse_init_params(params)
-    FuzzyNotes::Log.init_log(@log_level)
+    FuzzyNotes::Log.init_log(@log_level, @color)
     log.debug "init attributes: \n#{inspect_instance_vars}"
 
     unless note_paths_valid?
@@ -39,7 +43,7 @@ end
       klass = self.class
       klass.send(:attr_reader, param)
       default_const = param.to_s.upcase
-      instance_variable_set("@#{param}", params[param] || Defaults.const_get(default_const) )
+      instance_variable_set("@#{param}", params.include?(param) ? params[param] : Defaults.const_get(default_const) )
     end
   end
   private :parse_init_params
@@ -50,14 +54,18 @@ end
     matching_notes.each do |note_path|
       contents = \
         if encrypted?(note_path)
-          puts "decrypting #{note_path}"
+          log.info "decrypting note #{Colors::PATH} #{note_path}"
           FuzzyNotes::Cipher.new.decrypt(note_path)
+        elsif evernote?(note_path)
+          FuzzyNotes::EvernoteSync.sanitize_evernote(note_path)
         else
           File.read(note_path)
         end
 
-      puts "=== #{note_path} ===\n\n"
-      puts "#{contents}\n"
+      unless contents.blank?
+        log.info "=== #{note_path} ===\n\n"
+        puts "#{contents}\n"
+      end
     end
   end
 
@@ -70,13 +78,19 @@ end
   # encrypt matching notes 
   #
   def encrypt
-    FuzzyNotes::Cipher.new.encrypt(matching_notes, :replace => true)
+    return if matching_notes.empty?
+    log.info "encrypting matching notes:"
+    print_notes
+    log.indent(2) { FuzzyNotes::Cipher.new.encrypt(matching_notes, :replace => true) }
   end
 
   # decrypt matching notes
   #
   def decrypt
-    FuzzyNotes::Cipher.new.decrypt(matching_notes, :replace => true)
+    return if matching_notes.empty?
+    log.info "decrypting matching notes:"
+    print_notes
+    log.indent(2) { FuzzyNotes::Cipher.new.decrypt(matching_notes, :replace => true) }
   end
 
   # view WC info for all/matching notes
@@ -86,11 +100,26 @@ end
     puts `wc $(find #{paths} -type f)` 
   end
 
+  def list
+    print_notes(:all => true)
+  end
+
+  def evernote_sync
+    unless @evernote_params
+      log.error("no evernote configuration found!")
+      return
+    end
+
+    log.info "syncing evernote directory #{Colors::PATH} #{@evernote_params[:note_path]}"
+    FuzzyNotes::EvernoteSync.new(@evernote_params).sync
+    log.print_blank_line
+  end
+
 private
 
   def note_paths_valid?
     @note_paths.any? do |p| 
-      File.exists?(p) || log.info("Warning: note path '#{p}' not found")
+      File.directory?(p) || log.warn("note path #{Colors::PATH} #{p} does not exist")
     end
   end
 
@@ -108,5 +137,13 @@ private
     File.extname(path)[1..-1] == FuzzyNotes::Cipher::CIPHERTEXT_EXT
   end
 
+  def evernote?(path)
+    File.extname(path)[1..-1] == FuzzyNotes::EvernoteSync::NOTE_EXT
+  end
+
+  def print_notes(params = {})
+    notes = (matching_notes.empty? && params[:all]) ? all_notes : matching_notes
+    log.indent(2) { notes.each { |note| log.info "#{Colors::PATH} #{note}" } }
+  end
 
 end

data/lib/fuzzy_notes/password_protected.rb

@@ -0,0 +1,10 @@
+module FuzzyNotes::PasswordProtected
+
+  def get_password
+    printf 'Enter password (will not be shown):'
+    `stty -echo`; password = STDIN.gets.strip;`stty echo`; puts
+    log.debug "entered password: #{password.inspect}"
+    password
+  end
+
+end

data/lib/fuzzy_notes.rb

@@ -1,8 +1,11 @@
+require 'pp'
 require 'rubygems'
 
 module FuzzyNotes; end
 
 require 'fuzzy_notes/logger'
+require 'fuzzy_notes/password_protected'
 require 'fuzzy_notes/cipher'
-require 'fuzzy_notes/notes'
+require 'fuzzy_notes/evernote_sync'
 require 'fuzzy_notes/fuzzy_finder'
+require 'fuzzy_notes/notes'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: fuzzy_notes
 version: !ruby/object:Gem::Version 
-  hash: 19
+  hash: 17
   prerelease: 
   segments: 
   - 0
   - 0
-  - 6
-  version: 0.0.6
+  - 7
+  version: 0.0.7
 platform: ruby
 authors: 
 - Alex Skryl
@@ -15,25 +15,27 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-25 00:00:00 -05:00
+date: 2011-07-26 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: gibberish
+  name: buffered_logger
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 31
         segments: 
         - 0
-        version: "0"
+        - 1
+        - 2
+        version: 0.1.2
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: buffered_logger
+  name: gibberish
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
@@ -46,7 +48,35 @@ dependencies:
         version: "0"
   type: :runtime
   version_requirements: *id002
-description: A note manager with fuzzy search, full text search, evernote support, and encryption capabilities
+- !ruby/object:Gem::Dependency 
+  name: evernote
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: sanitize
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+description: A note manager with fuzzy path search, full text search, evernote sync, and encryption capabilities
 email: rut216@gmail.com
 executables: 
 - fnote
@@ -60,6 +90,7 @@ files:
 - lib/fuzzy_notes/fuzzy_finder.rb
 - lib/fuzzy_notes/logger.rb
 - lib/fuzzy_notes/notes.rb
+- lib/fuzzy_notes/password_protected.rb
 - lib/fuzzy_notes.rb
 - bin/fnote
 - README
@@ -97,6 +128,6 @@ rubyforge_project:
 rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
-summary: A plain text note manager
+summary: A cli note manager
 test_files: []