to_pass 0.2.4 → 0.4.0

data/Rakefile

@@ -24,20 +24,24 @@ rescue LoadError
   puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
 end
 
-%w[ rake/rdoctask sdoc ].each { |lib| require lib }
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'doc/rdoc'
-  rdoc.title = "to_pass #{version}"
-  rdoc.options << '--fmt' << 'shtml'
-  rdoc.template = 'direct'
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+# documentation task
+begin
+  %w[ rake/rdoctask sdoc ].each { |lib| require lib }
+  Rake::RDocTask.new do |rdoc|
+    version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+    rdoc.rdoc_dir = 'doc/rdoc'
+    rdoc.title = "to_pass #{version}"
+    rdoc.options << '--fmt' << 'shtml'
+    rdoc.template = 'direct'
+    rdoc.rdoc_files.include('README*')
+    rdoc.rdoc_files.include('lib/**/*.rb')
+  end
+rescue LoadError
 end
 
 desc "run tests"
-task :test, :needs => [:check_dependencies] do
+task :test do
   # optional libraries
   %w[ redgreen ].each do |lib|
     begin
@@ -50,4 +54,32 @@ task :test, :needs => [:check_dependencies] do
   end
 end
 
+desc "list available algorithms"
+task :algorithms, :needs => [:to_pass] do
+  puts ""
+  puts "  available password algorithms"
+  puts "  ============================================"
+  ToPass::AlgorithmReader.discover.each do |algorithm|
+    puts "  - #{algorithm}"
+  end
+  puts "  ============================================"
+  puts ""
+end
+
+desc "list available converters"
+task :converters, :needs => [:to_pass] do
+  puts ""
+  puts "  available converters for password algorithms"
+  puts "  ============================================"
+  ToPass::ConverterReader.new.discover.each do |converter|
+    puts "  - #{converter}"
+  end
+  puts "  ============================================"
+  puts ""
+end
+
+task :to_pass do
+  require 'lib/to_pass'
+end
+
 task :default => :test

data/TODO

@@ -1,9 +1,28 @@
 UP NEXT
 ============================================================================
-- test and enble class methods of Converter-class
+- make it debian compatible (most of which is common sense anyway)
+  http://pkg-ruby-extras.alioth.debian.org/upstream-devs.html
+  - Distribute your software as a source code archive
+  - Use setup.rb
+  - Remove all references to rubygems in the software you ship
+  - Don’t make your Rakefile depend on RubyGems
+  - Make your tests and examples usable outside of your directory tree
+  - Use a shebang that works everywhere
+  - Provide man pages for your binaries
+  - If possible, maintain a backward-compatible API
+
+- Man-Pages http://www.linuxhowtos.org/System/creatingman.htm
+  order:
+    NAME
+    SYNOPSIS
+    DESCRIPTION
+    OPTIONS
+    BUGS
+    AUTHOR
+    SEE ALSO
+
 
 SOMEDAY
 ============================================================================
 - move decision wether a string is a word or not into algorithm definition.
-- make conversion-functions more pluggable
 - test on windows

data/VERSION

@@ -1 +1 @@
-0.2.4
+0.4.0

data/lib/to_pass/algorithm_reader.rb

@@ -4,7 +4,7 @@
 require 'pathname'
 require 'yaml'
 
-# The AlgorithmReader's primary API is the load the rules from a YAML-file
+# The AlgorithmReader's primary API is to load the rules from a YAML-file
 # into a Hash.
 #
 # Algorithms are searched in the following locations
@@ -20,7 +20,7 @@ class ToPass::AlgorithmReader
     @load_path = []
     [
       '~/.to_pass/algorithms',
-      "#{File.dirname(__FILE__)}/../algorithms"
+      "#{File.dirname(__FILE__)}/algorithms"
     ].each do |dir|
       dir = Pathname.new(dir).expand_path
       @load_path << dir if dir.exist?
@@ -32,6 +32,15 @@ class ToPass::AlgorithmReader
     def load(algorithm)
       new(algorithm).load_from_file
     end
