fuzzy_notes 0.1.1 → 0.1.2

data/TODO

@@ -1,3 +1,8 @@
 TODO
+- README
+- ask for missing params during evernote AUTH
+- debugging output
+- figure out good output spacing
 - test suite
 - 1.9 testing
+- add a per-note password option for enc/dec

data/bin/fnote

@@ -9,36 +9,38 @@ require 'rubygems'
 require 'fuzzy_notes'
 
 CONFIG_PATH = "#{ENV['HOME']}/.fuzzy_notes"
+OPT_ACTIONS = [:print, :list, :info, :encrypt, :decrypt, :update_evernotes].freeze
+OPT_KEYWORDS_REQUIRED = [:print, :edit, :encrypt, :decrypt].freeze
 
 options = {}
 optparse = OptionParser.new do |opts|
   opts.banner = "Usage: fnote [options] [keyword1, keyword2...]"
 
   opts.on("-c", "--config [CONFIG]", "Specify config file") { |opt| options[:config] = opt}
+  opts.on("-n", "--note-path [PATH]", "Specify config file") { |opt| options[:note_path] = opt}
+  opts.on("--editor [EDITOR]", "Editor of choice") { |opt| options[:editor] = opt}
+  opts.on("-s", "--search", "Perform a full text search when matching notes") { |opt| options[:search] = true}
   opts.on("-p", "--print", "Dump matching notes to stdout") { |opt| options[:print] = true }
