whale 0.0.0 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 84a82a8527b5b787b69deb1dbb9c229db5cb356f
-  data.tar.gz: 4818466b7d1d8ca1d26a250754ec95fa451d188d
+  metadata.gz: 10aefc6ce7f9102e028c417e9e8d7a5b2f1f1ce0
+  data.tar.gz: 7a3dcd424e6c33d208b18ae7e3a29b7d078b564d
 SHA512:
-  metadata.gz: b8c2f2f092f0e34d3726267ddfdfb87bba0efb1850495d62c8b145561b95075611b64fe00e400a8d1c5ace6110ada2232cca73599e69113cfa951fd054078eab
-  data.tar.gz: 231ace61fa951ce4b6a705c3eba13a3cda42f253e867bda0eacf4103bbfc1022958b53f886e1a2b3febe63ca78d2713c0ea9e42ec3ee6b6caab42091454f0193
+  metadata.gz: 4e308539f6f2ac801178c4edb1fbabbec49ac1e31459c5d3662e96732deb7ca19a7edaa9fbabc2e1ed37b9a3449010277dd780aab335fb4699808471e8d6c5a6
+  data.tar.gz: 6653cc61f4da672de5e76f677c2845ba1b66a326333206115f57bb6b1f1658d0f5b4b256afd84bd67ad1cf942b5a41eec68087b84d524e0f980da7069321abbb

data/bin/whale

@@ -1,18 +1,34 @@
 #!/usr/bin/env ruby
 require 'whale'
+require 'logger'
+
 
 USAGE = <<ENDUSAGE
 Usage:
-  whale [-h] [-f tag] [-s tag] [-e id] files..
+  whale [files] [-h] [-p paths] [-r] [-f filter] [-e id] [-s tag]
+        [-w] [-n] [-t] [-v] [-d]
 ENDUSAGE
 
 HELP = <<ENDHELP
+  files                Space-separated list of files
   -h, --help           View this message
-  -f, --filter         List entries with the tag
-  -s, --sort           Sort entries by the tag value
+  -p, --paths          Colon-separated list of paths to search
+  -r, --recursive      Search for files recursively
+  -f, --filter         Filter entries by tags
   -e, --edit           Open the editor to given entry
-  -w, --write          Write the entries to file
-  --version            Show the version
+  -s, --sort           Sort entries by tag value
+  -w, --write          Write the entries to stdout
+  -n, --name           List the tag names
+  -t, --tags           Show the tag values
+  -v, --version        Show the version number
+  -d, --debug          Set the logging level to debug
+
+-p, --paths
+  Specify the paths to search. Each path is separated by a colon. Any files 
+  with the .wl or .whale extension are read.
+
+-r, --recursive
+  Search for files recursively.
 
 -f, --filter filter
   Show entries with tags satisfying the filter. The filter is a string 
@@ -22,28 +38,54 @@ HELP = <<ENDHELP
   Options for regexes are specified by writing /(?option:regex)/.
   The symbols for AND, OR, and NOT are &, |, and *, respectively.
 
--s, --sort tag
-  Sort the entries by tag.
-
 -e, --edit id
   Edit the entry with id id using the text editor specified by the environment 
   EDITOR.
 
+-n, --name
+  List all tags read.
+
+-t, --tags tags
+  Show the values of the given tags.
+
+-s, --sort tag
+  Sort the entries by the given tag value.
+
 -w, --write
   Write the entries, including title, body, and tags, to stdout.
+
+-v, --version
+  Show the version number.
+
+-d, --debug
+  Set the logging level to debug.
+
+Environment
+  EDITOR
+    The editor for the edit command.
+
+  WHALEPATH
+    A colon separated list of default paths to search when paths is not
+    provided.
 ENDHELP
 
-args = { :files => [] }
+args = { :files => [], :recursive => false }
 unflagged_args = [:files]
 next_arg = unflagged_args.first
+
 ARGV.each do |arg|
   case arg
   when '-h','--help'          then args[:help] = true
+  when '-p','--paths'         then next_arg = :paths
   when '-f','--filter'        then next_arg = :filter
-  when '-s','--sort'          then next_arg = :sort
   when '-e','--edit'          then next_arg = :edit
-  when '-w', '--write'        then args[:write] = true
-  when '--version'            then args[:version] = true
+  when '-n','--name'          then args[:name] = true
+  when '-t','--tags'          then next_arg = :tags
+  when '-s','--sort'          then next_arg = :sort
+  when '-r','--recursive'     then args[:recursive] = true
+  when '-w','--write'         then args[:write] = true
+  when '-v','--version'       then args[:version] = true
+  when '-d','--debug'         then args[:debug] = true
   else
     if next_arg == :files
       args[:files] << arg
