fuzzy_notes 0.0.3 → 0.0.5

data/TODO

@@ -1,3 +1,2 @@
 TODO
 -Evernote integration
--On the fly decryption/editing/re-encryption

data/lib/fuzzy_notes/cipher.rb

@@ -1,37 +1,69 @@
 require 'gibberish'
 
 class FuzzyNotes::Cipher
-  extend FuzzyNotes::Logger
-  private_class_method :new
-
-  def self.apply_cipher(file_paths, decrypt = false)
-    extension, action = decrypt ? ['.txt', :dec] : ['.enc', :enc]
-    password = get_password
-    cipher = Gibberish::AES.new(password)
-
-    file_paths.each do |path|
-      log.info "#{action} '#{path}'"
-      pathname = File.dirname(path)
-      filename = File.basename(path, '.*')
-
-      begin
-        ciphertext = cipher.send(action, File.read(path))
-        log.debug "writing #{decrypt ? 'un' : ''}encrypted content to: #{pathname}/#{filename}#{extension}"
-        File.open("#{pathname}/#{filename}#{extension}", 'w') { |f| f << ciphertext }
-        log.debug "deleting #{decrypt ? '' : 'un'}encrypted file: #{path}"
-        File.delete(path)
-      rescue OpenSSL::Cipher::CipherError => e
-        log.error e
-      end
+  include FuzzyNotes::Logger
+
+  PLAINTEXT_EXT  = 'txt'
+  CIPHERTEXT_EXT = 'enc'
+
+  def encrypt(file_paths, opts = {})
+    @action = :enc
+    apply_cipher(file_paths, opts)
+  end
+
+  def decrypt(file_paths, opts = {})
+    @action = :dec
+    apply_cipher(file_paths, opts)
+  end
+
+private
+
+  def apply_cipher(file_paths, opts)
+    cipher = Gibberish::AES.new(get_password)
+    case file_paths
+    when Array
+      file_paths.each { |path| process_file(path, cipher, opts) }
+    when String
+      process_file(file_paths, cipher, opts)
+    end
+  end
+
+  def process_file(path, cipher, opts) 
+    begin
+      log.debug "#{@action} '#{path}'"
+      content  = cipher.send(@action, File.read(path))
+      replace_file!(path, content) if opts[:replace] 
+      content
+    rescue OpenSSL::Cipher::CipherError => e
+      log.error e
     end
   end
 
+  def replace_file!(path, contents)
+    dirname  = File.dirname(path)
+    filename = File.basename(path, '.*')
+
+    log.debug "writing #{decrypt? ? 'un' : ''}encrypted content to: #{dirname}/#{filename}.#{extension}"
+    File.open("#{dirname}/#{filename}.#{extension}", 'w') { |f| f << contents }
 
-  def self.get_password
+    log.debug "deleting #{decrypt? ? '' : 'un'}encrypted file: #{path}"
+    File.delete(path)
+  end
+
+  def extension
+    decrypt? ? PLAINTEXT_EXT : CIPHERTEXT_EXT
+  end
+
+  def decrypt?
+    @action == :dec
+  end
+
+  def get_password
     printf 'Enter password (will not be shown):'
-    `stty -echo`; password = STDIN.gets.strip;`stty echo`; puts
+    `stty -echo`; password = STDIN.gets.strip;`stty echo`; puts "\n\n"
     log.debug "entered password: #{password.inspect}"
     password
   end
 
+
 end

data/lib/fuzzy_notes/fuzzy_finder.rb

@@ -1,45 +1,51 @@
 require 'find'
 
 class FuzzyNotes::FuzzyFinder
-  extend FuzzyNotes::Logger
-  private_class_method :new
+  include FuzzyNotes::Logger
 
+  attr_reader :path, :all_files, :matching_files, :keywords, :extensions, :full_text_search
 
-  def self.find(path, params = {})
-    keywords, extensions, search = params.values_at(:keywords, :extensions, :full_text_search)
-    match_proc = method(search ? :full_text_match? : :file_name_match?)
+  def initialize(path, params = {})
+    @path = path
     log.debug "search path: #{path}"
 
