to_pass 0.2.2

data/.gitignore

@@ -0,0 +1,5 @@
+.*.swp
+vendor/*.rb
+doc/rdoc/*
+tmp/*
+pkg/*

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009-2010 Matthias Viehweger
+
+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.

data/README.rdoc

@@ -0,0 +1,48 @@
+= to_pass
+
+== Transformation of a String to a Password.
+
+Passwords should be easy to remember and hard to guess.  One technique is to
+have a sentence which can be easily remembered transformed to a password.
+
+This library encapsulates that and satisfies different usage scenarios.
+Currently, only two algorithms are provided. But they are YAML-Files, so it's
+extensible.
+
+== Usage
+
+=== IRB
+
+ToPass::Integration provides a to_pass Method which transforms a sentence to a
+password.
+
+  irb> require 'lib/to_pass'
+  irb> String.send(:include, ToPass::Integration)
+  irb> "Da steht ein Pferd auf dem Flur".to_pass
+  # => "Ds1P@dF"
+
+=== CLI
+
+  $ to_pass "test"   # => t35t
+  $ to_pass "there is one problem for us, too" -a basic_en # => ti1p4u2
+
+=== CLI with Pipes
+
+This example is Mac OSX-centric, but you should get the point.
+
+  $ echo "test" | to_pass | pbcopy
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a
+  commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Matthias Viehweger. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,53 @@
+# -*- coding: utf-8 -*-
+# vim:ft=ruby:enc=utf-8
+
+# # enable trace to get better error output
+# Rake.application.options.trace = true
+
+# jeweler task
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "to_pass"
+    gem.summary = "generate password from words or sentences"
+    gem.description = %Q{Passwords should be easy to remember and hard to guess.
+One technique is to have a sentence which can be easily remembered transformed to a password.}
+    gem.email = "kronn@kronn.de"
+    gem.homepage = "http://github.com/kronn/to_pass"
+    gem.authors = ["Matthias Viehweger"]
+
+    gem.add_development_dependency 'mocha'
+    gem.add_development_dependency 'sdoc'
+  end
+  Jeweler::GemcutterTasks.new
+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')
+end
+
+desc "run tests"
+task :test, :needs => [:check_dependencies] do
+  # optional libraries
+  %w[ redgreen ].each do |lib|
+    begin
+      require lib
+    rescue LoadError
+    end
+  end
+  ( ['test/unit', 'test/helper'] + Dir['test/test_*.rb'] ).each do |file|
+    require file
+  end
+end
+
+task :default => :test

data/TODO

@@ -0,0 +1,9 @@
+UP NEXT
+============================================================================
+- test and enble class methods of Converter-class
+
+SOMEDAY
+============================================================================
+- move decision wether a string is a word or not into algorithm definition.
+- make conversion-functions more pluggable
+- test on windows

data/VERSION

@@ -0,0 +1 @@
+0.2.2

data/bin/to_pass

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+# vim:ft=ruby:enc=utf-8
+
+base_path = ( File.expand_path(File.dirname(__FILE__)+'/..') )
+$LOAD_PATH << base_path unless $LOAD_PATH.include?(base_path)
+
+require 'optparse'
+require 'lib/to_pass'
+
+# parse options
+options = {
+  :pipe_usage => ARGV[0].nil?,
+  :algorithm  => 'basic_de'
+}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: #{__FILE__} [options] passphrase"
+  opts.separator ""
+
+  opts.on('-a', '--algorithm ALGORITM', "use specified algorithm for transformation") do |value|
+    options[:algorithm] = value
+  end
+
+  opts.separator ""
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+end.parse!
+
+# get input string
+string= unless options[:pipe_usage]
+          ARGV[0]
+        else
+          $stdin.read.chomp
+        end
+
+# perform "heavy" work
+password = ToPass::Base.new( string, options[:algorithm] ).to_s
+
+if options[:pipe_usage]
+  $stdout << password
+else
+  puts password
+end

data/lib/algorithms/basic_de.yml

@@ -0,0 +1,30 @@
+desc: Basic Algorithm with a german usage in mind
+name: Basic (german)
+sentence:
+  - table: words
+  - first_chars
+  - table: symbols
+  - collapse_chars
+word:
+  - table: chars
+  - table: symbols
+tables:
+  words:
+    ein: 1
+    eine: 1
+    zwei: 2
+    drei: 3
+    vier: 4
+    fuenf: 5
+    sechs: 6
+    sieben: 7
+    acht: 8
+    neun: 9
+  symbols:
+    a: '@'
+  chars:
+    a: 4
+    e: 3
+    i: 1
+    o: 0
+    s: 5

data/lib/algorithms/basic_en.yml

@@ -0,0 +1,32 @@
+desc: Basic Algorithm with a english usage in mind
+name: Basic (english)
+sentence:
+  - table: words
+  - first_chars
+  - table: symbols
+  - collapse_chars
+word:
+  - table: chars
+  - table: symbols
+tables:
+  words:
+    one: 1
+    single: 1
+    two: 2
+    too: 2
+    three: 3
+    four: 4
+    for: 4
+    five: 5
+    six: 6
+    seven: 7
+    eight: 8
+    nine: 9
+  symbols:
+    a: '@'
+  chars:
+    a: 4
+    e: 3
+    i: 1
+    o: 0
+    s: 5

data/lib/to_pass/algorithm_reader.rb

@@ -0,0 +1,47 @@
+require 'pathname'
+require 'yaml'
+
+# The AlgorithmReader's primary API is the load the rules from a YAML-file
+# into a Hash.
+#
+# Algorithms are searched in the following locations
+#
+# 1. ~/.to_pass/algorithms
+# 2. bundled algorithms of gem
+#
+class ToPass::AlgorithmReader
+  attr_reader :load_path
+
+  def initialize(algorithm) # :nodoc:
+    @algorithm = algorithm
+    @load_path = []
+    [
+      '~/.to_pass/algorithms',
+      "#{File.dirname(__FILE__)}/../algorithms"
+    ].each do |dir|
+      dir = Pathname.new(dir)
+      @load_path << dir.expand_path if dir.exist?
+    end
+  end
+
+  class << self
+    # load an algorithm with a given identifier
+    def load(algorithm)
+      new(algorithm).load_from_file
+    end
+  end
+
+  def load_from_file # :nodoc:
+    fn = load_path.map do |dir|
+      file = Pathname.new("#{dir}/#{@algorithm}.yml")
+
+      if file.exist?
+        file
+      else
+        nil
+      end
+    end.compact.first
+
+    YAML.load_file(fn.expand_path)
+  end
+end

data/lib/to_pass/base.rb

@@ -0,0 +1,20 @@
+module ToPass
+  # ToPass::Base is mostly a facade for the library.
+  #
+  # Given a string and a algorithm identifier, the right rules
+  # are loaded and applied to the string. With a simple "to_s",
+  # you can get the final password
+  class Base
+    # transform a string according to a certain algorithm
+    def initialize( string, algorithm )
+      rules = AlgorithmReader.load(algorithm)
+      converter = Converter.new( rules )
+      @password = converter.convert(string)
+    end
+
+    # return the generated password
+    def to_s
+      @password
+    end
+  end
+end

data/lib/to_pass/converter.rb

@@ -0,0 +1,62 @@
+module ToPass
+  # converts a given string into a password-like word
+  #
+  # the string can be a word or a sentence. everthing which
+  # contains whitespace is considered a sentence
+  #
+  # a more complete description of the algorithm capabilities
+  # is still pending.
+  class Converter
+    # create a new converter, based on a set of conversion-rules
+    def initialize( rules )
+      @rules = rules
+    end
+
+    # convert a string into a password
+    def convert( string )
+      process(string, rules_for(string))
+    end
+
+    # class << self
+    #   # convenience method to apply conversion rules to a string
+    #   def apply(rules, string)
+    #     new(rules).convert(string)
+    #   end
+    #   # convenience method to convert a string based on rules
+    #   def convert(string, rules)
+    #     new(rules).convert(string)
+    #   end
+    # end
+
+    protected
+
+    include StringConversions
+
+    private
+
+    # return the applicable rules for a given string.
+    #
+    # everything which contains whitespace is considered a sentence,
+    # otherwise it is most likely a word.
+    def rules_for( string )
+      if string.include? ' ' or /\s/.match(string)
+        @rules['sentence']
+      else
+        @rules['word']
+      end
+    end
+
+    # 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
+      end
+    end
+  end
+end

data/lib/to_pass/integration.rb

@@ -0,0 +1,13 @@
+# Any Object can be a password, as long as it has a string representation.
+#
+# This Module provides a shortcut to the password-conversion.
+#
+#   String.send(:include, ToPass::Integration)
+#   puts "Da steht ein Pferd auf dem Flur".to_pass => 'Ds1P@dF'
+#
+module ToPass::Integration
+  # simplified password-creation
+  def to_pass( algorithm = 'basic_de' )
+    ToPass::Base.new(self.to_s, algorithm).to_s
+  end
+end

data/lib/to_pass/string_conversions.rb

@@ -0,0 +1,51 @@
+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/lib/to_pass.rb

@@ -0,0 +1,14 @@
+# Library to convert a String into a Password
+module ToPass
+  # version of gem, read directly from the VERSION-File
+  VERSION = File.read(File.join(File.dirname(__FILE__), '../VERSION')).strip
+
+  # name of gem
+  APP_NAME = 'to_pass'
+
+  autoload :Converter,         'lib/to_pass/converter'
+  autoload :StringConversions, 'lib/to_pass/string_conversions'
+  autoload :Base,              'lib/to_pass/base'
+  autoload :Integration,       'lib/to_pass/integration'
+  autoload :AlgorithmReader,   'lib/to_pass/algorithm_reader'
+end

data/test/helper.rb

@@ -0,0 +1,26 @@
+require 'test/unit/testcase'
+require 'test/unit' unless defined?(Test::Unit)
+require 'mocha'
+
+base_path = ( File.expand_path(File.dirname(__FILE__)+'/..') )
+$LOAD_PATH << base_path unless $LOAD_PATH.include?(base_path)
+
+Test::Unit::TestCase.class_eval do
+  def assert_class_defined(klass)
+    assert defined?(klass), "#{klass} should be defined"
+    assert_kind_of Class, klass, "#{klass} should be a class"
+  end
+
+  def assert_module_defined(modul)
+    assert defined?(modul), "#{modul} should be defined"
+    assert_kind_of Module, modul, "#{modul} should be a module"
+  end
+
+  def self.test_presence(klass)
+    define_method "test_presence" do
+      assert_class_defined klass
+    end
+  end
+end
+
+require 'lib/to_pass'

data/test/test_algorithm_reader.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__)+'/helper'
+
+class TestAlgorithmReader < Test::Unit::TestCase
+  test_presence ToPass::AlgorithmReader
+
+  def test_initialize
+    assert_nothing_raised do
+      klass.new( :basic_de )
+    end
+  end
+
+  def test_load
+    assert_respond_to klass, :load
+    assert_kind_of Hash, klass.load(:basic_de)
+  end
+
+  def test_has_load_path
+    assert_respond_to reader, :load_path
+    assert_kind_of Array, reader.load_path
+  end
+
+  def test_load_path_contains_standard_dirs
+    dirs = [
+      '~/.to_pass/algorithms' ,
+      "#{File.dirname(__FILE__)}/../lib/algorithms"
+    ]
+
+    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
+
+  protected
+
+  def klass
+    ToPass::AlgorithmReader
+  end
+  def reader(algorithm = :basic_de)
+    @reader ||= klass.new(algorithm)
+  end
+end

data/test/test_base.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__)+'/helper'
+
+class TestBase < Test::Unit::TestCase
+  test_presence ToPass::Base
+
+  def test_usage
+    assert_nothing_raised do
+      pwd = ToPass::Base.new("Da steht ein Pferd auf dem Flur", 'basic_de').to_s
+      assert_equal "Ds1P@dF", pwd
+    end
+  end
+
+  def test_version
+    assert_equal Pathname.new("#{File.dirname(__FILE__)}/../VERSION").expand_path.read.chomp, ToPass::VERSION
+  end
+
+  def test_appname
+    assert_equal "to_pass", ToPass::APP_NAME
+  end
+end

data/test/test_converter.rb

@@ -0,0 +1,93 @@
+require File.dirname(__FILE__)+'/helper'
+
+class TestConverter < Test::Unit::TestCase
+  def teardown
+    @converter = nil
+  end
+
+  # basic presence and api-testing
+  test_presence ToPass::Converter
+  def test_instantiation
+    assert_nothing_raised do
+      ToPass::Converter.new({})
+    end
+  end
+  def test_convert
+    assert_respond_to converter, :convert
+    assert_nothing_raised do
+      converter.convert( "test" )
+    end
+  end
+
+  # mock-tests to ensure presence and calling of protected methods
+  def test_replace
+    assert_respond_to converter, :replace
+    converter.expects(:replace).once
+
+    converter.convert("test")
+  end
+  def test_swapcase
+    converter({'word' => ['swapcase']})
+    assert_respond_to converter, :swapcase
+    converter.expects(: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.convert("test test")
+  end
+  def test_collapse_chars
+    converter({'sentence' => ['collapse_chars']})
+    assert_respond_to converter, :collapse_chars
+    converter.expects(: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']
+    }))
+
+    assert_equal( "t35T", converter.convert('test'))
+  end
+  def test_sentence
+    converter(complex_rules)
+    assert_equal( "Ds1P@dF", converter.convert("Da steht ein Pferd auf dem Flur"))
+  end
+  def test_sentence_with_whitespace
+    converter(complex_rules)
+    assert_equal( "Ds1P@dF", converter.convert("Da	steht	ein
+
+Pferd	auf	dem	Flur"))
+  end
+
+  protected
+
+  def converter(rules = basic_rules)
+    @converter ||= ToPass::Converter.new(rules)
+  end
+
+  def basic_rules
+    {
+      'word' => [{ 'table' => 'special' }],
+      'tables' => {
+        'special' => {
+          'e' => '3',
+          's' => '5'
+        }
+      }
+    }
+  end
+  def complex_rules
+    {
+      'sentence' => [{'table'=>'words'},'first_chars','collapse_chars',{'table'=>'symbols'}],
+      'tables' => {
+        'words' => { 'ein' => '1' },
+        'symbols' => { 'a' => '@' }
+      }
+    }
+  end
+end

data/test/test_integration.rb

@@ -0,0 +1,30 @@
+require File.dirname(__FILE__)+'/helper'
+
+class TestIntegration < Test::Unit::TestCase
+  def test_cli_usage_without_algorithm
+    assert_nothing_raised do
+      assert_equal "t35t", `bin/to_pass test`.chomp
+    end
+  end
+
+  def test_cli_usage_with_algorithm
+    assert_nothing_raised do
+      assert_equal "ti1p4u2", `bin/to_pass 'there is one problem for us, too' -a basic_en`.chomp
+    end
+  end
+
+  def test_cli_usage_with_pipes
+    assert_nothing_raised do
+      assert_equal 't35t', `echo "test" | bin/to_pass`
+    end
+  end
+
+  def test_module_integration
+    assert_nothing_raised do
+      str = "test"
+      str.instance_eval "class << self; include ToPass::Integration; end"
+
+      assert_equal 't35t', str.to_pass
+    end
+  end
+end

data/test/test_string_conversions.rb

@@ -0,0 +1,37 @@
+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

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification 
+name: to_pass
+version: !ruby/object:Gem::Version 
+  hash: 19
+  prerelease: false
+  segments: 
+  - 0
+  - 2
+  - 2
+  version: 0.2.2
+platform: ruby
+authors: 
+- Matthias Viehweger
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-06-13 00:00:00 +02:00
+default_executable: to_pass
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  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: sdoc
+  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: |-
+  Passwords should be easy to remember and hard to guess.
+  One technique is to have a sentence which can be easily remembered transformed to a password.
+email: kronn@kronn.de
+executables: 
+- to_pass
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+- TODO
+files: 
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- 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/base.rb
+- lib/to_pass/converter.rb
+- lib/to_pass/integration.rb
+- lib/to_pass/string_conversions.rb
+- test/helper.rb
+- test/test_algorithm_reader.rb
+- test/test_base.rb
+- test/test_converter.rb
+- test/test_integration.rb
+- test/test_string_conversions.rb
+has_rdoc: true
+homepage: http://github.com/kronn/to_pass
+licenses: []
+
+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: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: generate password from words or sentences
+test_files: 
+- test/helper.rb
+- test/test_algorithm_reader.rb
+- test/test_base.rb
+- test/test_converter.rb
+- test/test_integration.rb
+- test/test_string_conversions.rb