+
+    # searches for available algorithms
+    def discover
+      new(nil).load_path.collect do |dir|
+        Dir["#{dir}/*.yml"]
+      end.flatten.compact.map do |fn|
+        File.basename(fn).gsub('.yml', '')
+      end
+    end
   end
 
   def load_from_file # :nodoc:

data/lib/{algorithms → to_pass/algorithms}/basic_de.yml

@@ -1,14 +1,14 @@
 desc: Basic Algorithm with a german usage in mind
 name: Basic (german)
 sentence:
-  - table: words
+  - replace: words
   - first_chars
-  - table: symbols
+  - replace: symbols
   - collapse_chars
 word:
-  - table: chars
-  - table: symbols
-tables:
+  - replace: chars
+  - replace: symbols
+replacements:
   words:
     ein: 1
     eine: 1

data/lib/{algorithms → to_pass/algorithms}/basic_en.yml

@@ -1,14 +1,14 @@
 desc: Basic Algorithm with a english usage in mind
 name: Basic (english)
 sentence:
-  - table: words
+  - replace: words
   - first_chars
-  - table: symbols
+  - replace: symbols
   - collapse_chars
 word:
-  - table: chars
-  - table: symbols
-tables:
+  - replace: chars
+  - replace: symbols
+replacements:
   words:
     one: 1
     single: 1

data/lib/to_pass/cli.rb

@@ -12,7 +12,7 @@ module ToPass
     end
 
     def output
-      if @options[:pipe_usage]
+      if @options[:pipe_out]
         $stdout << @password
       else
         puts @password
@@ -24,7 +24,9 @@ module ToPass
     # parse the options
     def parse_options
       options = {
-        :algorithm  => 'basic_de'
+        :algorithm => 'basic_de',
+        :pipe_out  => false,
+        :pipe_in   => false
       }
 
       OptionParser.new do |opts|
@@ -35,6 +37,10 @@ module ToPass
           options[:algorithm] = value
         end
 
+        opts.on('-p', '--[no-]pipe', "pipe result to stdout (without trailing linebreak)") do |value|
+          options[:pipe_out] = value
+        end
+
         opts.separator ""
 
         opts.on_tail("-h", "--help", "Show this message") do
@@ -43,14 +49,16 @@ module ToPass
         end
       end.parse!
 
-      options[:pipe_usage] = ARGV[0].nil?
+      if ARGV[0].nil?
+        options[:pipe_in] = options[:pipe_out] = true
+      end
 
       options
     end
 
     # get the input string
     def get_input_string
-      unless @options[:pipe_usage]
+      unless @options[:pipe_in]
         ARGV[0]
       else
         $stdin.read.chomp

data/lib/to_pass/converter.rb

@@ -10,9 +10,12 @@ module ToPass
   # a more complete description of the algorithm capabilities
   # is still pending.
   class Converter
+    attr_accessor :converters, :rules
     # create a new converter, based on a set of conversion-rules
     def initialize( rules )
       @rules = rules
+      @reader = ConverterReader.new
+      @converters = @reader.discover
     end
 
     # convert a string into a password
@@ -31,9 +34,16 @@ module ToPass
     #   end
     # end
 
-    protected
-
-    include StringConversions
+    # proxy to converters
+    def respond_to?(method_name) # :nodoc:
+      if [:convert, :rules_for, :process].include? method_name.to_sym
+        true
+      elsif @converters.include? method_name.to_sym
+        true
+      else
+        super
+      end
+    end
 
     private
 
@@ -52,13 +62,20 @@ module ToPass
     # process the string, rule by rule
     def process(string, rules)
       rules.inject(string) do |pwd, rule|