-  opts.on("-l", "--list", "List matching notes") { |opt| options[:list] = true }
+  opts.on("-l", "--list", "List all or 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") { 
+  opts.on("-v", "--verbose", "Enable debug output") { |opt| options[:verbose] = true }
+  opts.on("--no-color", "Turn off ANSI color") { |opt| options[:no_color] = true}
+  opts.on("-u", "--update-evernotes", "Synchronize evernote directory") { |opt| options[:update_evernotes] = true }
+  opts.on("-h", "--help", "Show usage") { 
     puts opts 
     exit
   }
 end
 
-need_extra_args = [:print, :edit, :encrypt, :decrypt]
-
+# parse args
+#
 begin
   optparse.parse!(ARGV)                                                                                                                                                                                                 
-  # edit is the default action
-  options[:edit] = true if options.values.compact.empty?
-
+  options[:edit] = true if options.values_at(*OPT_ACTIONS).compact.empty?
   # check for required args
-  if need_extra_args.any? {|opt| options[opt]} && ARGV.empty?
+  if OPT_KEYWORDS_REQUIRED.any? {|opt| options[opt]} && ARGV.empty?
     puts optparse
     exit
   end
@@ -51,22 +53,25 @@ end
 config_path = \
   File.exists?(options[:config].to_s) && options[:config] ||
   File.exists?(CONFIG_PATH) && CONFIG_PATH
-
 config = config_path ? YAML::load_file(config_path) : {}
 log.info("config file not found, using defaults") if config.empty?
 
-notes = FuzzyNotes::Notes.new(:editor => config[:editor],
-                              :note_paths => config[:note_paths], 
+# grab notes
+# 
+notes = FuzzyNotes::Notes.new(:editor => options[:editor] || config[:editor],
+                              :note_paths => [options[:note_path] || config[:note_paths]].flatten, 
                               :evernote_params => config[:evernote],
                               :full_text_search => options[:search] || config[:full_text_search],
                               :log_level => (options[:verbose] || config[:verbose]) ? :debug : :info,
-                              :color => (options[:color] == false || config[:color] == false) ? false : true,
+                              :color => (options[:no_color] || config[:no_color]) ? false : true,
                               :keywords => ARGV)
                              
-notes.evernote_sync if options[:evernote_update]
-
+# perform action
+#
 if options[:list]
   notes.list
+elsif options[:update_evernotes]
+  notes.evernote_sync
 elsif options[:info]
   notes.info
 elsif options[:print]

data/lib/fuzzy_notes.rb

@@ -4,7 +4,7 @@ require 'rubygems'
 module FuzzyNotes; end
 
 require 'fuzzy_notes/logger'
-require 'fuzzy_notes/password_protected'
+require 'fuzzy_notes/authentication'
 require 'fuzzy_notes/cipher'
 require 'fuzzy_notes/evernote_sync'
 require 'fuzzy_notes/fuzzy_finder'

data/lib/fuzzy_notes/{password_protected.rb → authentication.rb}

@@ -1,4 +1,9 @@
-module FuzzyNotes::PasswordProtected
+module FuzzyNotes::Authentication
+  
+  def get_username
+    printf 'Enter username: '
+    gets
+  end
 
   def get_password
     printf 'Enter password (will not be shown):'

data/lib/fuzzy_notes/cipher.rb

@@ -2,48 +2,63 @@ require 'gibberish'
 
 class FuzzyNotes::Cipher
   include FuzzyNotes::Logger
-  include FuzzyNotes::PasswordProtected
+  include FuzzyNotes::Authentication
 
   PLAINTEXT_EXT  = 'txt'
   CIPHERTEXT_EXT = 'enc'
+  TMP_FILE_PREFIX = 'fuzzy_notes'
+  ENCRYPT_METHOD_MATCHER = /\Aencrypt_(data|file|files|from_tempfile|from_tempfiles)\Z/
+  DECRYPT_METHOD_MATCHER = /\Adecrypt_(data|file|files|to_tempfile|to_tempfiles)\Z/
 
-  def encrypt(file_paths, opts = {})
-    @action = :enc
-    apply_cipher(file_paths, opts)
-  end
+private
+
+  def method_missing(method_sym, *args)
+    method_name = method_sym.to_s
+    log.debug "args: #{args.inspect}"
+    last_arg = args.last
+    opts = last_arg.is_a?(Hash) ? last_arg : {}
+
+    case method_name
+    when ENCRYPT_METHOD_MATCHER
+      @action = :enc
+    when DECRYPT_METHOD_MATCHER
+      @action = :dec
+    else super
+    end
 
-  def decrypt(file_paths, opts = {})
-    @action = :dec
-    apply_cipher(file_paths, opts)
+    case $1
+    when 'data'
+      process_data(args.first, Gibberish::AES.new(get_password))
+    when 'file'
+      process_file(args.first, Gibberish::AES.new(get_password), opts)
+    when 'files'
+      cipher = Gibberish::AES.new(get_password)
+      args.first.map { |path| process_file(path, cipher, opts) }
+    when 'to_tempfile', 'from_tempfile'
+      self.send(method_sym, args.first, Gibberish::AES.new(get_password))
+    when 'to_tempfiles', 'from_tempfiles'
+      cipher = Gibberish::AES.new(get_password)
+      args.first.map { |file_path| self.send(method_name[0..-2], *file_path, cipher) }
+    end
   end
 
-private
+  def process_file(path, cipher, opts = {}) 
+    return unless path && valid_filename?(path)
+    content = File.read(path)
+    return unless valid_content?(content)
+    log.info "#{decrypt? ? 'de' : 'en'}crypting file #{PATH_COLOR} #{path}"
 
-  def apply_cipher(file_paths, opts)
-    cipher = Gibberish::AES.new(get_password)
-    case file_paths
-    when Array
-      file_paths.each do |path| 
-        if encrypt? && self.class.encrypted?(path) ||
-           decrypt? && !self.class.encrypted?(path)
-          log.warn "#{Colors::PATH} #{path} #{Colors::DEFAULT} is #{encrypt? ? 'already' : 'not'} encrypted, skipping"
-          next
-        end
-        process_file(path, cipher, opts)
-      end
-    when String
-      process_file(file_paths, cipher, opts)
-    end
+    processed_content = process_data(content, cipher)
+    replace_file!(path, processed_content) if processed_content && opts[:replace]
+    processed_content
   end
 
-  def process_file(path, cipher, opts) 
+  def process_data(data, cipher)
     begin
-      log.debug "#{@action} '#{path}'"
-      content = cipher.send(@action, File.read(path))
-      replace_file!(path, content) if opts[:replace] 
-      content
+      cipher.send(@action, data) unless data.blank?
     rescue OpenSSL::Cipher::CipherError => e
       log.error e
+      nil
     end
   end
 
@@ -51,13 +66,49 @@ private
     dirname  = File.dirname(path)
     filename = File.basename(path, '.*')
 
-    log.info "#{Colors::CREATE} writing #{decrypt? ? 'un' : ''}encrypted file: #{Colors::PATH} #{dirname}/#{filename}.#{extension}"
+    log.info "#{CREATE_COLOR} writing #{decrypt? ? 'un' : ''}encrypted file: #{PATH_COLOR} #{dirname}/#{filename}.#{extension}"
     File.open("#{dirname}/#{filename}.#{extension}", 'w') { |f| f << contents }
 
-    log.info "#{Colors::DELETE} deleting #{decrypt? ? '' : 'un'}encrypted file: #{Colors::PATH} #{path}"
+    log.info "#{DELETE_COLOR} deleting #{decrypt? ? '' : 'un'}encrypted file: #{PATH_COLOR} #{path}"
     File.delete(path)
   end
 
+  def decrypt_to_tempfile(file_path, cipher)
+    return unless file_path
+    content = process_file(file_path, cipher)
+    content && Tempfile.open(TMP_FILE_PREFIX) do |tmp_file|
+      tmp_file << content
+      tmp_file.path
+    end
+  end
+
+  def encrypt_from_tempfile(tmp_file, file_path, cipher)
+    return unless tmp_file && file_path
+    content = File.read(tmp_file)
+    return unless valid_content?(content)
+
+    log.info "#{CREATE_COLOR} writing encrypted file: #{PATH_COLOR} #{file_path}"
+    File.open(file_path, 'w') do |file|
+      file << process_data(content, cipher)
+    end
+  end
+
+  def valid_filename?(path)
+    if encrypt? && self.class.encrypted?(path) || decrypt? && !self.class.encrypted?(path)
+      log.warn "#{PATH_COLOR} #{path} #{DEFAULT_COLOR} is #{encrypt? ? 'already' : 'not'} encrypted, skipping"
+      return false
+    end
+    true
+  end
+
+  def valid_content?(content)
+    if content.blank?
+      log.warn "file is empty, skipping"
+      return false
+    end
+    true
+  end
+
   def extension
     decrypt? ? PLAINTEXT_EXT : CIPHERTEXT_EXT
   end
@@ -74,5 +125,4 @@ private
     File.extname(path)[1..-1] == CIPHERTEXT_EXT
   end
 
-
 end

data/lib/fuzzy_notes/evernote_sync.rb

@@ -6,13 +6,12 @@ require 'ostruct'
 
 class FuzzyNotes::EvernoteSync
   include FuzzyNotes::Logger
-  include Colors
-  include FuzzyNotes::PasswordProtected
+  include FuzzyNotes::Authentication
 
-USER_STORE_URL = 'https://evernote.com/edam/user'
-NOTE_STORE_URL = 'http://evernote.com/edam/note'
-NOTE_EXT = 'html'
-MAX_NOTES = 1000
+  USER_STORE_URL = 'http://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
@@ -26,16 +25,17 @@ MAX_NOTES = 1000
 
   def sync
     return unless authenticated? && valid_sync_path?
-    log.info "#{IMPORT} synchronizing with Evernote account..."
-    log.indent(2) { log.info "#{IMPORT} checking for updates..." }
+    log.info "syncing evernote directory #{PATH_COLOR} #{@path}"
+    log.info "#{IMPORT_COLOR} synchronizing with Evernote account..."
+    log.indent(2) { log.info "#{IMPORT_COLOR} checking for updates..." }
     log.indent(4) do
       notebook_structs = fetch_notebooks
-      log.info "#{IMPORT} syncing Evernote deletions..."
+      log.info "#{IMPORT_COLOR} syncing Evernote deletions..."
       log.indent(2) do
         propagate_evernote_deletions(notebook_structs)
       end
       notebook_structs.each do |notebook_struct|
-        log.info "#{IMPORT} syncing notebook #{NOTE} #{notebook_struct.name}"
+        log.info "#{IMPORT_COLOR} syncing notebook #{NOTE_COLOR} #{notebook_struct.name}"
         log.indent(2) do
           create_local_notebook(notebook_struct)
           sync_notes(notebook_struct)
@@ -75,26 +75,33 @@ private
   def propagate_evernote_deletions(notebook_structs)
     evernote_dir_entries = Dir["#{@path}/*"]
     evernote_dir_entries.each do |notebook_path|
-      notebook_name = File.basename(notebook_path)
-      notebook_match = notebook_structs.find { |ns| sanitize_filename(ns.name) == notebook_name }  
+      notebook_match = notebook_structs.find { |ns| sanitize_filename(ns.name) == File.basename(notebook_path) }  
       unless notebook_match
-        log.info "#{DELETE} notebook #{NOTE} #{notebook_name} #{DELETE} has been deleted from Evernote"
-        verify_deletion(notebook_path)
+        delete_notebook!(notebook_path)
       else
         note_entries = Dir["#{notebook_path}/*"]
         note_entries.each do |note_path|
-          note_title = File.basename(note_path, '.*')
-          unless notebook_match.notes.any? { |n| sanitize_filename(n.title) == note_title }
-            log.info "#{DELETE} note #{NOTE} #{note_title} #{DELETE} has been deleted from Evernote"
-            verify_deletion(note_path)
+          unless notebook_match.notes.any? { |n| sanitize_filename(n.title) == File.basename(note_path, '.*') }
+            delete_note!(note_path)
           end
         end
       end
     end
   end
 
+  def delete_notebook!(notebook_path)
+    log.info "#{DELETE_COLOR} notebook #{NOTE_COLOR} #{File.basename(notebook_path)} #{DELETE_COLOR} has been deleted from Evernote"
+    verify_deletion(notebook_path)
+  end
+
+  def delete_note!(note_path)
+    log.info "#{DELETE_COLOR} note #{NOTE_COLOR} #{File.basename(note_path, '.*')} #{DELETE_COLOR} has been deleted from Evernote"
+    verify_deletion(note_path)
+  end
+
   def sync_notes(notebook_struct)
-    note_updates = notebook_struct.notes.inject([[],[]]) do |(import, export), note| 
+    note_updates = \
+      notebook_struct.notes.inject([[],[]]) do |(import, export), note| 
       if needs_import?(notebook_struct, note)
         import << fetch_note_with_content(note)
       elsif needs_export?(notebook_struct, note)
@@ -109,7 +116,7 @@ private
   def import_notes(notebook_struct, notes)
     notes.each do |note|
       note_path = get_note_path(notebook_struct, note)
-      log.info "#{IMPORT} importing note #{NOTE} #{note.title} #{DEFAULT} with content length #{NUMBER} #{note.contentLength}"
+      log.info "#{IMPORT_COLOR} importing note #{NOTE_COLOR} #{note.title} #{DEFAULT_COLOR} with content length #{NUMBER_COLOR} #{note.contentLength}"
       File.open(note_path, 'w') { |f| f << note.content }
     end
   end
@@ -117,7 +124,7 @@ private
   def export_notes(notebook_struct, notes)
     notes.each do |note|
       note.content = local_note_content(notebook_struct, note)
-      log.info "#{EXPORT} exporting note #{NOTE} #{note.title} #{DEFAULT} with content length #{NUMBER} #{note.content.length}"
+      log.info "#{EXPORT_COLOR} exporting note #{NOTE_COLOR} #{note.title} #{DEFAULT_COLOR} with content length #{NUMBER_COLOR} #{note.content.length}"
       begin
         @note_store.updateNote(@token, note)
       rescue Evernote::EDAM::Error::EDAMUserException => e
@@ -194,7 +201,7 @@ private
   def verify_deletion(path)
     r = nil
     until r =~ /(Y|y|N|n)/ do
-      printf "Are you sure you want to delete #{path}? (Y/N) "
+      log.info "Are you sure you want to delete #{path}? (Y/N) "
       r = gets
     end
 
@@ -210,18 +217,23 @@ private
     name
   end
 
+  def self.evernote?(path)
+    File.extname(path)[1..-1] == NOTE_EXT
+  end
+
 # authentication helpers
 
+  #TODO: ask for all missing params
   def authenticate(params)
     params.merge!(:password => get_password)
     user_store = Evernote::UserStore.new(USER_STORE_URL, params)
     begin
-      user_store.authenticate
+      token = user_store.authenticate
+      log.info "Evernote authentication was successful for #{USER_COLOR} #{params[:username]}"
+      token
     rescue Evernote::UserStore::AuthenticationFailure
-      log.error "Evernote authentication failed for #{USER} #{params[:username]}"
+      log.error "Evernote authentication failed for #{USER_COLOR} #{params[:username]}"
       return
-    ensure
-      log.info "Evernote authentication was successful for #{USER} #{params[:username]}"
     end
   end
 

data/lib/fuzzy_notes/fuzzy_finder.rb

@@ -3,7 +3,7 @@ require 'find'
 class FuzzyNotes::FuzzyFinder
   include FuzzyNotes::Logger
 
-  attr_reader :path, :all_files, :matching_files, :keywords, :extensions, :full_text_search
+  attr_reader :path, :all_files, :files_matching_extension, :files_matching_all, :keywords, :extensions, :full_text_search
 
   def initialize(path, params = {})
     @path = path
@@ -16,9 +16,12 @@ class FuzzyNotes::FuzzyFinder
   def refresh
     clear_results
     Find.find(*@path) do |file_path| 
-      if !File.directory?(file_path) && extension_match?(file_path)
-        @all_files << file_path
-        @matching_files << file_path if file_match_proc.call(file_path)
+      if !File.directory?(file_path) 
+         @all_files << file_path 
+        if extension_match?(file_path)
+          @files_matching_extension << file_path
+          @files_matching_all << file_path if file_match_proc.call(file_path)
+        end
       end
     end
   end
@@ -26,11 +29,7 @@ class FuzzyNotes::FuzzyFinder
 private
 
   def clear_results
-    @all_files, @matching_files = [], []
-  end
-
-  def file_match_proc
-    method(@search_type ? :full_text_match? : :file_name_match?)
+    @all_files, @files_matching_extension, @files_matching_all = [], [], []
   end
 
   def extension_match?(file_path)
@@ -38,17 +37,27 @@ private
     !@extensions || @extensions.any? {|ext| /\.#{ext}$/ === file_name }
   end
 
+  def file_match_proc
+    method(@search_type ? :full_text_match? : :file_name_match?)
+  end
+
+# search procs
+
   def file_name_match?(file_path)
-    @keywords ? @keywords.any? { |name| /#{name}/ === file_path } : false
+    @keywords ? @keywords.any? { |keyword| /#{keyword}/ === file_path } : false
   end
 
   def full_text_match?(file_path)
-    if @keywords && !@keywords.empty?
+    unless @keywords.blank? || encrypted_file?(file_path)
       file_contents = File.read(file_path)
       @keywords.any? { |key| /#{key}/m === file_contents }
     else false 
     end
   end
 
+  def encrypted_file?(path)
+    /\.#{FuzzyNotes::Cipher::CIPHERTEXT_EXT}$/ === path
+  end
+
 
 end

data/lib/fuzzy_notes/logger.rb

@@ -27,16 +27,17 @@ end
 
 module FuzzyNotes::Logger
   module Colors
-    PATH = "$blue"
-    USER = "$green"
-    NOTE = "$cyan"
-    NUMBER = "$red"
-    CREATE = "$green"
-    DELETE = "$red"
-    IMPORT = "$green"
-    EXPORT = "$red"
-    DEFAULT = "$reset"
+    PATH_COLOR = "$blue"
+    USER_COLOR = "$green"
+    NOTE_COLOR = "$cyan"
+    NUMBER_COLOR = "$red"
+    CREATE_COLOR = "$green"
+    DELETE_COLOR = "$red"
+    IMPORT_COLOR = "$green"
+    EXPORT_COLOR = "$red"
+    DEFAULT_COLOR = "$reset"
   end
+  include Colors
 
   def log
     FuzzyNotes::Log.log

data/lib/fuzzy_notes/notes.rb

@@ -1,10 +1,11 @@
+require 'tempfile'
+
 class FuzzyNotes::Notes
   include FuzzyNotes::Logger
 
 module Defaults
-  LOG_LEVEL   = 1
+  LOG_LEVEL   = :info
   EDITOR      = 'vim'
-  COLOR       = true
   KEYWORDS    = []
   NOTE_PATHS  = [ "#{ENV['HOME']}/notes" ]
   VALID_EXTENSIONS = [ 'txt', 
@@ -15,54 +16,43 @@ module Defaults
   def self.const_missing(*args); end
 end
 
-  OPTS = [:log_level, :color, :editor, :note_paths, :valid_extensions, :keywords, :evernote_params].freeze
+  VALID_PARAMS = [: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, @color)
-    log.debug "init attributes: \n#{inspect_instance_vars}"
-
-    unless note_paths_valid?
-      log.error "no valid note paths found, exiting"
-      exit
-    end
+    log.debug "init params: \n#{inspect_instance_vars}"
+    @note_paths = prune_invalid_note_paths!
 
     finder = FuzzyNotes::FuzzyFinder.new(@note_paths, 
                                         { :keywords => @keywords, 
-                                          :extensions => @extensions, 
+                                          :extensions => @valid_extensions, 
                                           :full_text_search => params[:full_text_search] })
-    @all_notes, @matching_notes = finder.all_files, finder.matching_files
+    @all_notes, @matching_notes = finder.files_matching_extension, finder.files_matching_all
+    @cipher = FuzzyNotes::Cipher.new
   end
 
-  # initialize params or use defaults
-  #
-  def parse_init_params(params)
-    OPTS.each do |param|
-      klass = self.class
-      klass.send(:attr_reader, param)
-      default_const = param.to_s.upcase
-      instance_variable_set("@#{param}", params.include?(param) ? params[param] : Defaults.const_get(default_const) )
-    end
-  end
-  private :parse_init_params
-
   # dump all matching notes to stdout
   #
   def cat
+    unless encrypted_notes.empty?
+      print_notes(:encrypted => true)
+      decrypted_notes = @cipher.decrypt_files(encrypted_notes)
+    end
+
     matching_notes.each do |note_path|
       contents = \
         if FuzzyNotes::Cipher.encrypted?(note_path)
-          log.info "decrypting note #{Colors::PATH} #{note_path}"
-          FuzzyNotes::Cipher.new.decrypt(note_path)
-        elsif evernote?(note_path)
+          decrypted_notes.shift
+        elsif FuzzyNotes::EvernoteSync.evernote?(note_path)
           FuzzyNotes::EvernoteSync.sanitize_evernote(note_path)
         else
           File.read(note_path)
         end
 
-      unless contents.blank?
+      if contents
         log.info "=== #{note_path} ===\n\n"
         puts "#{contents}\n"
       end
@@ -72,74 +62,155 @@ end
   # edit all matching notes in EDITOR
   #
   def edit
-    exec("#{editor} #{bashify_paths(matching_notes)}") unless matching_notes.empty?
+    notes_to_edit = \
+      unless encrypted_notes.empty?
+        print_notes(:encrypted => true)
+        decrypted_tempfiles = @cipher.decrypt_to_tempfiles(encrypted_notes)
+        successfully_decrypted_files = decrypted_tempfiles.compact 
+        plaintext_notes + successfully_decrypted_files
+      else plaintext_notes
+      end
+
+    # edit decrypted files
+    unless notes_to_edit.empty?
+      system("#{editor} #{bashify_note_paths(notes_to_edit)}")
+    end
+
+    # reencrypt decrypted notes
+    unless encrypted_notes.empty? || successfully_decrypted_files.empty? 
+      log.info "#{CREATE_COLOR} re-encrypting edited notes:"
+      tempfiles_notes = decrypted_tempfiles.zip(encrypted_notes)
+      log.indent do
+        tempfiles_notes.each do |(tmpfile, note_path)|
+          log.info "#{PATH_COLOR} #{note_path}" if note_path
+        end
+      end
+      log.indent { @cipher.encrypt_from_tempfiles(tempfiles_notes) } 
+    end
   end
 
   # encrypt matching notes 
   #
   def encrypt
-    return if matching_notes.empty?
-    log.info "encrypting matching notes:"
-    print_notes
-    log.indent(2) { FuzzyNotes::Cipher.new.encrypt(matching_notes, :replace => true) }
+    return if plaintext_notes.empty?
+    print_notes(:plaintext => true)
+    log.indent do 
+      @cipher.encrypt_files(plaintext_notes, :replace => true)
+    end
   end
 
   # decrypt matching notes
   #
   def decrypt
-    return if matching_notes.empty?
-    log.info "decrypting matching notes:"
-    print_notes
-    log.indent(2) { FuzzyNotes::Cipher.new.decrypt(matching_notes, :replace => true) }
+    return if encrypted_notes.empty?
+    print_notes(:encrypted => true)
+    log.indent do
+      @cipher.decrypt_files(encrypted_notes, :replace => true)
+    end
   end
 
   # view WC info for all/matching notes
   #
   def info
-    paths = bashify_paths(matching_notes.empty? ? all_notes : matching_notes)
+    paths = bashify_note_paths(matching_notes(:all_if_empty => true))
     puts `wc $(find #{paths} -type f)` 
   end
 
   def list
-    print_notes(:all => true)
+    print_notes(:all_if_empty => 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]}"
+    return unless evernote_params_found?
     FuzzyNotes::EvernoteSync.new(@evernote_params).sync
-    log.print_blank_line
   end
 
 private
 
-  def note_paths_valid?
-    @note_paths.any? do |p| 
-      File.directory?(p) || log.warn("note path #{Colors::PATH} #{p} does not exist")
+  def encrypted_notes
+    @encrypted_notes ||= matching_notes.select { |note_path| FuzzyNotes::Cipher.encrypted?(note_path) }
+  end
+
+  def evernote_notes
+    @evernote_notes ||= matching_notes.select { |note_path| FuzzyNotes::EvernoteSync.evernote?(note_path) }
+  end
+
+  def plaintext_notes
+    @plaintext_notes ||= matching_notes.select { |note_path| !FuzzyNotes::Cipher.encrypted?(note_path) && 
+                                                             !FuzzyNotes::EvernoteSync.evernote?(note_path) }
+  end
+
+  def prune_invalid_note_paths!
+    valid_paths = []
+    @note_paths.each do |path| 
+      if File.directory?(path) 
+        valid_paths << path
+      else
+        log.warn("note path #{PATH_COLOR} #{path} #{DEFAULT_COLOR} does not exist")
+      end
     end
+    if valid_paths.empty?
+      log.error "no valid note paths found, exiting"
+      exit
+    end
+    valid_paths
   end
 
-  # bash style, space seperated fashion
+  # TODO: grab creds from user
+  def evernote_params_found?
+    unless @evernote_params
+      log.error("required evernote configuration not found!")
+      false
+    else true
+    end
+  end
+
+  # bash helpers
   #
-  def bashify_paths(paths)
+  def bashify_note_paths(paths)
     paths.map {|n| "\"#{n}\""}.join(' ')
   end
 
-  def inspect_instance_vars
-    instance_variables.inject("") { |s, ivar| s << "  #{ivar} => #{eval(ivar.to_s).inspect}\n" }
+  def print_notes(params = {})
+    notes = []
+    
+    notes << encrypted_notes if params[:encrypted]
+    notes << evernote_notes if params[:evernote]
+    notes << plaintext_notes if params[:plaintext]
+    if notes.empty?
+      notes << matching_notes(:all_if_empty => true)
+    end
+    
+    notes.flatten!
+    keys = params.keys.reject { |k| k == :all_if_empty }
+    log.info "#{keys.join(',')} notes:" unless keys.empty?
+    log.indent { notes.each { |note| log.info "#{PATH_COLOR} #{note}" } }
   end
 
-  def evernote?(path)
-    File.extname(path)[1..-1] == FuzzyNotes::EvernoteSync::NOTE_EXT
+  def matching_notes(params = {})
+    (@matching_notes.empty? && params[:all_if_empty]) ? @all_notes : @matching_notes
   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}" } }
+  # initialize to params or use defaults
+  #
+  def parse_init_params(params)
+    VALID_PARAMS.each do |param|
+      klass = self.class
+      klass.send(:attr_reader, param)
+      default_const = param.to_s.upcase
+
+      value = \
+        if params.include?(param) 
+          params[param] 
+        else Defaults.const_get(default_const)
+        end
+     instance_variable_set("@#{param}", value) 
+    end
   end
 
+  def inspect_instance_vars
+    instance_variables.inject("") { |s, ivar| s << "  #{ivar} => #{eval(ivar.to_s).inspect}\n" }
+  end
+
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fuzzy_notes
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-01 00:00:00.000000000Z
+date: 2011-09-26 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: buffered_logger
-  requirement: &70150343147260 !ruby/object:Gem::Requirement
+  requirement: &70119415052580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: 0.1.2
   type: :runtime
   prerelease: false
-  version_requirements: *70150343147260
+  version_requirements: *70119415052580
 - !ruby/object:Gem::Dependency
   name: gibberish
-  requirement: &70150343146760 !ruby/object:Gem::Requirement
+  requirement: &70119415052080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70150343146760
+  version_requirements: *70119415052080
 - !ruby/object:Gem::Dependency
   name: evernote
-  requirement: &70150343146280 !ruby/object:Gem::Requirement
+  requirement: &70119415051600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70150343146280
+  version_requirements: *70119415051600
 - !ruby/object:Gem::Dependency
   name: sanitize
-  requirement: &70150343145800 !ruby/object:Gem::Requirement
+  requirement: &70119415051120 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *70150343145800
+  version_requirements: *70119415051120
 description: A note manager with fuzzy path search, full text search, evernote sync,
   and encryption capabilities
 email: rut216@gmail.com
@@ -63,12 +63,12 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/fuzzy_notes/authentication.rb
 - lib/fuzzy_notes/cipher.rb
 - lib/fuzzy_notes/evernote_sync.rb
 - 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