nametrainer 0.0.1

data/README.md

@@ -0,0 +1,89 @@
+nametrainer
+===========
+
+`nametrainer` is a name learning trainer using [Ruby][Ruby] and the [Qt][Qt] GUI toolkit.
+
+It will assist you in learning people's names from a collection of images.
+
+Quick Start
+----------
+
+Start the application from the command line with
+`nametrainer` or with `nametrainer path_to_collection`.
+The program can also be started with a demo collection:
+use `nametrainer --demo` or `nametrainer -d`.
+
+With a collection loaded, the application window will look similar to this:
+
+<img src="https://github.com/stomar/nametrainer/raw/master/screenshot.png" alt="Screenshot" width="431" height="405" />
+
+`nametrainer` shows a randomly chosen image.
+You can then display the corresponding name and tell the application
+whether you know the person's name or you don't know it yet.
+Persons that you do not know will be shown more often.
+
+Note that for reasons of speed and convenience it is not necessary
+to type in the name (so be honest to yourself).
+There are also keyboard shortcuts for "power users".
+
+Collections
+-----------
+
+A collection is simply a directory with image files.
+`nametrainer` searches in the specified directory for all JPG or PNG files.
+It uses the file name as the person's display name unless a corresponding TXT file
+is also present. In this case it will use the content of the TXT file as name.
+
+For example, a collection might contain the following files:
+
+>       Albert_Einstein.jpg
+>       img1234.jpg
+>       img1234.txt
+>       Werner_Heisenberg.JPG
+
+Please note:
+
+-   Do not use special characters in file names; use underscore instead of space.
+-   Use UTF-8 encoding for TXT files.
+-   **On Windows, JPG files might not be supported** (depending on the Qt version).
+    In this case use PNG images instead.
+
+Installation
+------------
+
+Install with `gem install nametrainer`.
+
+You will also have to install Qt bindings for Ruby:
+
+-   On Windows, the `qtbindings` gem should get you up and running.
+
+-   On Linux, install the appropriate package for your distribution,
+    e. g. `qt4-ruby` on Ubuntu.
+
+    You can also compile the bindings using the `qtbindings` gem
+    (see the [qtbindings README](https://github.com/ryanmelt/qtbindings#readme)
+    for instructions).
+
+Acknowledgements
+----------------
+
+The images for the demo collection were taken from [robohash.org](http://robohash.org/).
+
+Reporting bugs
+--------------
+
+Report bugs on the `nametrainer` home page: <https://github.com/stomar/nametrainer/>
+
+License
+-------
+
+Copyright &copy; 2012, Marcus Stollsteimer
+
+`nametrainer` is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License version 3 or later (GPLv3+),
+see [www.gnu.org/licenses/gpl.html](http://www.gnu.org/licenses/gpl.html).
+There is NO WARRANTY, to the extent permitted by law.
+
+
+[Ruby]: http://www.ruby-lang.org/
+[Qt]:   http://qt-project.org/

data/Rakefile

@@ -0,0 +1,30 @@
+# Rakefile for the nametrainer program.
+#
+# Copyright (C) 2012 Marcus Stollsteimer
+
+require 'rake/testtask'
+
+BINDIR = '/usr/local/bin'
+
+BINARY = 'bin/nametrainer'
+
+
+def gemspec_file
+  'nametrainer.gemspec'
+end
+
+
+task :default => [:test]
+
+Rake::TestTask.new do |t|
+  t.pattern = 'test/**/test_*.rb'
+  t.ruby_opts << '-rubygems'
+  t.verbose = true
+  t.warning = true
+end
+
+
+desc 'Build gem'
+task :build do
+  sh "gem build #{gemspec_file}"
+end

data/bin/nametrainer

@@ -0,0 +1,38 @@
+#!/usr/bin/ruby -w
+
+require 'Qt'
+
+require 'nametrainer'
+
+SRCPATH = File.dirname(__FILE__)
+
+module Nametrainer
+
+  ERRORCODE = {:general => 1, :usage => 2}
+
+  # Prints an error message and a short help information, then exits.
+  def self.usage_fail(message) # :nodoc:
+    warn "#{PROGNAME}: #{message}"
+    warn "Use `#{PROGNAME} --help' for valid options."
+    exit ERRORCODE[:usage]
+  end
+end
+
+### main program
+
+# parse options
+begin
+  options = Nametrainer::Optionparser.parse!(ARGV)
+rescue => e
+  Nametrainer.usage_fail(e.message)
+end
+
+# set up demo mode
+if options[:demo]
+  options[:collection] = File.expand_path("#{SRCPATH}/../demo_collection")
+end
+
+# start
+app = Qt::Application.new ARGV
+Nametrainer::GUI.new(options[:collection])
+app.exec

data/demo_collection/Erwin_Schroedinger.txt

@@ -0,0 +1 @@
+Erwin Schrödinger

data/lib/nametrainer.rb

@@ -0,0 +1,94 @@
+# == Name
+#
+# nametrainer - name learning trainer
+#
+# == Synopsis
+#
+#    nametrainer [options] [collection]
+#
+# == Description
+#
+# +nametrainer+ is a name learning trainer using Ruby and the Qt GUI toolkit.
+# It will assist you in learning people's names from a collection of images.
+#
+# See the project home page for additional information:
+# https://github.com/stomar/nametrainer/
+#
+# == Options
+#
+# -d, --demo:: Starts the application with a demo collection.
+#
+# -h, --help:: Prints a brief help message and exits.
+#
+# -v, --version:: Prints a brief version information and exits.
+#
+# == Author
+#
+# Copyright (C) 2012 Marcus Stollsteimer
+#
+# License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
+
+require 'nametrainer/gui'
+require 'nametrainer/person'
+require 'nametrainer/collection'
+require 'nametrainer/optionparser'
+require 'nametrainer/statistics'
+require 'nametrainer/version'
+
+# This module contains the classes for the +nametrainer+ tool
+module Nametrainer
+
+  FILE_EXTENSIONS = %w{png jpg jpeg}
+
+  # Returns a string with all accepted image file extensions.
+  def self.extension_string
+    "#{FILE_EXTENSIONS[0...-1].join(', ').upcase}, or #{FILE_EXTENSIONS.last.upcase}"
+  end
+
+  # Returns the warning message for an empty collection.
+  def self.collection_empty_message
+    'Could not load collection.<br><br>' +
+    "Maybe the specified directory does not exist or contains no #{extension_string} files."
+  end
+
+  # Returns the text for the help window.
+  def self.help_message
+    <<-HELPTEXT
+    <big>Basic Functions / Keyboard Shortcuts</big><br>
+
+    <table>
+    <tr><td>Display name &nbsp;&nbsp;&nbsp;</td>
+        <td>Shows the person's name (<strong>D</strong>)</td></tr>
+    <tr><td>Correct</td>
+        <td>You know this person (<strong>S</strong>)</td></tr>
+    <tr><td>Wrong</td>
+        <td>You do not know this person yet (<strong>F</strong>)</td></tr>
+    <tr><td>Quit</td>
+        <td>Quit (<strong>Ctrl+W</strong>)</td></tr>
+    </tr>
+    </table>
+    <br><br>
+
+    <big>Collections</big><br><br>
+
+    A collection is simply a diretory with image files.
+    #{PROGNAME} uses the file name as the person's display name
+    or the content of a corresponding TXT file.<br><br>
+
+    Accepted file formats: #{extension_string}.<br><br>
+
+    Please note: JPG files may not be supported on Windows;
+    in this case use PNG images instead.<br><br>
+
+    <big>About</big><br><br>
+
+    <b>#{PROGNAME}</b> version #{VERSION} (#{DATE})<br><br>
+
+    Project home page:
+    <a href='#{HOMEPAGE}'>#{HOMEPAGE.gsub(%r{https?://}, '')}</a><br><br>
+
+    #{COPYRIGHT.lines.first.gsub(/\(C\)/, '&copy;')}<br>
+    For license information use <code>#{PROGNAME} -v</code>.
+    HELPTEXT
+  end
+end

data/lib/nametrainer/collection.rb

@@ -0,0 +1,144 @@
+require 'set'
+require 'yaml'
+
+require 'nametrainer/person'
+
+module Nametrainer
+
+  # A Class for a collection of persons, each with a name,
+  # a corresponding (image) file, and a score.
+  # A collection is an array of instances of the Person class.
+  #
+  # Open a collection with
+  #   collection = Collection.new(directory, extensions)
+  #
+  # For each file with an extension from the +extensions+ array a Person
+  # instance is created, using the file name as the person's name
+  # (extension is removed, underscore is converted to space)
+  # or the content of a corresponding `txt' file, and the file name as
+  # the +image+ attribute.
+  #
+  # You can get a random person from a collection with
+  #   person = collection.sample
+  #
+  # Persons with a lower score are chosen more often
+  # than persons with a higher score.
+  class Collection < Array
+
+    SCORE_FILE = 'nametrainer.dat'
+
+    # Creates a Collection instance.
+    # It searches in +directory+ for files with the given
+    # file extensions (also in upper case) and populates
+    # the collection with corresponding Person instances.
+    #
+    # +directory+ - collection directory
+    # +extension+ - array of file extensions
+    def initialize(directory, extensions)
+      super()
+      @directory = directory
+      @extensions = extensions.to_set
+      @extensions.merge extensions.map {|i| i.upcase}
+      self.concat self.class.load(@directory, @extensions.to_a)
+    end
+
+    # Returns an array of all names.
+    def names
+      all_names = Array.new
+      self.each do |person|
+        all_names << person.name
+      end
+
+      all_names
+    end
+
+    # Returns a hash with the score of all persons (name => score).
+    def scores
+      all_scores = {}
+      self.each do |person|
+        all_scores[person.name] = person.score
+      end
+
+      all_scores
+    end
+
+    # Sets the score of some or all persons.
+    #
+    # +new_scores+ - hash with (name => score) values
+    def set_scores(new_scores)
+      self.each do |person|
+        person.score = new_scores[person.name]  unless new_scores[person.name].nil?
+      end
+    end
+
+    # Loads the scores from file (YAML).
+    def import_scores
+      filename = File.expand_path("#{@directory}/#{SCORE_FILE}")
+      new_scores = YAML::load(File.read filename)
+      set_scores(new_scores)
+    end
+
+    # Export all scores to file (YAML).
+    def export_scores
+      filename = File.expand_path("#{@directory}/#{SCORE_FILE}")
+      File.open(filename, 'w') do |f|
+        f.write(scores.to_yaml)
+      end
+    end
+
+    # Returns a random element, preferring persons with a smaller score.
+    def sample
+      self.shuffle.sort[weighted_random_index]  # shuffle first, so that elements with equal scores get mixed up
+    end
+
+    private
+
+    # Returns a random index (obsolete).
+    def random_index
+      rand(self.size)
+    end
+
+    # Returns a random index, preferring smaller indices.
+    def weighted_random_index
+      max_index = self.size - 1
+      weighting_factor = 6  # index 0 will be about weighting_factor times more probable than max_index
+
+      # construct an array with indices by repeatedly adding different parts of a range of indices
+      indices = Array.new
+      range = Array.new(self.size) {|i| i }
+      1.upto(weighting_factor) do
+        |i| indices += range[0..(i.to_f/weighting_factor * max_index).ceil]
+      end
+
+      indices[rand(indices.size)]
+    end
+
+    # class methods
+
+    # Load a collection. Returns an array of Person instances.
+    def self.load(directory, extensions)
+      extension_list = extensions.join(',')
+      files = Dir.glob("#{directory}/*.{#{extension_list}}")
+      result = Array.new
+      files.each do |file|
+        name = get_name(file, extensions)
+        result << Person.new(name, file)
+      end
+
+      result
+    end
+
+    # Get name from corresponding `txt' file or
+    # from file name (remove extension, convert underscores).
+    def self.get_name(file, extensions)
+      name = file.dup
+      extensions.each {|ext| name.gsub!(/\.#{ext}$/, '') }  # remove file extension
+      begin
+        info_file = "#{name}.txt"
+        File.read(info_file).chomp
+      rescue
+        File.basename(name).tr('_', ' ')
+      end
+    end
+  end
+end

data/lib/nametrainer/gui.rb

@@ -0,0 +1,234 @@
+require 'Qt'
+require 'iconv'  if RUBY_VERSION < '1.9' # utf-8 -> latin1 for QLabel
+
+module Nametrainer
+
+  # Class for the application window.
+  class GUI < Qt::Widget
+
+    # Initializes the application window.
+    # You can specify a collection that is loaded at startup.
+    #
+    # +collection_dir+ - path to collection
+    def initialize(collection_dir = nil)
+      super()
+
+      set_window_title 'Name Trainer'
+      resize 600, 500
+
+      # the common variables
+      @collection_dir = nil
+      @collection = nil
+      @person = nil
+      @statistics = Nametrainer::Statistics.new
+
+      # the common widgets
+      @collection_label = Qt::Label.new '<i>No collection loaded</i>'
+      @image_label = Qt::Label.new
+      @image = Qt::Pixmap.new
+      @name_label = Qt::Label.new
+      @statistics_label = Qt::Label.new @statistics.to_s
+
+      init_gui
+      show
+
+      init_collection File.expand_path(collection_dir)  unless collection_dir.nil?
+    end
+
+    # Initializes the GUI layout and functions.
+    def init_gui
+      name_fontsize = 24
+      name_font = Qt::Font.new { setPointSize name_fontsize }
+      @name_label.set_font name_font
+      @image_label.set_size_policy Qt::SizePolicy::Ignored, Qt::SizePolicy::Ignored
+
+      # create buttons
+      @show = Qt::PushButton.new '&Display Name', self do
+        #set_tool_tip 'S'
+        set_shortcut Qt::KeySequence.new(Qt::Key_D.to_i)
+      end
+      @correct = Qt::PushButton.new 'Correct', self do
+        #set_tool_tip 'F'
+        set_shortcut Qt::KeySequence.new(Qt::Key_S.to_i)
+      end
+      @wrong = Qt::PushButton.new 'Wrong', self do
+        #set_tool_tip 'D'
+        set_shortcut Qt::KeySequence.new(Qt::Key_F.to_i)
+      end
+      load_collection = Qt::PushButton.new '&Load Collection', self do
+        #set_tool_tip 'L'
+        set_shortcut Qt::KeySequence.new(Qt::Key_L.to_i)
+      end
+      help = Qt::PushButton.new '&Help', self do
+        #set_tool_tip 'H'
+        set_shortcut Qt::KeySequence.new(Qt::Key_H.to_i)
+      end
+      quit = Qt::PushButton.new 'Quit', self do
+        #set_tool_tip 'Ctrl+W'
+        set_shortcut Qt::KeySequence.new(Qt::CTRL.to_i + Qt::Key_W.to_i)
+      end
+
+      # Connect the buttons to slots.
+      connect load_collection, SIGNAL(:clicked), self, SLOT(:load_collection)
+      connect quit, SIGNAL(:clicked), self, SLOT(:quit)
+      connect help, SIGNAL(:clicked), self, SLOT(:show_help)
+      connect @correct, SIGNAL(:clicked), self, SLOT(:correct_answer)
+      connect @wrong, SIGNAL(:clicked), self, SLOT(:wrong_answer)
+      connect @show, SIGNAL(:clicked), self, SLOT(:display_name)
+
+      # Start with buttons disabled.
+      disable_buttons
+
+      # Create the layout.
+      vbox = Qt::VBoxLayout.new self
+      mainbox = Qt::HBoxLayout.new
+
+      vbox.add_widget @collection_label
+
+      left = Qt::VBoxLayout.new
+      left.add_widget @image_label, 1
+      left.add_widget @name_label
+
+      answer_buttons = Qt::HBoxLayout.new
+      answer_buttons.add_widget @correct
+      answer_buttons.add_widget @wrong
+
+      right = Qt::VBoxLayout.new
+      right.add_widget @show
+      right.add_layout answer_buttons
+      right.add_stretch 1
+      right.add_widget Qt::Label.new 'Statistics:'
+      right.add_widget @statistics_label
+      right.add_stretch 3
+      right.add_widget load_collection
+      right.add_widget help
+      right.add_widget quit
+
+      mainbox.add_layout left, 1
+      mainbox.add_layout right
+
+      vbox.add_layout mainbox
+
+      set_layout vbox
+    end
+
+    slots :load_collection, :quit, :show_help, :display_name, :correct_answer, :wrong_answer
+
+    # Opens a file dialog and tries to load a collection.
+    def load_collection
+      collection_dir = Qt::FileDialog.get_existing_directory self, 'Load Collection'
+      return  if collection_dir.nil?
+      init_collection File.expand_path(collection_dir)
+    end
+
+    # Tries to load a collection (does not change anything if load fails).
+    #
+    # +collection_dir+ - path to collection
+    def init_collection(collection_dir)
+      collection = Nametrainer::Collection.new(collection_dir, Nametrainer::FILE_EXTENSIONS)
+      if collection.nil? or collection.empty?
+        Qt::MessageBox.warning self, 'Error', Nametrainer.collection_empty_message
+        return
+      end
+      @collection_dir = collection_dir
+      @collection = collection
+      @collection_label.set_text "Collection: #{File.basename(@collection_dir)}"
+      @statistics.reset
+      @statistics_label.set_text @statistics.to_s
+      choose_person
+    end
+
+    # Disables the buttons that are only needed when a collection is loaded.
+    def disable_buttons
+      @correct.set_enabled false
+      @wrong.set_enabled false
+      @show.set_enabled false
+    end
+
+    # Enables the buttons that are only needed when a collection is loaded.
+    def enable_buttons
+      @correct.set_enabled true
+      @wrong.set_enabled true
+      @show.set_enabled true
+    end
+
+    # Quits application.
+    def quit
+      Qt::Application.instance.quit
+    end
+
+    # Shows the help window.
+    def show_help
+      Qt::MessageBox.about self, 'Help', Nametrainer.help_message
+    end
+
+    # Displays the name of the shown person and disables the <tt>Display Name</tt> button.
+    def display_name
+      # convert name string from utf-8 to latin1 (for QLabel)
+      if RUBY_VERSION < '1.9'
+        name_latin1 = Iconv.conv('LATIN1', 'UTF-8', @person.name)
+      else
+        name_latin1 = @person.name.encode('ISO-8859-1', 'UTF-8')
+      end
+      @name_label.set_text name_latin1
+      @show.set_enabled false
+    end
+
+    # Called when +Correct+ button is clicked.
+    def correct_answer
+      handle_answer(:correct)
+    end
+
+    # Called when +Wrong+ button is clicked.
+    def wrong_answer
+      handle_answer(:wrong)
+    end
+
+    # Handles correct and wrong answers, and chooses the next person.
+    #
+    # +answer+ - <tt>:correct</tt> or <tt>:wrong</tt>
+    def handle_answer(answer)
+      update_statistics(answer)
+      update_scores(answer)
+      choose_person
+    end
+
+    # Updates the statistics depending on answer.
+    def update_statistics(answer)
+      case answer
+      when :correct
+        @statistics.correct += 1
+      when :wrong
+        @statistics.wrong += 1
+      end
+      @statistics_label.set_text @statistics.to_s
+    end
+
+    # Increases the score for correctly recognized persons.
+    def update_scores(answer)
+      @person.increase_score  if answer == :correct
+    end
+
+    # Displays the image, scaled as large as possible.
+    def show_image
+      @image_label.set_pixmap @image.scaled(@image_label.size, Qt::KeepAspectRatio)
+    end
+
+    # Chooses and displays the next person,
+    # erases the displayed name and enables the <tt>Display Name</tt> button.
+    def choose_person
+      @name_label.set_text ''
+      @person = @collection.sample
+      @image.load @person.image or @image = Qt::Pixmap.new  # delete image when load fails
+      show_image
+      enable_buttons
+    end
+
+    # Repaints the image when the application window is resized.
+    def resizeEvent(event)
+      return  if @image.null? || @image.nil?
+      scaledSize = @image.size.scale(@image_label.size, Qt::KeepAspectRatio)
+      show_image  if scaledSize != @image_label.pixmap.size
+    end
+  end
+end

data/lib/nametrainer/optionparser.rb

@@ -0,0 +1,70 @@
+require 'optparse'
+
+require 'nametrainer/version'
+
+module Nametrainer
+
+  # Parser for the command line options.
+  # The class method parse! does the job.
+  class Optionparser
+
+    # Parses the command line options from +argv+.
+    # (+argv+ is cleared).
+    # Might print out help or version information.
+    #
+    # +argv+ - array with the command line options
+    #
+    # Returns a hash containing the option parameters.
+    def self.parse!(argv)
+
+      options = {
+        :collection => nil,
+        :demo       => false
+      }
+
+      opt_parser = OptionParser.new do |opt|
+        opt.banner = "Usage: #{PROGNAME} [options] [collection]"
+        opt.separator ''
+        opt.separator "#{PROGNAME} is a name learning trainer using Ruby and the Qt GUI toolkit."
+        opt.separator "It will assist you in learning people's names from a collection of images."
+        opt.separator ''
+        opt.separator 'See the project home page for additional information.'
+        opt.separator ''
+        opt.separator 'Options'
+        opt.separator ''
+
+        # process --version and --help first,
+        # exit successfully (GNU Coding Standards)
+        opt.on_tail('-h', '--help', 'Prints a brief help message and exits.') do
+          puts opt_parser
+          puts "\nReport bugs on the #{PROGNAME} home page: <#{HOMEPAGE}>"
+          exit
+        end
+
+        opt.on_tail('-v', '--version',
+                    'Prints a brief version information and exits.') do
+          puts "#{PROGNAME} #{VERSION}"
+          puts COPYRIGHT
+          exit
+        end
+
+        opt.on('-d', '--demo', 'Starts the application with a demo collection.') do
+          options[:demo] = true
+        end
+
+        opt.separator ''
+      end
+      opt_parser.parse!(argv)
+
+      # only collection directory should be left in argv
+      if options[:demo]
+        raise(ArgumentError, 'wrong number of arguments')  if (argv.size != 0 || argv[0] == '')
+      else
+        raise(ArgumentError, 'wrong number of arguments')  if (argv.size > 1 || argv[0] == '')
+        options[:collection] = argv.pop  if argv.size == 1
+      end
+
+      options
+    end
+  end
+end

data/lib/nametrainer/person.rb

@@ -0,0 +1,37 @@
+module Nametrainer
+
+  # A class for persons with name, image, and score.
+  #
+  # Create an instance with
+  #   person = Person.new(name, image)
+  #
+  # Increase the score with
+  #   person.increase_score
+  #
+  # You can sort Person instances by score:
+  #   person1 = Person.new('Albert', nil)
+  #   person2 = Person.new('Isaac', nil)
+  #   person1.increase_score
+  #   puts [person1, person2].sort.map{|p| p.name}  => Isaac, Albert
+  class Person
+
+    attr_reader :name, :image
+    attr_accessor :score
+
+    def initialize(name, image)
+      @name = name
+      @image = image
+      @score = 0
+    end
+
+    # Increases the score by 1.
+    def increase_score
+      @score += 1
+    end
+
+    # Uses score for sorting.
+    def <=>(other)
+      self.score <=> other.score
+    end
+  end
+end

data/lib/nametrainer/statistics.rb

@@ -0,0 +1,42 @@
+module Nametrainer
+
+  # A class for statistics.
+  #
+  # It keeps track of the number of correct and wrong answers.
+  #
+  # Create an instance with
+  #   stats = Statistics.new
+  #
+  # Set the values
+  #   stats.correct = 6
+  #   stats.wrong = 2
+  #
+  # Print the percentage
+  #   puts stats.to_s  => 75 % (6/8)
+  class Statistics
+
+    attr_accessor :correct, :wrong
+
+    def initialize
+      reset
+    end
+
+    # Resets all values to zero.
+    def reset
+      @correct = 0
+      @wrong = 0
+    end
+
+    # Returns the total number of answers.
+    def total
+      @correct + @wrong
+    end
+
+    # Returns a string with percentage and correct and total answers.
+    def to_s
+      percent = (total == 0) ? 0 : (@correct.to_f / total.to_f * 100).to_i
+
+      "#{percent} % (#{@correct}/#{total})"
+    end
+  end
+end

data/lib/nametrainer/version.rb

@@ -0,0 +1,13 @@
+module Nametrainer
+
+  PROGNAME = 'nametrainer'
+  VERSION  = '0.0.1'
+  DATE     = '2012-04-06'
+  HOMEPAGE = 'https://github.com/stomar/nametrainer/'
+
+  COPYRIGHT = "Copyright (C) 2012 Marcus Stollsteimer.\n" +
+              "License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>\n" +
+              "This is free software: you are free to change and redistribute it.\n" +
+              "There is NO WARRANTY, to the extent permitted by law."
+
+end

data/nametrainer.gemspec

@@ -0,0 +1,43 @@
+require 'lib/nametrainer/version'
+
+version  = Nametrainer::VERSION
+date     = Nametrainer::DATE
+homepage = Nametrainer::HOMEPAGE
+
+Gem::Specification.new do |s|
+  s.name              = 'nametrainer'
+  s.version           = version
+  s.date              = date
+  s.rubyforge_project = 'nametrainer'
+
+  s.summary = 'nametrainer is a name learning trainer using the Qt GUI toolkit.'
+  s.description = s.summary + ' ' +
+              'It will assist you in learning people’s names from a collection of images.'
+
+  s.authors = ['Marcus Stollsteimer']
+  s.email = 'sto.mar@web.de'
+  s.homepage = homepage
+
+  s.license = 'GPL-3'
+
+  s.requirements << 'the Qt toolkit and Qt bindings for Ruby'
+
+  s.executables = ['nametrainer']
+  s.bindir = 'bin'
+  s.require_path = 'lib'
+  s.test_files = Dir.glob('test/**/test_*.rb')
+
+  s.rdoc_options = ['--charset=UTF-8']
+
+  s.files = %w{
+      README.md
+      screenshot.png
+      Rakefile
+      nametrainer.gemspec
+    } +
+    Dir.glob('{bin,demo_collection,lib,man,test}/**/*')
+
+  #s.add_dependency('iconv')  # only for 1.8; problematic on Windows (build tools necessary)
+  s.add_development_dependency('rake')
+  s.add_development_dependency('minitest')
+end

data/test/collection/001.txt

@@ -0,0 +1 @@
+Albert Einstein

data/test/collection/002.txt

@@ -0,0 +1 @@
+Paul Dirac

data/test/collection/nametrainer.dat

@@ -0,0 +1,4 @@
+--- 
+Paul Dirac: 1
+Max Born: 2
+Albert Einstein: 3

data/test/test_collection.rb

@@ -0,0 +1,76 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+
+require 'nametrainer/collection'
+
+SRCPATH = File.dirname(__FILE__)
+
+describe Nametrainer::Collection do
+
+  before do
+    extensions = %w{png jpg}
+    @collection = Nametrainer::Collection.new("#{SRCPATH}/collection", extensions)
+    @sample_scores = {
+      'Albert Einstein' => 3,
+      'Paul Dirac' => 1,
+      'Max Born' => 2
+    }
+  end
+
+  it 'can return a name list' do
+    @collection.names.must_include 'Albert Einstein'
+    @collection.names.must_include 'Paul Dirac'
+    @collection.names.must_include 'Max Born'
+  end
+
+  it 'has a size' do
+    @collection.size.must_equal 3
+  end
+
+  it 'can return all the scores' do
+    scores = {
+      'Albert Einstein' => 0,
+      'Paul Dirac' => 0,
+      'Max Born' => 0
+    }
+    @collection.scores.must_equal scores
+  end
+
+  it 'can set all the scores' do
+    @collection.set_scores(@sample_scores)
+    @collection.scores.must_equal @sample_scores
+  end
+
+  it 'can save the scores to a file and load them again' do
+    @collection.set_scores(@sample_scores)
+    @collection.export_scores
+    @collection.first.score = nil
+    @collection.import_scores
+    @collection.scores.must_equal @sample_scores
+  end
+
+  it 'can get sorted by the scores' do
+    @collection.set_scores(@sample_scores)
+    @collection.sort.first.name.must_equal 'Paul Dirac'
+    @collection.sort.last.name.must_equal 'Albert Einstein'
+  end
+
+  it 'can return a random index' do
+    samples = 100
+    indices = Array.new(samples) { @collection.send(:weighted_random_index) }
+    indices.size.must_equal samples
+    indices.sort.first.must_be :>=, 0
+    indices.sort.last.must_be :<, @collection.size
+  end
+
+  it 'can return a random person' do
+    @collection.sample.must_be_instance_of Nametrainer::Person
+  end
+
+  it 'can increase the score for a specified person' do
+    person = @collection.last
+    person.score.must_equal 0
+    person.increase_score
+    @collection.last.score.must_equal 1
+  end
+end

data/test/test_optionparser.rb

@@ -0,0 +1,32 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+
+require 'nametrainer/optionparser'
+
+describe Nametrainer::Optionparser do
+
+  it 'should return the correct default values' do
+    options = Nametrainer::Optionparser.parse!(['collection'])
+    expected = {
+      :collection => 'collection',
+      :demo => false
+    }
+    options.must_equal expected
+  end
+
+  it 'should recognize the -d option' do
+    options = Nametrainer::Optionparser.parse!(['-d'])
+    options[:collection].must_be_nil
+    options[:demo].must_equal true
+  end
+
+  it 'should not accept wrong number of arguments' do
+    lambda { Nametrainer::Optionparser.parse!(['collection1', 'collection2']) }.must_raise ArgumentError
+    lambda { Nametrainer::Optionparser.parse!(['']) }.must_raise ArgumentError
+    lambda { Nametrainer::Optionparser.parse!(['-d', 'collection']) }.must_raise ArgumentError
+  end
+
+  it 'should not accept invalid options' do
+    lambda { Nametrainer::Optionparser.parse!(['-x']) }.must_raise OptionParser::InvalidOption
+  end
+end

data/test/test_person.rb

@@ -0,0 +1,32 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+
+require 'nametrainer/person'
+
+describe Nametrainer::Person do
+
+  before do
+    @person = Nametrainer::Person.new('Albert Einstein', 'image01.jpg')
+  end
+
+  it 'has a name, an associated image file and a score' do
+    @person.name.must_equal 'Albert Einstein'
+    @person.image.must_equal 'image01.jpg'
+    @person.score.must_equal 0
+  end
+
+  it 'can increase its score' do
+    @person.score.must_equal 0
+    @person.increase_score
+    @person.score.must_equal 1
+  end
+
+  it 'can get sorted by score' do
+    p1 = Nametrainer::Person.new('Albert', nil)
+    p2 = Nametrainer::Person.new('Isaac', nil)
+    p1.score = 1
+    [p1, p2].sort.map{|p| p.name}.must_equal ['Isaac', 'Albert']
+    p2.score = 2
+    [p1, p2].sort.map{|p| p.name}.must_equal ['Albert', 'Isaac']
+  end
+end

data/test/test_statistics.rb

@@ -0,0 +1,48 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+
+require 'nametrainer/statistics'
+
+describe Nametrainer::Statistics do
+
+  before do
+    @stats = Nametrainer::Statistics.new
+  end
+
+  it 'has the correct initial values' do
+    @stats.correct.must_equal 0
+    @stats.wrong.must_equal 0
+    @stats.total.must_equal 0
+  end
+
+  it 'can set its attributes' do
+    @stats.correct = 3
+    @stats.correct.must_equal 3
+    @stats.wrong = 2
+    @stats.wrong.must_equal 2
+  end
+
+  it 'knows the total' do
+    @stats.correct = 8
+    @stats.wrong = 2
+    @stats.total.must_equal 10
+  end
+
+  it 'can be reset' do
+    @stats.correct = 12
+    @stats.wrong = 8
+    @stats.total.must_equal 20
+    @stats.reset
+    @stats.total.must_equal 0
+  end
+
+  it 'can print the statistics for total = 0' do
+    @stats.to_s.must_equal '0 % (0/0)'
+  end
+
+  it 'can print the statistics' do
+    @stats.correct = 9
+    @stats.wrong = 11
+    @stats.to_s.must_equal '45 % (9/20)'
+  end
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification 
+name: nametrainer
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Marcus Stollsteimer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-04-06 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: "nametrainer is a name learning trainer using the Qt GUI toolkit. It will assist you in learning people\xE2\x80\x99s names from a collection of images."
+email: sto.mar@web.de
+executables: 
+- nametrainer
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- screenshot.png
+- Rakefile
+- nametrainer.gemspec
+- bin/nametrainer
+- demo_collection/Erwin_Schroedinger.png
+- demo_collection/Erwin_Schroedinger.txt
+- demo_collection/Felix_Bloch.png
+- demo_collection/Max_Planck.png
+- demo_collection/Max_Born.png
+- demo_collection/Paul_Dirac.png
+- demo_collection/Werner_Heisenberg.png
+- demo_collection/Albert_Einstein.png
+- lib/nametrainer/optionparser.rb
+- lib/nametrainer/gui.rb
+- lib/nametrainer/version.rb
+- lib/nametrainer/person.rb
+- lib/nametrainer/collection.rb
+- lib/nametrainer/statistics.rb
+- lib/nametrainer.rb
+- test/test_person.rb
+- test/test_statistics.rb
+- test/test_collection.rb
+- test/test_optionparser.rb
+- test/collection/002.txt
+- test/collection/001.jpg
+- test/collection/001.txt
+- test/collection/Max_Born.png
+- test/collection/002.JPG
+- test/collection/nametrainer.dat
+homepage: https://github.com/stomar/nametrainer/
+licenses: 
+- GPL-3
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+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: 
+- the Qt toolkit and Qt bindings for Ruby
+rubyforge_project: nametrainer
+rubygems_version: 1.7.2
+signing_key: 
+specification_version: 3
+summary: nametrainer is a name learning trainer using the Qt GUI toolkit.
+test_files: 
+- test/test_person.rb
+- test/test_statistics.rb
+- test/test_collection.rb
+- test/test_optionparser.rb