-        if rule.is_a?(String) and respond_to?(rule.to_sym)
-          send(rule.to_sym, pwd)
-        elsif rule.is_a?(Hash) and rule.has_key?('table')
-          replace(pwd, @rules['tables'][rule.fetch('table')])
-        else
-          pwd
-        end
+        apply_rule(pwd, rule)
+      end
+    end
+
+    # apply a single rule to the password-to-be
+    def apply_rule(pwd, rule)
+      cmd, args = rule.to_a.flatten
+      m = @reader.load(cmd.to_sym).method(cmd.to_sym)
+
+      case m.arity
+      when 1
+        m.call(pwd)
+      when 3, -2
+        m.call(pwd, @rules, *args)
       end
     end
   end

data/lib/to_pass/converter_reader.rb

@@ -0,0 +1,107 @@
+# -*- coding: utf-8 -*-
+# vim:ft=ruby:enc=utf-8
+
+require 'pathname'
+
+# The ConverterReader's primary API is to load the converters from right
+# directories into an Array
+#
+# Converters are searched in the following locations
+#
+# 1. ~/.to_pass/converters
+# 2. bundled converters of gem
+#
+# The bundled converter are, however, lazily loaded with autoload.
+# User-provided converters are always required (for now).
+#
+class ToPass::ConverterReader
+  attr_reader :load_path, :loaded
+
+  def initialize # :nodoc:
+    @load_path  = []
+    @loaded     = []
+    @discovered = []
+    [
+      '~/.to_pass/converters',
+      "#{File.dirname(__FILE__)}/converters"
+    ].each do |dir|
+      dir = Pathname.new(dir).expand_path
+      @load_path << dir if dir.exist?
+    end
+  end
+
+  # loads the converters
+  def load(converter)
+    unless @loaded.include?(converter.to_sym)
+      load_from_file(converter)
+      @loaded << converter
+    end
+
+    classname(converter)
+  end
+
+  # discover a list of available converters
+  def discover
+    search_for_converters
+  end
+
+  private
+
+  def search_for_converters # :nodoc:
+    files = load_path.collect do |directory|
+      dir = Pathname.new(directory)
+      if dir.exist?
+        Dir["#{dir}/*.rb"].collect do |converter|
+          fn_re = %r!/([^/]*)\.rb$!i
+          name  = converter.match(fn_re)
+          if name
+            name[1].to_sym
+          end
+        end
+      end
+    end.flatten.compact
+
+    raise LoadError, "converters could not be found in #{load_path}" if files.nil?
+
+    @discovered = files
+  end
+
+  def load_from_file(converter) # :nodoc:
+    fn = load_path.collect do |dir|
+      path = Pathname.new("#{dir}/#{converter}.rb").expand_path
+
+      if path.exist?
+        path
+      else
+        next
+      end
+    end.compact.first
+
+    raise LoadError, "converter '#{converter}' could not be found in #{load_path}" if fn.nil?
+
+    if require fn
+      classname converter
+    end
+  end
+
+  def classname(converter) # :nodoc:
+    constantize("ToPass::Converters::#{camel_case(converter)}")
+  end
+
+  def constantize(camel_cased_word) # :nodoc:
+    names = camel_cased_word.split('::')
+    names.shift if names.empty? || names.first.empty?
+
+    constant = Object
+    names.each do |name|
+      constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+    end
+    constant
+  end
+
+  def camel_case(underscored_word) # :nodoc:
+    camel_cased_word = underscored_word.to_s.split('_').map do |part|
+      part.capitalize
+    end.join('')
+  end
+end

data/lib/to_pass/converters/collapse_chars.rb

@@ -0,0 +1,12 @@
+module ToPass::Converters
+  class CollapseChars
+    class << self
+      # all the blanks are removed.
+      #
+      # this is useful if you convert a sentence into a password.
+      def collapse_chars(string)
+        string = string.split(' ').join('')
+      end
+    end
+  end
+end

data/lib/to_pass/converters/first_chars.rb

@@ -0,0 +1,12 @@
+module ToPass::Converters
+  class FirstChars
+    class << self
+      # reduces every word to its first character, preserving case
+      def first_chars(string)
+        string.split(' ').map do |word|
+          word[0].chr
+        end.join(' ')
+      end
+    end
+  end
+end

data/lib/to_pass/converters/replace.rb