-    all_files, matching_files = [], []
-    Find.find(*path) do |file_path| 
-      if extension_match?(file_path, extensions) 
-        all_files << file_path
-        matching_files << file_path if match_proc.call(file_path, keywords)
+    @keywords, @extensions, @search_type = params.values_at(:keywords, :extensions, :full_text_search)
+    self.refresh
+  end
+
+  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)
       end
     end
-
-    [all_files.sort, matching_files.sort]
   end
 
-
 private
 
-
-  def self.extension_match?(file_path, extensions)
-    file_name = File.basename(file_path)
-    !extensions || extensions.any? {|ext| /\.#{ext}$/ === file_name }
+  def clear_results
+    @all_files, @matching_files = [], []
   end
 
+  def file_match_proc
+    method(@search_type ? :full_text_match? : :file_name_match?)
+  end
 
-  def self.file_name_match?(file_path, keywords)
-    keywords ? keywords.any? { |name| /#{name}/ === file_path } : false
+  def extension_match?(file_path)
+    file_name = File.basename(file_path)
+    !@extensions || @extensions.any? {|ext| /\.#{ext}$/ === file_name }
   end
 
+  def file_name_match?(file_path)
+    @keywords ? @keywords.any? { |name| /#{name}/ === file_path } : false
+  end
 
-  def self.full_text_match?(file_path, keywords)
-    if keywords && !keywords.empty?
+  def full_text_match?(file_path)
+    if @keywords && !@keywords.empty?
       file_contents = File.read(file_path)
-      keywords.any? { |key| /#{key}/m === file_contents }
+      @keywords.any? { |key| /#{key}/m === file_contents }
     else false 
     end
   end

data/lib/fuzzy_notes/notes.rb

@@ -1,104 +1,112 @@
 class FuzzyNotes::Notes
   include FuzzyNotes::Logger
 
-INIT_PARAMS = :log_level, :editor, :note_paths, :valid_extensions, :keywords
-
-# param defaults
-#
-LOG_LEVEL = 1
-EDITOR='vim'
-NOTE_PATHS=[ "#{ENV['HOME']}/notes" ]
-VALID_EXTENSIONS=%w( txt enc )
-KEYWORDS = []
-
-attr_reader :matching_notes, :all_notes
-
-def initialize(params = {})
-  parse_init_params(params)
-  FuzzyNotes::Log.init_log(@log_level)
-  log.debug "init attributes: \n#{attributes}"
-
-  unless note_paths_valid?
-    log.error "no valid note paths found, exiting"
-    exit
-  end
-
-  @all_notes, @matching_notes = \
-    FuzzyNotes::FuzzyFinder.find(@note_paths, { :keywords => @keywords, 
-                                                :extensions => @extensions,
-                                                :full_text_search => params[:full_text_search] })
+module Defaults
+  LOG_LEVEL = 1
+  EDITOR='vim'
+  NOTE_PATHS=[ "#{ENV['HOME']}/notes" ]
+  VALID_EXTENSIONS=%w( txt enc )
+  KEYWORDS = []
+
+  def self.const_missing(*args); end
 end
 
-# dump all matching notes to stdout
-#
-def cat
-  matching_notes.each do |n|
-    puts "=== #{n} ===\n\n"
-    puts "#{File.read(n)}\n"
-  end
-end
+  OPTS = [:log_level, :editor, :note_paths, :valid_extensions, :keywords].freeze
 
+  attr_reader :matching_notes, :all_notes
 
-# edit all matching notes in EDITOR
-#
-def edit
-  exec("#{editor} #{bashify_paths(matching_notes)}") if !matching_notes.empty?
-end
+  def initialize(params = {})
+    parse_init_params(params)
+    FuzzyNotes::Log.init_log(@log_level)
+    log.debug "init attributes: \n#{inspect_instance_vars}"
 
+    unless note_paths_valid?
+      log.error "no valid note paths found, exiting"
+      exit
+    end
 
-# encrypt matching notes 
-#
-def encrypt
-  FuzzyNotes::Cipher.apply_cipher(matching_notes)
-end
+    finder = FuzzyNotes::FuzzyFinder.new(@note_paths, 
+                                        { :keywords => @keywords, 
+                                          :extensions => @extensions, 
+                                          :full_text_search => params[:full_text_search] })
+    @all_notes, @matching_notes = finder.all_files, finder.matching_files
+  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[param] || Defaults.const_get(default_const) )
+    end
+  end
+  private :parse_init_params
+
+  # dump all matching notes to stdout
+  #
+  def cat
+    matching_notes.each do |note_path|
+      contents = \
+        if encrypted?(note_path)
+          puts "decrypting #{note_path}"
+          FuzzyNotes::Cipher.new.decrypt(note_path)
+        else
+          File.read(note_path)
+        end
+
+      puts "=== #{note_path} ===\n\n"
+      puts "#{contents}\n"
+    end
+  end
 
-# decrypt matching notes
-#
-def decrypt
-  FuzzyNotes::Cipher.apply_cipher(matching_notes, true)
-end
+  # edit all matching notes in EDITOR
+  #
+  def edit
+    exec("#{editor} #{bashify_paths(matching_notes)}") unless matching_notes.empty?
+  end
 
+  # encrypt matching notes 
+  #
+  def encrypt
+    FuzzyNotes::Cipher.new.encrypt(matching_notes, :replace => true)
+  end
 
-# view WC info for all/matching notes
-def info
-  paths = bashify_paths(matching_notes.empty? ? all_notes : matching_notes)
-  puts `wc $(find #{paths} -type f)` 
-end
+  # decrypt matching notes
+  #
+  def decrypt
+    FuzzyNotes::Cipher.new.decrypt(matching_notes, :replace => true)
+  end
 
+  # view WC info for all/matching notes
+  #
+  def info
+    paths = bashify_paths(matching_notes.empty? ? all_notes : matching_notes)
+    puts `wc $(find #{paths} -type f)` 
+  end
 
 private
 
-
-# initialize params or use defaults
-#
-def parse_init_params(params)
-  INIT_PARAMS.each do |param|
-    klass = self.class
-    klass.send(:attr_reader, param)
-    const_name = param.to_s.upcase
-    instance_variable_set("@#{param}", params[param] || 
-                                       (klass.const_defined?(const_name) ? klass.const_get(const_name) : nil) )
+  def note_paths_valid?
+    @note_paths.any? do |p| 
+      File.exists?(p) || log.info("Warning: note path '#{p}' not found")
+    end
   end
-end
-
 
-def note_paths_valid?
-  @note_paths.any? do |p| 
-    File.exists?(p) || log.info("Warning: note path '#{p}' not found")
+  # bash style, space seperated fashion
+  #
+  def bashify_paths(paths)
+    paths.map {|n| "\"#{n}\""}.join(' ')
   end
-end
-
-
-# lists matching note paths in bash style, space seperated fashion
-def bashify_paths(paths)
-  paths.map {|n| "\"#{n}\""}.join(' ')
-end
 
+  def inspect_instance_vars
+    instance_variables.inject("") { |s, ivar| s << "  #{ivar} => #{eval(ivar).inspect}\n" }
+  end
 
-def attributes
-  instance_variables.inject("") { |s, ivar| s << "  #{ivar} => #{eval(ivar).inspect}\n" }
-end
+  def encrypted?(path)
+    File.extname(path)[1..-1] == FuzzyNotes::Cipher::CIPHERTEXT_EXT
+  end
 
 
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: fuzzy_notes
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 21
   prerelease: 
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - Alex Skryl
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-19 00:00:00 -05:00
+date: 2011-07-20 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -46,7 +46,7 @@ dependencies:
         version: "0"
   type: :runtime
   version_requirements: *id002
-description: A note manager with fuzzy search, full text search, and encryption capabilities
+description: A note manager with fuzzy search, full text search, evernote support, and encryption capabilities
 email: rut216@gmail.com
 executables: 
 - fnote
@@ -55,11 +55,11 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
-- lib/fuzzy_notes/cipher.rb
-- lib/fuzzy_notes/fuzzy_finder.rb
+- lib/fuzzy_notes.rb
 - lib/fuzzy_notes/logger.rb
+- lib/fuzzy_notes/cipher.rb
 - lib/fuzzy_notes/notes.rb
-- lib/fuzzy_notes.rb
+- lib/fuzzy_notes/fuzzy_finder.rb
 - bin/fnote
 - README
 - TODO