ppg 0.0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8cfd70a8672f3df6fe2516af336b97f686aa3001
+  data.tar.gz: 82bfb856d6a3cfe78bbfcbcd70066abfd6a00d8a
+SHA512:
+  metadata.gz: db880f29757216f42134cb11376b231931a2bb1ada582d7dc1771bafd2c36f1d110efaccf551852b2fbb28f2ccf78457f2a4ea521209e6c7994fcf534e036819
+  data.tar.gz: 6fb661bc2b099fbf6b15aad50b16484f5907e21d702e2b57927863561e3aec3e7ac2b451c408bbdf67c9d2cd286e4ef4f3bd0062412cb8648c2f211802ca6cf2

data/bin/ppg

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+
+require 'ppg'
+
+require 'getoptlong'
+
+DEFAULT_PASSWORD_LENGTH = 8
+
+opts = GetoptLong.new(
+  ['--help', '-h', GetoptLong::NO_ARGUMENT],
+  ['--digits', '-d', GetoptLong::OPTIONAL_ARGUMENT],
+  ['--upcase', '-u', GetoptLong::OPTIONAL_ARGUMENT],
+  ['--length', '-l', GetoptLong::REQUIRED_ARGUMENT],
+  ['--verbous', '-v', GetoptLong::NO_ARGUMENT]
+)
+
+def print_help
+  puts <<-EOF
+  generator.rb [OPTIONS]
+
+    -h --help:    prints this help
+
+    -d N          include N digits in password
+    --digits N    1 by default
+
+    -u N          Include N letters in upper case
+    --upcase N    1 by default
+
+    -l N          make password of N characters
+    --length N
+
+    -v            turns on additional output
+    --verbous
+
+  EOF
+
+end
+
+begin
+
+mutators = {}
+password_length = DEFAULT_PASSWORD_LENGTH
+
+  opts.each do |opt, arg|
+    case opt
+    when '--help'
+      print_help
+      exit
+    when '--digits'
+
+      mutators[:Digits]  = Proc.new { Random.rand(10).to_s },
+        arg.empty? ? 1 : arg.to_i
+
+    when '--upcase'
+      mutators[:Upcase] = Proc.new { |c| c.upcase },
+        arg.empty? ? 1 : arg.to_i
+
+    when '--length'
+      password_length = arg.to_i
+      raise "password length must be greater than 0" if password_length <= 0
+
+    when '--verbous'
+      class Password
+        def to_s
+          "\n" \
+          "password: #{password}\n" \
+          "pattern:  #{password_pattern.to_s}\n"
+        end
+      end
+
+    end
+  end
+
+  pwgen = PwGen.new(password_length)
+  mutators.each { |name, mutator|
+    puts "enabling #{name} mutator for #{mutator.last} character(s)" 
+    pwgen.add_mutator(*mutator)
+  }
+  
+  puts pwgen.generate_password
+
+rescue GetoptLong::MissingArgument
+  puts
+  print_help
+  exit
+
+end
+

data/lib/ppg.rb

@@ -0,0 +1 @@
+require_relative 'ppg/pwgen'

data/lib/ppg/password.rb

@@ -0,0 +1,18 @@
+class Password
+  attr_accessor :password, :password_pattern
+  attr_reader :PASSWORD_LENGTH
+
+  def initialize (password_length, password_pattern = nil)
+    @PASSWORD_LENGTH = password_length.freeze
+    @password = String.new
+    #TODO: make password_pattern validation check method
+    @password_pattern ||= []
+  end
+
+  def length= (length)
+    @PASSWORD_LENGTH = length.freeze
+  end
+  
+  alias :to_s :password
+
+end

data/lib/ppg/phonemes.rb

@@ -0,0 +1,41 @@
+$ENGLISH_PHONEMES_HASH = {
+
+  :vowels => [ "a","e","i","o","u" ],
+
+  :consonants => [ "b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n",
+    "p", "r", "s", "t", "v", "w", "x", "y", "z" ],
+
+  :dipthongs => { 
+    :vowel => ["ae", "oh", "oo", "ah", "ai", "ee", "ei", "ie"],
+    :consonant => ["ng", "gh", "ch", "ph", "qu", "sh", "th"] 
+  }
+ 
+}.freeze
+
+$ENGLISH_DOWNCASE_REGEXP = /[a-z]/.freeze
+
+class Phonemes
+  attr_reader :downcase_regexp
+  
+  def initialize(
+    vowels = nil,
+    consonants = nil,
+    dipthongs = nil,
+    downcase_regexp = $ENGLISH_DOWNCASE_REGEXP
+  )
+
+    @phonemes = { :vowel => vowels || $ENGLISH_PHONEMES_HASH[:vowels], 
+      :consonant => consonants || $ENGLISH_PHONEMES_HASH[:consonants], 
+      :dipthong => dipthongs || $ENGLISH_PHONEMES_HASH[:dipthongs]
+    }
+    @downcase_regexp = downcase_regexp
+  end
+
+  def keys
+    @phonemes.keys
+  end
+
+  def [](index)
+    @phonemes[index]
+  end
+end

