rwdeliza 0.03

data/lib/druida.rb

@@ -0,0 +1,499 @@
+#!/usr/bin/env ruby -w
+#
+#Copyright (c) 2007 Federico Zagarzaz�
+#
+#Permission is hereby granted, free of charge, to any person obtaining a copy
+#of this software and associated documentation files (the "Software"), to deal
+#in the Software without restriction, including without limitation the rights
+#to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+#copies of the Software, and to permit persons to whom the Software is
+#furnished to do so, subject to the following conditions:
+#
+#The above copyright notice and this permission notice shall be included in
+#all copies or substantial portions of the Software.
+#
+#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+#IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+#FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+#AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+#LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+#OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+#THE SOFTWARE.
+#
+require 'optparse'
+require 'ostruct'
+require 'yaml'
+require 'fileutils'
+require 'enumerator'
+
+# default settings
+NAME           = 'druida'
+VER            = '1.0.0'
+DB_DIR_PATH    = "ElizaData/database"
+DB_PREFIX      = '/db.'
+DB_NELS        = 1000          # max num of elements
+                               # for each db file.
+                               #  little files =>
+                               #  faster and < mem
+                               #  when user wants
+                               #  a random quote.
+LP             = 5             # left padding
+MAX_TAGS_LEN   = 42
+MAX_TAG_LEN    = 40
+MAX_STR_LEN    = 700
+MAX_STR_NLINES = 7             # quotes, not books
+EX             = <<EOF
+Examples:
+  # #{NAME}
+        Prints a random quote.
+
+  # #{NAME} -t rating -s "4 > x > 1"
+        Prints all quotes with the given rating(s).
+
+  # #{NAME} -t tags -s wisdom,life
+        Search for quotes with the given tags.
+
+  # #{NAME} -t author -s 'Seneca' -p
+        Print a random quote from Seneca.
+
+  # #{NAME} -a
+        Adds quote to database.
+
+  # #{NAME} -e 12
+        Edit quote 12.
+  
+  # #{NAME} -t author -s 'Joe Doe' \\
+    -t tags -s \"drugs,sex\" -t rating -s \">2\" \\
+    -t text -s 'wild'
+        Print quotes of 'Joe Doe', that have the
+        tags 'drugs' and 'sex', a rating of more than 
+        two stars, and contain the word 'wild'.
+
+EOF
+
+class String
+  # return longest words of string
+  # (QuoteDB -> find_similar)
+  def key_words
+    arr = self.gsub(/[^\w\s]/, '').split(' ').sort_by {|w| w.length}
+    arr[(arr.length / 2)..(arr.length - 1)]
+  end
+  def count_lines
+    n = 0
+    scan(/\n/) {n+=1}
+    n
+  end
+  def count_words
+    n= 0
+    scan(/\b\S+\b/) {n+=1}
+    n
+  end
+end
+
+class Quote
+  attr_accessor :quote, :author, :info, :rating
+  attr_reader :tags
+  def initialize(a, r, t, i, q)
+    @quote   = q
+    @author  = a
+    @tags    = t.uniq
+    @info    = i
+    @rating  = r.nil? ? 0 : r
+  end
+  def tags=(arr)
+    @tags = arr
+    @tags.uniq!
+  end
+  def print(n = nil, quiet = false)
+    puts @quote
+    puts ' '*LP + '-- ' + @author
+    puts ' '*LP + @info                               unless quiet
+    puts ' '*LP + "(rating: #{@rating})"              unless quiet
+    puts ' '*LP + '(tags: ' + @tags.join(', ') + ')'  unless quiet
+    puts ' '*LP + "[#{n}]"                            unless quiet || n == nil
+  end
+end
+class QuoteDB
+  def initialize(db_path, db_nums = [])
+    @db_path = db_path
+    @db      = []
+    @db_nums = db_nums  # -> save()
+
+    # convert relative to absolute quote index(for user), -> index()
+    @offset  = @db_nums.length == 1 ? DB_NELS * (@db_nums[0] - 1) : 0
+
+    # database is split into multiple files of DB_NELS length
+    @db_nums.each {|n| @db += YAML.load_file(@db_path + n.to_s) }
+  end
+  def empty?
+    @db.empty?
+  end
+  def add(arr)
+    @db << Quote.new(*arr)
+  end
+  def del(n)
+    @db.delete_at(n) unless empty?
+  end
+  def last_num
+    empty? ? nil : @db.length - 1
+  end
+  def length
+    @db.length
+  end
+  def index(q)
+    @db.index(q) + @offset
+  end
+  def [](n)
+    empty? ? nil : @db[n]
+  end
+  def remove_duplicates
+    dups = []
+    @db.each do |q|
+      next if dups.include?(q)
+      a = find_similar(q.author, q.quote.key_words)
+      a.shift
+      dups += a if ! a.empty?
+    end
+    if ! dups.empty?
+      puts "removing #{dups.length} quotes..."
+      @db -= dups
+    end
+  end
+  def find_similar(author, key_words)
+    # pretty basic function, much room for improvement
+
+    # use the longest word in author's name to catch more
+    r   = Regexp.new(author.key_words.last, true)
+    ret = []
+    @db.find_all {|q| q.author =~ r}.each do |q|
+      ret << q if key_words.all? {|w| q.quote.gsub(/[^\w\s]/, '') =~ Regexp.new(w, true) }
+    end
+    ret
+  end
+  def search_tags(arr, ret = [])
+    ret = @db.find_all {|q| arr.all? {|t| q.tags.include?(t)} } unless empty?
+    ret
+  end
+  def search_ratings(arr, ret = [])
+    return ret if empty? || arr.empty?
+    num_left = arr[0] =~ /\d/
+    num, cnd = num_left ? [arr[0].to_i, arr[1]] : [arr[1].to_i, arr[0]]
+    arr.slice!(0..1)
+
+    ret = @db.find_all do |q|
+      r = q.rating
+      case cnd
+        when '>' : num_left ? (num >  r) : (r > num)
+        when '>=': num_left ? (num >= r) : (r >= num)
+        when '=' :             num != r
+        when '<=': num_left ? (num <= r) : (r <= num)
+        when '<' : num_left ? (num <  r) : (r <  num)
+      end
+    end
+    search_ratings(arr, ret)
+  end
+  def search_quotes(str, ret = [])
+    return if empty?
+    r   = Regexp.new(str, true)
+    ret = @db.find_all {|q| q.quote =~ r}
+    ret
+  end
+  def search_authors(str, ret = [])
+    return if empty?
+    r   = Regexp.new(str, true)
+    ret = @db.find_all {|q| q.author =~ r}
+    ret
+  end
+  def save
+    puts 'saving...'
+
+    # delete all db files that were loaded(if any)
+    # to avoid files being left over when deleting quotes
+    @db_nums.each {|n| FileUtils.rm(@db_path + n.to_s) }
+
+    # modify only the db file that was loaded(editing)
+    i = @db_nums.empty? ? 1 : @db_nums.first
+
+    @db.each_slice(DB_NELS) do |a|
+      File.open(@db_path + i.to_s, 'w') {|f| YAML.dump(a, f)}
+      i += 1
+    end
+  end
+end
+
+def invalid_strings?(arr)
+  arr.each do |x|
+    return true      unless x.length < MAX_STR_LEN
+    return true      unless x.count_lines < MAX_STR_NLINES
+  end
+  false
+end
+def invalid_tags?(arr)
+  return true        unless arr.empty? || arr.length <= MAX_TAGS_LEN
+  return true        unless arr.empty? || ! arr.find {|t| t.length > MAX_TAG_LEN}
+  false
+end
+def invalid_rating?(r)
+  return true            unless r.nil? || 0 <= r && r < 6
+  false
+end
+
+# handle search argument(s)
+def parse_search(quotedb, type, str)
+  s, ret = str.dup, nil
+  case type
+    when :tags
+      s   = s.split(',')
+      raise "Invalid --search argument."   if s.empty?
+      ret = quotedb.search_tags(s)
+    when :rating
+      s   = s.split(' '); s.delete("x")
+      raise "Invalid --search argument."      if s.length != 2 && s.length != 4
+      raise "Invalid --search argument."      if s.find {|x| x =~ /[^<>=0-6]/}
+      ret = quotedb.search_ratings(s)
+    when :author
+      raise "invalid author string(too long)" if invalid_strings?([s])
+      ret = quotedb.search_authors(s)
+    when :text
+      raise "invalid quote string(too long)"  if invalid_strings?([s])
+      ret = quotedb.search_quotes(s)
+  end
+  ret.nil? ? [] : ret
+end
+
+# get quote data from user, don't ask for quote text
+# when importing from a fortune's file
+def get_quote_data(importing = false)
+
+    print 'Author : '                                  ; author = gets
+    print 'Info : '                                    ; info   = gets
+    print 'Rating(int, 0 <= x < 6) : '                 ; rating = gets
+    print 'Tags  (space separated) : '                 ; tags   = gets
+  ( print 'Quote (carefully enter, ctrl + d to end) : '; quote  = ''
+  while line = gets
+    quote << line
+  end ) unless importing
+
+  raise "you've to enter quote data before pressing ctrl + d." if tags.nil?
+  [author, info, tags, quote].each {|x| x.chomp! unless x.nil?}
+
+  quote = '' if quote !~ /\w/ # otherwise if user press enters more than once
+                              # when editing, it'll accidentally delete the quote. 
+                              # see main()
+  tags   = tags.split(' ')
+  rating = rating =~ /^\d/ ? rating.to_i : nil
+
+  raise "invalid string(too long)"           if invalid_strings?([quote, author, info])
+  raise "invalid tags(too many or too long)" if invalid_tags?(tags)
+  raise "invalid rating"                     if invalid_rating?(rating)
+
+  return [author, rating, tags, info, quote]
+end
+
+def import_fortune_quotes(quotedb, in_file)
+  raise "#{in_file} not readable." unless File.readable?(in_file)
+  IO.popen("file #{in_file}") { |f| raise "not a text file." unless f.gets =~ /text/}
+
+  c, ignored, found_sep = 0, 0, false
+  author, rating, tags, info = get_quote_data(true)
+
+  # file's quotes separator: '%'
+  File.open(in_file, 'r') do |f|
+    quote = ''
+    f.each_line do |l|
+      if l !~ /^%$/
+        quote << l
+      else
+        if quote =~ /\w/ && ! invalid_strings?([quote])
+          c+=1; found_sep = true
+          quotedb.add([author, rating, tags, info, quote])
+        else
+          ignored+=1
+        end
+        quote = ''
+      end
+    end
+  end
+  raise "file has an invalid format (is it a fortune cookie file?)" unless found_sep
+  puts "#{c} quotes were added, #{ignored} ignored."
+  quotedb.save
+end
+
+def main
+
+  options           = OpenStruct.new
+  options.num       = nil   # int
+  options.search    = []    # str
+  options.type_     = []    # sym
+  options.rand      = false
+  options.add       = false
+  options.edit      = nil   # int
+  options.del       = nil   # int
+  options.dups      = false
+  options.len       = false
+  options.quiet     = true
+  options.import    = nil   # str (path to file)
+  options.count     = 0
+
+  opts = OptionParser.new do |opts|
+    opts.banner    = "Usage: #{NAME} [options]"
+    opts.separator ""
+    opts.on("-n", "--num n", "Print quote n.",
+            "(first element is indexed by 0)")         {|n| options.num  = n; options.count+=1}
+    opts.on("-a", "--add", "Add a quote to database.") {options.add  = true;  options.count+=1}
+    opts.on("-e", "--edit num", "Edit quote num.")     {|n| options.edit = n; options.count+=1}
+    opts.on("-d", "--del num", "Delete quote num.")    {|n| options.del  = n; options.count+=1} 
+    opts.on("-s", "--search string",
+            "Search quotes database(requires --type).",
+            "(tags: comma separated list)",
+            "(rating: you can use [>,<,=])") {|s| options.search << s; options.count+=1}
+    opts.on("-t", "--type type", [:author, :tags, :rating, :text], 
+            "Type of search(author, tags, rating, text).",
+            "(requires --search).") {|t| options.type_ << t; options.count+=1}
+    opts.on("-p", "--print_rand", "Print random quote.") {options.rand = true; options.count+=1}
+    opts.on("-v", "--verbose", "Print extra quote information.") {options.quiet = false}
+    opts.on("--import fortune_file",
+            "Import quotes from a fortune file(full path).") {|f| options.import = f; options.count+=1}
+    opts.on("--duplicates",
+            "Remove \"possible\" duplicates(slow).") {options.dups = true; options.count+=1}
+    opts.on("--length", "Print number of quotes in database.") {options.len = true; options.count+=1}
+    opts.on_tail("-?", "--examples", "Show examples.") {puts EX; exit(0)}
+    opts.on_tail("-V", "--version", "Show version.") {puts "#{NAME + ' ' + VER}"; exit(0)}
+    opts.on_tail("-h", "--help", "Show this message.") {puts opts; exit(0)}
+
+  end
+  begin
+    db_path   = File.expand_path(DB_DIR_PATH)
+    FileUtils.mkdir_p(db_path) unless File.directory?(db_path)
+
+    # build array of numbers out of db files(see QuoteDB.new)
+    r         = Regexp.new(/^#{DB_PREFIX.sub(/\//, '')}(\d+)/)
+    db_nfiles = []
+    Dir.foreach(db_path) {|f| db_nfiles << $1.to_i if f =~ r }
+
+# not acceptable decrease in performace(human time)
+#    raise "you can't have a db.0 file. (check #{DB_DIR_PATH})" if db_nfiles.include?(0)
+#    n = db_nfiles.length
+    db_nfiles = db_nfiles.sort
+#    if ! db_nfiles.empty? && (db_nfiles.inject {|sum, n| sum + n} != n*(n+1) / 2)
+#      raise "db.* files are not continuous." 
+#    end
+
+    # prepare path to database files for loading
+    db_path += DB_PREFIX
+
+    # databases must be writable text files
+#    db_nfiles.each do |n|
+#      IO.popen("file #{db_path + n.to_s}") do |f|
+#        raise "database #{n} is not a text file." unless f.gets =~ /text/
+#      end
+#      raise "database #{n} is not writable." unless File.writable?(db_path + n.to_s)
+#    end
+
+    opts.parse!
+    raise "invalid input (see --help)." if ARGV.length != 0
+
+    if ! db_nfiles.empty? && (options.count == 0 || (options.count == 1 && options.rand) )
+      # load a random database file(faster and eats less memory than lading all)
+      quotedb = QuoteDB.new(db_path, [rand(db_nfiles.length) + 1] )
+
+      # pick a random quote from loaded database, convert to absolute value when printing
+      q = quotedb[rand(quotedb.length)]
+      q.print(quotedb.index(q), options.quiet)
+    else
+      case options.count
+        when 1
+          if options.num || options.edit
+            num = (options.num || options.edit).to_i
+   
+            # the file num (suffix) for num
+            fn = (num / DB_NELS) + 1
+   
+            raise "out of range (no file)." unless File.exist?(db_path + fn.to_s)
+            quotedb = QuoteDB.new(db_path, [fn])
+  
+            # convert user's num to relative num inside quotedb
+            n = num % DB_NELS
+
+            raise "out of range." unless n < quotedb.length
+
+            if options.num
+              quotedb[n].print(num, options.quiet)
+            else
+              puts 'leave empty the fields you don\'t want to edit.'
+              arr, q = get_quote_data, quotedb[n]
+              q.author = arr[0] unless arr[0].empty?
+              q.rating = arr[1] unless ! arr[1]
+              q.tags   = arr[2] unless arr[2].empty?
+              q.info   = arr[3] unless arr[3].empty?
+              q.quote  = arr[4] unless arr[4].empty?
+              quotedb.save
+            end
+          else
+            quotedb = QuoteDB.new(db_path, db_nfiles)
+            if options.len
+              puts "Length: #{quotedb.length}"
+            elsif options.add
+              arr = get_quote_data
+              raise "missing author/quote field." if arr[0].empty? || arr[4].empty?
+              qn  = quotedb.find_similar(arr[0], arr[4].key_words)
+              if ! qn.empty?
+                puts  "Similar quote(s) exists: #{qn.join(', ')} (indices)"
+                print "\nProceed? (yes/no) : "; ans = gets
+                (puts  "Canceled."; exit(0)) if ans !~ /^yes/
+              end
+              quotedb.add(arr); quotedb.save
+            elsif options.import
+              import_fortune_quotes(quotedb, options.import)
+            elsif options.del
+              raise "out of range." unless options.del.to_i < quotedb.length
+              quotedb.del(options.del.to_i); quotedb.save
+            elsif options.dups
+              quotedb.remove_duplicates
+              quotedb.save
+            else
+              raise "Invalid option (see --help)."
+            end
+          end
+        when 2
+          quotedb = QuoteDB.new(db_path, db_nfiles)
+          if ! options.search.empty?
+            raise "Incompatible options (see --help)." if options.type_.empty?
+            a = parse_search(quotedb, options.type_[0], options.search[0])
+            if a.empty?
+              puts 'none found'
+            else
+              a.each {|q| q.print(quotedb.index(q), options.quiet) }
+            end
+          else
+            raise "Incompatible options (see --help)."
+          end
+        else
+          quotedb = QuoteDB.new(db_path, db_nfiles)
+          if options.search.length == options.type_.length && options.count < 10
+            a   = []
+            options.search.length.times do |i|
+              r = parse_search(quotedb, options.type_[i], options.search[i])
+              a = a.empty? ? r : a & r
+            end
+            if a.empty?
+              puts 'none found'
+            else
+              rnd = rand(a.length)
+              if options.rand
+                a[rnd].print(quotedb.index(a[rnd]), options.quiet)
+              else
+                a.each {|q| q.print(quotedb.index(q), options.quiet) }
+              end
+            end
+          else
+            raise "Incompatible options (see --help)." 
+          end
+      end
+    end
+  rescue StandardError => bang
+    puts "\n" + 'Oops, ' + bang
+    exit(1)
+  end
+end
+main