@@ -54,24 +96,56 @@ ARGV.each do |arg|
     end
   end
 end
+
+logger = Logger.new(STDOUT)
+logger.level = Logger::WARN
+logger.level = Logger::DEBUG if args[:debug]
+logger.level = Logger::UNKNOWN if args[:write]
+
 if args[:version]
   puts "whale.rb version #{MAJOR_VERSION}.#{MINOR_VERSION}.#{REVISION}"
   exit
 end
+
+paths = []
+paths += ENV['WHALEPATH'].split(':') if ENV['WHALEPATH']
+paths += args[:paths].split(':') if args[:paths]
+
+logger.debug(paths)
+
+paths.each { |p| args[:files] += \
+  list_files_in_path(p, args[:recursive], logger) }
+
+logger.debug(args[:files])
+
 if args[:help] or args[:files].empty?
   puts USAGE
   puts HELP if args[:help]
   exit
 end
+
 entries = []
-args[:files].each { |f| entries += parse_file(f) }
-puts "Parsed #{args[:files].length} files and #{entries.length} entries"
+args[:files].each do |file| 
+  begin
+    entries += parse_file(file, logger)
+  rescue Errno::ENOENT
+    logger.warn("File not found: #{file}")
+  rescue Errno::EISDIR
+    logger.warn("#{file} is a directory. Use -p to specify paths")
+  end
+end
+
+logger.info("Parsed #{args[:files].length} files " +
+            "and #{entries.length} entries")
+
 if args[:filter]
   filter = Filter.new
-  filter.parse_filter args[:filter]
-  filter_entries(entries, filter)
+  filter.pgrse_filter(args[:filter], logger)
+  filter_entries(entries, filter, logger)
 end 
-sort_entries_by(entries, args[:sort]) if args[:sort]
+
+sort_entries_by(entries, args[:sort], logger) if args[:sort]
+
 if args[:edit]
   i = args[:edit].to_i - 1
   e = entries[i]
@@ -79,15 +153,27 @@ if args[:edit]
     puts "Invalid ID"
     exit
   end
-  open_editor(ENV['EDITOR'].to_sym, e.tags[:file], e.tags[:line])
+  open_editor(ENV['EDITOR'].to_sym, e.tags[:file], e.tags[:line], logger)
+end
+
+if args[:name] and !args[:write]
+  list_tags get_all_tags(entries)
 end
 
 write_entries(entries) if args[:write]
 
-if !args[:write]
+tags_to_list = [:title, :date, :tags]
+tags_format = [45, 10, 24]
+
+if args[:tags]
+  tags = args[:tags].split(' ')
+  tags.each do |t| 
+    tags_to_list << t.to_sym
+    tags_format << 24
+  end
+end
+
+if !args[:write] and !args[:name]
   all_tags = get_all_tags entries
-  debug(list_tags(all_tags))
-  tags_to_list = [:title, :date, :tags]
-  tags_format = [45, 10, 25]
   list_entries(entries, tags_to_list, tags_format)
 end

data/lib/whale.rb

@@ -1,26 +1,12 @@
 # File: whale.rb
 
 require 'set'
-
-DEBUG = true
+require 'logger'
 
 MAJOR_VERSION = 0
-MINOR_VERSION = 0
+MINOR_VERSION = 1
 REVISION      = 0
 
-
-def debug(msg)
-  puts msg if DEBUG
-end
-
-def error(msg)
-  puts "Error: #{msg}"
-end
-
-def warning(msg)
-  puts "Warning: #{msg}"
-end
-
 $DEFAULT_TAGS = [:title, :body, :line, :file, :tags]
 
 class Entry
@@ -45,10 +31,9 @@ class Filter
 
   # For regex options (e.g. ignorecase) use the (?opt:source) notation,
   # e.g. /(?i-mx:hEllo .*)/
-  def parse_filter(f)
-    debug("parsing #{f}")
+  def parse_filter(f, logger)
+    logger.debug("parsing #{f}")
     regex = false
-    quote = nil
     escape = false
     # literal = false
     token = 0
@@ -56,34 +41,22 @@ class Filter
     (0...f.length).each do |i|
       if f[i] == '\\' or escape
         escape ^= true
-      elsif f[i] == '"' or f[i] == "'"
-        unless regex
-          if quote == f[i]
-            stack << f[token, i - token]
-            quote = nil
-          else
-            token = i + 1
-            quote = f[i]
-          end
-        end
       elsif f[i] == '/'
-        unless quote
-          if regex
-            stack << Regexp.new(f[token, i - token])
-            regex = false
-          else
-            token = i + 1
-            regex = true
-          end
+        if regex
+          stack << Regexp.new(f[token, i - token])
+          regex = false
+        else
+          token = i + 1
+          regex = true
         end