data/lib/ppg/pwgen.rb

@@ -0,0 +1,143 @@
+# coding: utf-8
+require_relative 'password'
+require_relative 'phonemes'
+
+require 'securerandom'
+
+class MutatorError < Exception; end
+
+class PwGen
+  attr_reader :password
+  attr_writer :phonemes
+
+  def initialize(length, phonemes = nil)
+    @password = Password.new(length)
+    @phonemes = phonemes || Phonemes.new
+    @mutators = {}
+
+    #TODO: избавиться от константы
+    @dipthong_length = 2
+  end
+
+  def add_mutator(proc, count)
+    @mutated_chars ||= []
+    @clean_chars_left ||= @password.PASSWORD_LENGTH
+
+    return false if count == 0
+
+    if @clean_chars_left == 0
+      count = 0
+      raise MutatorError, "nothing left to mutate, rejecting!"
+    end
+
+    unless proc.respond_to? :call
+      raise MutatorError, "mutator's not callable, rejecting!"
+    end
+
+    if count > @clean_chars_left
+      error_string = "can't mutate #{count} characters, decreasing to #{@clean_chars_left}!\n"
+      count = @clean_chars_left
+      raise MutatorError, error_string
+    end
+
+    @clean_chars_left -= count
+    @mutators[proc] = count
+    true
+
+  rescue MutatorError
+    STDERR << $!.message
+    retry
+
+  end
+
+  def generate_password
+    generate_password_pattern!
+      .fill_in_password_pattern!
+      .mutate!
+    @password
+  end
+
+  def fill_in_password_pattern!
+    @password.password_pattern.each do |pattern|
+      if pattern.kind_of?(Symbol)
+        elem = @phonemes[pattern][SecureRandom.random_number(@phonemes[pattern].length)]
+      else pattern.kind_of?(Array)
+        # most definitely is dipthong
+        length = @phonemes[pattern[0]][pattern[1]].length
+        elem = @phonemes[pattern[0]][pattern[1]][SecureRandom.random_number(length)]
+      end
+      @password.password << elem
+    end
+    self
+  end
+
+  def generate_password_pattern!
+    length_left = @password.PASSWORD_LENGTH
+    next_pattern = previous_pattern = nil
+    can_be_next_patterns = @phonemes.keys
+    selector_block = Proc.new { |pattern|
+      pattern if pattern != next_pattern || pattern == :dipthong 
+    }
+    while length_left > 0 do
+      loop do
+        next_pattern = generate_random_pattern(can_be_next_patterns)
+        break unless requirements_not_met?(next_pattern,
+          previous_pattern, length_left)        
+      end
+
+      can_be_next_patterns.select! &selector_block
+
+      can_be_next_patterns << previous_pattern if previous_pattern != nil
+
+      if next_pattern == :dipthong
+        if @password.password_pattern.empty? #first element
+          auxiliary_pattern = generate_random_pattern([:vowel, :consonant])
+        else
+          auxiliary_pattern = 
+            case previous_pattern
+            when :vowel then :consonant
+            when :consonant then :vowel
+            end
+        end
+        next_pattern = next_pattern, auxiliary_pattern
+        can_be_next_patterns -= [auxiliary_pattern]
+        length_left -= @dipthong_length
+        previous_pattern = auxiliary_pattern
+
+      else
+        length_left -= 1
+        previous_pattern = next_pattern
+
+      end
+      @password.password_pattern << next_pattern
+    end
+    self
+  end
+
+  def mutate!
+    @mutators.each_pair do |mutator, count| 
+      while count > 0
+        loop do
+          index = SecureRandom.random_number(@password.PASSWORD_LENGTH)
+          next unless @password.password[index] =~ @phonemes.downcase_regexp
+          @password.password[index] = (mutator.call @password.password[index])
+          break
+        end
+        count -= 1
+      end 
+    end
+  end
+
+  def requirements_not_met?(next_pattern, previous_pattern, length_left)
+    return true if next_pattern == :dipthong && length_left < @dipthong_length
+    return true if next_pattern == previous_pattern
+    false
+  end
+
+  def generate_random_pattern(patterns)
+    patterns [ SecureRandom.random_number(patterns.length) ]
+  end
+
+  private :generate_random_pattern, :requirements_not_met?
+
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: ppg
+version: !ruby/object:Gem::Version
+  version: 0.0.1.1
+platform: ruby
+authors:
+- enoch0x5a
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-22 00:00:00.000000000 Z
+dependencies: []
+description: A simple password generator with pronunciation in mind
+email: 
+executables:
+- ppg
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/ppg
+- lib/ppg.rb
+- lib/ppg/password.rb
+- lib/ppg/phonemes.rb
+- lib/ppg/pwgen.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Phonetic Password Generator
+test_files: []