@@ -0,0 +1,12 @@
+module ToPass::Converters
+  class Replace
+    class << self
+      # perform replacements on a string, based on a replacment table
+      def replace(string, rules, tablename)
+        rules['replacements'][tablename].inject(string) do |pwd, map|
+          pwd = pwd.gsub(/#{map[0].to_s}/, map[1].to_s)
+        end
+      end
+    end
+  end
+end

data/lib/to_pass/converters/swapcase.rb

@@ -0,0 +1,25 @@
+module ToPass::Converters
+  class Swapcase
+    class << self
+      # alternate case of letter (not numbers)
+      def swapcase(string)
+        pwd = ""
+        last_upcase = true
+
+        string.each_char do |char|
+          char = if char.between?("0", "9")
+                   char
+                 elsif last_upcase
+                   last_upcase = false
+                   char.downcase
+                 else
+                   last_upcase = true
+                   char.upcase
+                 end
+          pwd << char
+        end
+        pwd
+      end
+    end
+  end
+end

data/lib/to_pass/converters.rb

@@ -0,0 +1,14 @@
+# -*- coding: utf-8 -*-
+# vim:ft=ruby:enc=utf-8
+
+module ToPass
+  # The Converters-class is a collection of available
+  # Transformations. Every method is given a string as single argument
+  # and is expected to return a transformed string. The only exception
+  # from this is general rule is the replace method which also takes a
+  # replacement table.
+  #
+  # This enables chaining and eases extending the capabilities.
+  module Converters
+  end
+end

data/lib/to_pass.rb

@@ -13,6 +13,7 @@ module ToPass
   autoload :Base,              'lib/to_pass/base'
   autoload :Cli,               'lib/to_pass/cli.rb'
   autoload :Converter,         'lib/to_pass/converter'
+  autoload :ConverterReader,   'lib/to_pass/converter_reader'
+  autoload :Converters,        'lib/to_pass/converters'
   autoload :Integration,       'lib/to_pass/integration'
-  autoload :StringConversions, 'lib/to_pass/string_conversions'
 end

data/test/fixtures/user_alg.yml

@@ -2,13 +2,13 @@ desc: Test Algorithm
 name: Test
 sentence:
   - first_chars
-  - table: chars
-  - table: symbols
+  - replace: chars
+  - replace: symbols
   - collapse_chars
 word:
-  - table: chars
-  - table: symbols
-tables:
+  - replace: chars
+  - replace: symbols
+replacements:
   symbols:
     p: '%'
     s: '/'

data/test/fixtures/user_converter.rb

@@ -0,0 +1,17 @@
+# -*- coding: utf-8 -*-
+# vim:ft=ruby:enc=utf-8
+
+module ToPass::Converters
+  # replace the string "USER" with the current username
+  class Userize
+    def self.convert(string) # :nodoc:
+      username = if `which whoami`
+                   `whoami`.chomp
+                 else
+                   "thecurrentuser"
+                 end
+
+      string.gsub("USER",username)
+    end
+  end
+end

data/test/helper.rb

@@ -27,10 +27,16 @@ Test::Unit::TestCase.class_eval do
 
 
   def with_algorithm_in_user_dir
-    `mkdir -p ~/to_pass/algorithms; cp -f #{File.dirname(__FILE__)}/fixtures/user_alg.yml ~/.to_pass/algorithms/user_alg.yml`
+    `mkdir -p ~/.to_pass/algorithms; cp -f #{File.dirname(__FILE__)}/fixtures/user_alg.yml ~/.to_pass/algorithms/user_alg.yml`
     yield
     `rm ~/.to_pass/algorithms/user_alg.yml`
   end
+
+  def with_converters_in_user_dir
+    `mkdir -p ~/.to_pass/converters; cp -f #{File.dirname(__FILE__)}/fixtures/user_converter.rb ~/.to_pass/converters/userize.rb`
+    yield
+    `rm ~/.to_pass/converters/userize.rb`
+  end
 end
 
 require 'lib/to_pass'

data/test/test_algorithm_reader.rb

@@ -17,6 +17,11 @@ class TestAlgorithmReader < Test::Unit::TestCase
     assert_kind_of Hash, klass.load(:basic_de)
   end
 
+  def test_discover
+    assert_respond_to klass, :discover
+    assert_kind_of Array, klass.discover
+  end
+
   def test_has_load_path
     assert_respond_to reader, :load_path
     assert_kind_of Array, reader.load_path
@@ -25,7 +30,7 @@ class TestAlgorithmReader < Test::Unit::TestCase
   def test_load_path_contains_standard_dirs
     dirs = [
       '~/.to_pass/algorithms' ,
-      "#{File.dirname(__FILE__)}/../lib/algorithms"
+      "#{File.dirname(__FILE__)}/../lib/to_pass/algorithms"
     ]
 
     Pathname.any_instance.expects(:exist?).times(dirs.size).returns(true)

data/test/test_cli.rb

@@ -24,6 +24,18 @@ class TestCli < Test::Unit::TestCase
     end
   end
 
+  def test_cli_usage_with_pipe_input
+    assert_nothing_raised do
+      assert_equal 't35t', `echo "test" | bin/to_pass --no-pipe`.chomp
+    end
+  end
+
+  def test_cli_usage_with_pipe_output
+    assert_nothing_raised do
+      assert_equal 't35t', `bin/to_pass test --pipe`
+    end
+  end
+
 
   def test_cli_usage_with_user_algorithm
     with_algorithm_in_user_dir do

data/test/test_converter.rb

@@ -25,33 +25,34 @@ class TestConverter < Test::Unit::TestCase
   # mock-tests to ensure presence and calling of protected methods
   def test_replace
     assert_respond_to converter, :replace
-    converter.expects(:replace).once
+    converter.expects(:apply_rule).with("test", {'replace'=>'special'}).once
 
     converter.convert("test")
   end
   def test_swapcase
     converter({'word' => ['swapcase']})
     assert_respond_to converter, :swapcase
-    converter.expects(:swapcase).once
+    converter.expects(:apply_rule).with("test",  'swapcase' ).once
     converter.convert("test")
   end
   def test_first_chars
     converter({'sentence' => ['first_chars']})
     assert_respond_to converter, :first_chars
-    converter.expects(:first_chars).once
+    converter.expects(:apply_rule).with("test test", 'first_chars').once
     converter.convert("test test")
   end
   def test_collapse_chars
     converter({'sentence' => ['collapse_chars']})
     assert_respond_to converter, :collapse_chars
-    converter.expects(:collapse_chars).once
+    converter.expects(:apply_rule).with("test test", 'collapse_chars').once
     converter.convert("test test")
   end
 
+
   # more complex/real-life setups
   def test_multiple_rules
     converter(basic_rules.merge({
-      'word' => [{'table' => 'special'}, 'swapcase']
+      'word' => [{'replace' => 'special'}, 'swapcase']
     }))
 
     assert_equal( "t35T", converter.convert('test'))
@@ -67,6 +68,34 @@ class TestConverter < Test::Unit::TestCase
 Pferd	auf	dem	Flur"))
   end
 
+
+  # actual result-testing
+  def test_replacement
+    rules = {
+      'replacements' => {
+        'numbers' => {
+          :e => 3,
+          :s => 5
+        }
+      }
+    }
+    result = converter(rules).send(:apply_rule, "test", {'replace'=>'numbers'})
+    assert_equal "t35t", result
+  end
+  def test_case_swapping
+    assert_equal "tEsT", converter.send(:apply_rule, "test", 'swapcase')
+  end
+  def test_case_swapping_ignores_numbers
+    assert_equal "tEsT4fUn", converter.send(:apply_rule, "test4fun", 'swapcase')
+    assert_equal "fUn4TeSt", converter.send(:apply_rule, "fun4test", 'swapcase')
+  end
+  def test_char_collapsing
+    assert_equal "abc", converter.send(:apply_rule, "a b c", 'collapse_chars')
+  end
+  def test_select_first_chars
+    assert_equal "t a t f t", converter.send(:apply_rule, "test all the fucking time", 'first_chars')
+  end
+
   protected
 
   def converter(rules = basic_rules)
@@ -75,8 +104,8 @@ Pferd	auf	dem	Flur"))
 
   def basic_rules
     {
-      'word' => [{ 'table' => 'special' }],
-      'tables' => {
+      'word' => [{ 'replace' => 'special' }],
+      'replacements' => {
         'special' => {
           'e' => '3',
           's' => '5'
@@ -86,8 +115,8 @@ Pferd	auf	dem	Flur"))
   end
   def complex_rules
     {
-      'sentence' => [{'table'=>'words'},'first_chars','collapse_chars',{'table'=>'symbols'}],
-      'tables' => {
+      'sentence' => [{'replace'=>'words'},'first_chars','collapse_chars',{'replace'=>'symbols'}],
+      'replacements' => {
         'words' => { 'ein' => '1' },
         'symbols' => { 'a' => '@' }
       }

data/test/test_converter_reader.rb

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+# vim:ft=ruby:enc=utf-8
+
+require File.dirname(__FILE__)+'/helper'
+
+class TestConverterReader < Test::Unit::TestCase
+  test_presence ToPass::ConverterReader
+
+  def test_load
+    assert_respond_to reader, :load
+    assert_kind_of Class, reader.load(:replace)
+  end
+
+  def test_discover
+    assert_respond_to reader, :discover
+    assert_kind_of Array, reader.discover
+  end
+
+  def test_has_load_path
+    assert_respond_to reader, :load_path
+    assert_kind_of Array, reader.load_path
+  end
+
+  def test_knows_loaded_converters
+    assert_respond_to reader, :loaded
+    assert_kind_of Array, reader.loaded
+    assert_equal 0, reader.loaded.size
+
+    reader.load(:replace)
+    reader.load(:first_chars)
+
+    assert_equal 2, reader.loaded.size
+    assert_equal :replace, reader.loaded.first
+  end
+
+  def test_load_path_contains_standard_dirs
+    dirs = [
+      '~/.to_pass/converters',
+      "#{File.dirname(__FILE__)}/../lib/to_pass/converters"
+    ]
+
+    Pathname.any_instance.expects(:exist?).times(dirs.size).returns(true)
+
+    dirs.each do |reldir|
+      dir = Pathname.new(reldir).expand_path
+      assert( reader.load_path.include?(dir), "#{reader.load_path.inspect} should include #{dir.inspect}" )
+    end
+  end
+
+  def test_loads_from_user_dir
+    with_converters_in_user_dir do
+      assert_kind_of Class, reader.load(:userize), "Converter 'Userize' should have been found"
+    end
+  end
+
+  protected
+
+  def klass
+    ToPass::ConverterReader
+  end
+  def reader
+    @reader ||= klass.new
+  end
+end

data/test/test_converters.rb

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+# vim:ft=ruby:enc=utf-8
+
+require File.dirname(__FILE__)+'/helper'
+
+class TestConverters < Test::Unit::TestCase
+  def test_presence
+    assert_module_defined ToPass::Converters
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: to_pass
 version: !ruby/object:Gem::Version 
-  hash: 31
+  hash: 15
   prerelease: false
   segments: 
   - 0
-  - 2
   - 4
-  version: 0.2.4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Matthias Viehweger
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-24 00:00:00 +02:00
+date: 2010-06-30 00:00:00 +02:00
 default_executable: to_pass
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -66,23 +66,30 @@ files:
 - TODO
 - VERSION
 - bin/to_pass
-- lib/algorithms/basic_de.yml
-- lib/algorithms/basic_en.yml
 - lib/to_pass.rb
 - lib/to_pass/algorithm_reader.rb
+- lib/to_pass/algorithms/basic_de.yml
+- lib/to_pass/algorithms/basic_en.yml
 - lib/to_pass/base.rb
 - lib/to_pass/cli.rb
 - lib/to_pass/converter.rb
+- lib/to_pass/converter_reader.rb
+- lib/to_pass/converters.rb
+- lib/to_pass/converters/collapse_chars.rb
+- lib/to_pass/converters/first_chars.rb
+- lib/to_pass/converters/replace.rb
+- lib/to_pass/converters/swapcase.rb
 - lib/to_pass/integration.rb
-- lib/to_pass/string_conversions.rb
 - test/fixtures/user_alg.yml
+- test/fixtures/user_converter.rb
 - test/helper.rb
 - test/test_algorithm_reader.rb
 - test/test_base.rb
 - test/test_cli.rb
 - test/test_converter.rb
+- test/test_converter_reader.rb
+- test/test_converters.rb
 - test/test_integration.rb
-- test/test_string_conversions.rb
 has_rdoc: true
 homepage: http://github.com/kronn/to_pass
 licenses: []
@@ -118,10 +125,12 @@ signing_key:
 specification_version: 3
 summary: generate password from words or sentences
 test_files: 
+- test/fixtures/user_converter.rb
 - test/helper.rb
 - test/test_algorithm_reader.rb
 - test/test_base.rb
 - test/test_cli.rb
 - test/test_converter.rb
+- test/test_converter_reader.rb
+- test/test_converters.rb
 - test/test_integration.rb
-- test/test_string_conversions.rb

data/lib/to_pass/string_conversions.rb

@@ -1,54 +0,0 @@
-# -*- coding: utf-8 -*-
-# vim:ft=ruby:enc=utf-8
-
-module ToPass
-  # The StringConversions-Module is a collection of available
-  # Transformations. Every method is given a string as single argument
-  # and is expected to return a transformed string. The only exception
-  # from this is general rule is the replace method which also takes a
-  # replacement table.
-  #
-  # This enables chaining and eases extending the capabilities.
-  module StringConversions
-    # all the blanks are removed.
-    #
-    # this is useful if you convert a sentence into a password.
-    def collapse_chars(string)
-      string = string.split(' ').join('')
-    end
-
-    # reduces every word to its first character, preserving case
-    def first_chars(string)
-      string.split(' ').map do |word|
-        word[0].chr
-      end.join(' ')
-    end
-
-    # alternate case of letter (not numbers)
-    def swapcase(string)
-      pwd = ""
-      last_upcase = true
-
-      string.each_char do |char|
-        char = if char.between?("0", "9")
-                 char
-               elsif last_upcase
-                 last_upcase = false
-                 char.downcase
-               else
-                 last_upcase = true
-                 char.upcase
-               end
-        pwd << char
-      end
-      pwd
-    end
-
-    # perform replacements on a string, based on a replacment table
-    def replace(string, table)
-      table.inject(string) do |pwd, map|
-        pwd = pwd.gsub(/#{map[0].to_s}/, map[1].to_s)
-      end
-    end
-  end
-end

data/test/test_string_conversions.rb

@@ -1,40 +0,0 @@
-# -*- coding: utf-8 -*-
-# vim:ft=ruby:enc=utf-8
-
-require File.dirname(__FILE__)+'/helper'
-
-class TestStringConversion < Test::Unit::TestCase
-  def test_replacement
-    result = converter.replace("test", {
-      :e => 3,
-      :s => 5
-    })
-    assert_equal "t35t", result
-  end
-
-  def test_case_swapping
-    assert_equal "tEsT", converter.swapcase("test")
-  end
-
-  def test_case_swapping_ignores_numbers
-    assert_equal "tEsT4fUn", converter.swapcase("test4fun")
-
-    assert_equal "fUn4TeSt", converter.swapcase("fun4test")
-  end
-
-  def test_char_collapsing
-    assert_equal "abc", converter.collapse_chars("a b c")
-  end
-
-  def test_select_first_chars
-    assert_equal "t a t f t", converter.first_chars('test all the fucking time')
-  end
-
-  protected
-
-  def converter
-    klass = Class.new
-    klass.send(:extend, ToPass::StringConversions)
-    klass
-  end
-end