fuzzy_notes 0.0.1

data/README

@@ -0,0 +1 @@
+README

data/TODO

@@ -0,0 +1,2 @@
+TODO:
+-Evernote support

data/bin/fnote

@@ -0,0 +1,63 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'yaml'
+require 'rubygems'
+require 'fuzzy_notes'
+
+CONFIG_PATH = "#{ENV['HOME']}/.fuzzy_notes"
+
+options = {}
+need_extra_args = [:print, :edit, :encrypt, :decrypt]
+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("-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("-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("-h", "--help", "Show this message") { 
+    puts opts 
+    exit
+  }
+end
+
+begin
+  optparse.parse!(ARGV)                                                                                                                                                                                                 
+  options[:edit] = true if options.values.compact.empty?
+  # check for extra args if necessary
+  if need_extra_args.any? {|opt| options[opt]} && ARGV.empty?
+    puts optparse
+    exit
+  end
+rescue OptionParser::ParseError => e
+  puts optparse
+end
+
+config_path = \
+  options[:config] && File.exists?(options[:config]) && 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?
+
+notes = FuzzyNotes::Notes.new(:log_level => (options[:verbose] || config[:verbose]) ? 0 : 1,
+                              :note_paths => config[:note_paths], 
+                              :full_text_search => options[:search] || config[:full_text_search],
+                              :keywords => ARGV)
+                             
+if options[:list] || options[:info]
+  notes.info
+elsif options[:print]
+  notes.cat
+elsif options[:encrypt]
+  notes.encrypt
+elsif options[:decrypt]
+  notes.decrypt
+else 
+  notes.edit
+end

data/lib/fuzzy_notes.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+
+module FuzzyNotes; end
+
+require 'fuzzy_notes/logger'
+require 'fuzzy_notes/notes'
+require 'fuzzy_notes/fuzzy_finder'

data/lib/fuzzy_notes/fuzzy_finder.rb

@@ -0,0 +1,42 @@
+require 'find'
+
+class FuzzyNotes::FuzzyFinder
+  extend FuzzyNotes::Logger
+  private_class_method :new
+
+  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?)
+    log.debug "[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)
+      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 }
+  end
+
+  def self.file_name_match?(file_path, keywords)
+    keywords ? keywords.any? { |name| /#{name}/ === file_path } : false
+  end
+
+  def self.full_text_match?(file_path, keywords)
+    if keywords && !keywords.empty?
+      file_contents = File.read(file_path)
+      keywords.any? { |key| /#{key}/m === file_contents }
+    else false 
+    end
+  end
+
+end

data/lib/fuzzy_notes/logger.rb

@@ -0,0 +1,21 @@
+require 'buffered_logger'
+
+class FuzzyNotes::Log
+  LOG_LEVEL = 1
+
+  private_class_method :new
+
+  def self.init_log(log_level)
+    @log = BufferedLogger.new(STDOUT, log_level)
+  end
+
+  def self.log
+    @log ||=  BufferedLogger.new(STDOUT, LOG_LEVEL) 
+  end
+end
+
+module FuzzyNotes::Logger
+  def log
+    FuzzyNotes::Log.log
+  end
+end

data/lib/fuzzy_notes/notes.rb

@@ -0,0 +1,116 @@
+require 'gibberish'
+
+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 :notes, :all_notes
+
+def initialize(params = {})
+  parse_init_params(params)
+
+  unless @note_paths.any? { |p| File.exists?(p) }
+    log.error "ERROR: no valid note paths found"
+    exit
+  end
+
+  @all_notes, @notes = \
+    FuzzyNotes::FuzzyFinder.find(@note_paths, { :keywords => @keywords, 
+                                                :extensions => @extensions,
+                                                :full_text_search => params[:full_text_search] })
+end
+
+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) )
+  end
+  FuzzyNotes::Log.init_log(@log_level)
+
+  ivar_values = instance_variables.inject("") { |s, ivar| s << "  #{ivar} => #{eval(ivar).inspect}\n" }
+  log.debug "[debug] init attributes: \n#{ivar_values}"
+end
+
+
+# cat all matching notes to stdout
+def cat
+  notes.each do |n|
+    puts "=== #{n} ===\n\n"
+    puts "#{File.read(n)}\n"
+  end
+end
+
+
+# edit all matching notes in EDITOR
+def edit
+  exec("#{editor} #{bashify_paths(notes)}") if !notes.empty?
+end
+
+
+def encrypt
+  apply_cipher
+end
+
+
+def decrypt
+  apply_cipher(true)
+end
+
+
+# view WC info for all/matching notes
+def info
+  paths = bashify_paths(notes.empty? ? all_notes : notes)
+  puts `wc $(find #{paths} -type f)` 
+end
+
+
+private
+
+
+def apply_cipher(decrypt = false)
+  extension, action = decrypt ? ['.txt', 'dec'] : ['.enc', 'enc']
+  password = get_password
+  cipher = Gibberish::AES.new(password)
+  notes.each do |note|
+    log.info "#{action} '#{note}'"
+    pathname = File.dirname(note)
+    filename = File.basename(note, '.*')
+    begin
+      ciphertext = cipher.send(action, File.read(note))
+      log.debug "[debug] writing encrypted content to: #{pathname}/#{filename}#{extension}"
+      File.open("#{pathname}/#{filename}#{extension}", 'w') { |f| f << ciphertext }
+      log.debug "[debug] deleting unencrypted file: #{note}"
+      File.delete(note)
+    rescue OpenSSL::Cipher::CipherError => e
+      log.error "ERROR: #{e}"
+    end
+  end
+end
+
+
+def get_password
+  printf 'Enter password (will not be shown):'
+  `stty -echo`; password = STDIN.gets.strip;`stty echo`; puts
+  log.debug "[debug] entered password: #{password.inspect}"
+  password
+end
+
+
+# lists matching note paths in bash style, space seperated fashion
+def bashify_paths(paths)
+  paths.map {|n| "\"#{n}\""}.join(' ')
+end
+
+end

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+name: fuzzy_notes
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Alex Skryl
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-24 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: gibberish
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: buffered_logger
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: A note manager with fuzzy search, full text search, and encryption capabilities
+email: rut216@gmail.com
+executables: 
+- fnote
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/fuzzy_notes/fuzzy_finder.rb
+- lib/fuzzy_notes/logger.rb
+- lib/fuzzy_notes/notes.rb
+- lib/fuzzy_notes.rb
+- bin/fnote
+- README
+- TODO
+has_rdoc: true
+homepage: http://github.com/skryl
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A plain text note manager
+test_files: []
+