-      elsif !regex and !quote
+      elsif !regex
         stack << :FILTER_AND if f[i] == '&'
         stack << :FILTER_OR if f[i] == '|'
         stack << :FILTER_NOT if f[i] == '*'
         stack << :FILTER_EQ if f[i] == '='
       end
     end
-    debug(stack)
+    logger.debug(stack)
     @stack = stack
   end
 
@@ -96,7 +69,7 @@ class Filter
   end
 
   # apply the stack to the entry tags
-  def filter(entry)
+  def filter(entry, logger)
     s = []
     last_tags = []
     eq = false
@@ -108,13 +81,13 @@ class Filter
       when :FILTER_EQ then eq = true
       else
         if eq
-          debug("last tags: #{last_tags}")
+          logger.debug("last tags: #{last_tags}")
           match = false
           s.pop
           last_tags.each do |u|
             if t.match entry.tags[u]
               match = true 
-              debug("#{t} matches #{entry.tags[u]}")
+              logger.debug("#{t} matches #{entry.tags[u]}")
               break
             end
           end
@@ -126,18 +99,18 @@ class Filter
         end
       end
     end
-    debug(s)
-    warning("malformed filter") if s.length != 1
+    logger.debug(s)
+    logger.warn("Malformed filter") if s.length != 1
     return s.first
   end
 
 end
 
-def filter_entries(entries, filter)
-  entries.delete_if { |a| !filter.filter(a) }
+def filter_entries(entries, filter, logger)
+  entries.delete_if { |a| !filter.filter(a, logger) }
 end
 
-def sort_entries_by(entries, tag)
+def sort_entries_by(entries, tag, logger)
   return entries.sort { |a, b| a.tags[tag] <=> b.tags[tag] }
 end
 
@@ -148,8 +121,8 @@ $EDITOR_CMDS = {
 }
 $EDITOR_CMDS.default = "ed %<file>s"
 
-def open_editor(editor, path, lineno)
-  debug("opening at #{lineno}")
+def open_editor(editor, path, lineno, logger)
+  logger.debug("opening at #{lineno}")
   args = {line: lineno, file: path}
   cmd = $EDITOR_CMDS[editor] % args
   exec(cmd)
@@ -230,36 +203,46 @@ def list_tags(tags)
   puts s.slice(0, s.length - 2)
 end
 
+# List files in the path with the given extension
+def list_files_in_path(path, recursive, logger)
+  file_glob = '*.{wl,whale}'
+  if recursive
+    glob_path = File.join(path, File.join('**', file_glob))
+  else
+    glob_path = File.join(path, file_glob)
+  end
+  return Dir.glob(glob_path)
+end
 
 EMPTY_LINE = /\A\s*\Z/
 LABEL_LINE = /\A;(.*)\Z/
 
 # Extract entries from file.
-# param @file String the path of the file to parse
-# return Array the array of Entry
-def parse_file(file)
+# param @file a file name to read
+# return Array an array of Entry
+def parse_file(file, logger)
   entries = []
   file_entry = Entry.new
-  File.open(file, "r") do |f|
-    entry = nil
-    is_reading_tag = true
-    lineno = 0
+  entry = nil
+  is_reading_tag = true
+  lineno = 0
+  File.open(file, 'r') do |f|
     f.each_line do |line|
       lineno += 1
       # skip if the line is whitespace
       next if EMPTY_LINE.match line
       if (m = LABEL_LINE.match line)
-        debug("#{f.path}, #{lineno}, reading tag")
+        logger.debug("#{f.path}, #{lineno}, reading tag")
         is_reading_tag = true
         matched_line = m[1]
         if entry.nil?
-          debug("adding file entry tags #{matched_line}")
+          logger.debug("adding file entry tags #{matched_line}")
           parse_tags file_entry, matched_line
         else
           parse_tags entry, matched_line
         end
       elsif is_reading_tag
-        debug("#{f.path}, #{lineno}, new entry")
+        logger.debug("#{f.path}, #{lineno}, new entry")
         is_reading_tag = false
         entries << entry if !entry.nil?
         entry = Entry.new
@@ -271,10 +254,10 @@ def parse_file(file)
       end
     end
     entries << entry if !entry.nil?
-    puts "Last entry is missing tag" if !is_reading_tag
+    logger.warn("#{file} missing last entry tags") if !is_reading_tag
   end
   # add the file level tags to each entry
-  debug(file_entry.tags)
+  logger.debug(file_entry.tags)
   entries.each { |e| e.tags = file_entry.tags.merge(e.tags) }
   return entries
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: whale
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.0
 platform: ruby
 authors:
 - Ryutaro Ikeda