shift_ciphers 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7339c2a602c6851a97eb2ae8e9a8fb0bba7acedf908cf9bdfa44b10258b6b52f
-  data.tar.gz: dab0336c772360bdd50888e7aae4c26215f9fc8d423e1b6086322debd90f9334
+  metadata.gz: f9719f1d7ca53e6f2bdfb05df4d0f43e936c572ed687e841f63052c01aa0433b
+  data.tar.gz: bc58897ff42d8b542c03ffcc527fbfeac1c61fcc9a5074e1cc3399ab6632ea7c
 SHA512:
-  metadata.gz: ca83d8402f7f5e9365e54fbf5b8c01d5557603701a8a9afae17f941dcbfc68f204079d391763c9d084db4e7d9c3886b4fde1e53de4f0ca6d63984cd649647ec6
-  data.tar.gz: 5b6486223be628db1143c7b3864f510f39902cbb803a688c7891cd1933f86dffdc2c77af63654df2e827452e963ad7fa260b6ae58a69f43ba7ca8de7cd6dda6e
+  metadata.gz: 5e4876ec51d94454024e8caa69e7a2e36d0cf25890c74a2ff75288be68d0ea38aebe3d5234736db32251f6fbf72653df2bfc41ad45bbea02f86a6c4b2969e237
+  data.tar.gz: 73bc9aed8e221b46a6186375de7b3658df0661c37494fe9c33f2bea53deb74db3f77473defb732bc056f672dfe430eba11d48f90478f1c724dbe37dc2f69733c

data/LICENSE

@@ -1,21 +1,21 @@
-The MIT License (MIT)
-
-Copyright (c) 2018 Tomasz Więch
-
-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
+The MIT License (MIT)
+
+Copyright (c) 2018 Tomasz Więch
+
+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.md

@@ -1,69 +1,83 @@
-Shift Ciphers [![Gem Version](https://badge.fury.io/rb/shift_ciphers.svg)](http://badge.fury.io/rb/shift_ciphers) [![Build Status](https://travis-ci.org/TeWu/shift-ciphers.svg?branch=master)](https://travis-ci.org/TeWu/shift-ciphers)
-=======
-
-**Shift Ciphers** gem is simple, yet complete, implementation of [Caesar](https://en.wikipedia.org/wiki/Caesar_cipher) and [Vigenère](https://en.wikipedia.org/wiki/Vigen%C3%A8re_cipher) ciphers.
-
-Installation
--------
-
-    gem install shift_ciphers
-
-Basic usage
--------
-
-```ruby
-require 'shift_ciphers'
-
-plaintext = "Attack at dawn!"
-
-encrypted = ShiftCiphers::Caesar.encrypt(plaintext, offset: 5)
-decrypted = ShiftCiphers::Caesar.decrypt(encrypted, offset: 5)
-decrypted == plaintext  # Should be true
-
-encrypted = ShiftCiphers::Vigenere.encrypt(plaintext, "my keyword")
-decrypted = ShiftCiphers::Vigenere.decrypt(encrypted, "my keyword")
-decrypted == plaintext  # Should be true
-```
-
-... or instantiate cipher, and benefit from stored configuration info (e.g. `offset` for Caesar cipher, or `key` for Vigenère cipher):
-
-```ruby
-caesar = ShiftCiphers::Caesar.new
-caesar.offset = 5
-encrypted = caesar.encrypt(plaintext)
-decrypted = caesar.decrypt(encrypted)
-decrypted == plaintext  # Should be true
-
-vigenere = ShiftCiphers::Vigenere.new("my keyword")
-encrypted = vigenere.encrypt(plaintext)
-decrypted = vigenere.decrypt(encrypted)
-decrypted == plaintext  # Should be true
-```
-
-You can customize alphabet used by cipher:
-
-```ruby
-plaintext = "ATTACKATDAWN"
-encrypted = ShiftCiphers::Vigenere.encrypt(plaintext, "KEYWORD", alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ")
-decrypted = ShiftCiphers::Vigenere.decrypt(encrypted, "KEYWORD", alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ")
-decrypted == plaintext  # Should be true
-```
-
-When you attempt to encrypt a string, which contains character that is not in the cipher's alphabet, then `ShiftCiphers::CipherError` is rised:
-
-```ruby
-plaintext = "ATTACK!"
-encrypted = ShiftCiphers::Vigenere.encrypt(plaintext, "KEYWORD", alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ")
-# Raises ShiftCiphers::CipherError: Invalid input "ATTACK!". Character "!" is not in the alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-```
-
-You can avoid this exception by telling cipher to not encrypt characters which are not in its alphabet. This is done by passing `nonalphabet_char_strategy` argument to `encrypt`/`decrypt` class method (or by using `nonalphabet_char_strategy=` instance method):
-
-```ruby
-plaintext = "ATTACK AT DAWN!"
-encrypted = ShiftCiphers::Vigenere.encrypt(plaintext, "KEYWORD", alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ", nonalphabet_char_strategy: :dont_encrypt)
-decrypted = ShiftCiphers::Vigenere.decrypt(encrypted, "KEYWORD", alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ", nonalphabet_char_strategy: :dont_encrypt)
-puts plaintext  # => ATTACK AT DAWN!
-puts encrypted  # => KXRWQB DD HYSB!
-decrypted == plaintext  # Should be true
-```
+Shift Ciphers [![Gem Version](https://badge.fury.io/rb/shift_ciphers.svg)](http://badge.fury.io/rb/shift_ciphers) [![Build Status](https://travis-ci.org/TeWu/shift-ciphers.svg?branch=master)](https://travis-ci.org/TeWu/shift-ciphers)
+=======
+
+**Shift Ciphers** gem is simple, yet complete, implementation of classic [Caesar][1] and [Vigenère][2] ciphers. It also features custom, hardened version of Vigenère cipher, which uses [autokey scheme][3] and [PRNG][4]s.
+
+Installation
+-------
+
+    gem install shift_ciphers
+
+Basic usage
+-------
+
+```ruby
+require 'shift_ciphers'
+
+plaintext = "Attack at dawn!"
+
+encrypted = ShiftCiphers::Caesar.encrypt(plaintext, offset: 5)    # => "Fyyfhp%fy%ifBs^"
+decrypted = ShiftCiphers::Caesar.decrypt(encrypted, offset: 5)    # => "Attack at dawn!"
+decrypted == plaintext  # Should be true
+
+encrypted = ShiftCiphers::Vigenere.encrypt(plaintext, "my keyword")    # => "W!0uqS3yU=zI3H{"
+decrypted = ShiftCiphers::Vigenere.decrypt(encrypted, "my keyword")    # => "Attack at dawn!"
+decrypted == plaintext  # Should be true
+
+encrypted = ShiftCiphers::HardenedVigenere.encrypt(plaintext, "my keyword")    # => "Z6tappN^Ap[o&Ns"
+decrypted = ShiftCiphers::HardenedVigenere.decrypt(encrypted, "my keyword")    # => "Attack at dawn!"
+decrypted == plaintext  # Should be true
+```
+
+... or instantiate a cipher, and benefit from stored configuration info (e.g. `offset` for Caesar cipher, or `key` for Vigenère):
+
+```ruby
+caesar = ShiftCiphers::Caesar.new
+caesar.offset = 5
+encrypted = caesar.encrypt(plaintext)    # => "Fyyfhp%fy%ifBs^"
+decrypted = caesar.decrypt(encrypted)    # => "Attack at dawn!"
+decrypted == plaintext  # Should be true
+
+vigenere = ShiftCiphers::Vigenere.new("my keyword")
+encrypted = vigenere.encrypt(plaintext)    # => "W!0uqS3yU=zI3H{"
+decrypted = vigenere.decrypt(encrypted)    # => "Attack at dawn!"
+decrypted == plaintext  # Should be true
+
+strong_vigenere = ShiftCiphers::HardenedVigenere.new("my keyword")
+encrypted = strong_vigenere.encrypt(plaintext)    # => "Z6tappN^Ap[o&Ns"
+decrypted = strong_vigenere.decrypt(encrypted)    # => "Attack at dawn!"
+decrypted == plaintext  # Should be true
+```
+
+You can customize alphabet used by cipher:
+
+```ruby
+plaintext = "ATTACKATDAWN"
+encrypted = ShiftCiphers::Vigenere.encrypt(plaintext, "KEYWORD", alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ")    # => "KXRWQBDDHYSB"
+decrypted = ShiftCiphers::Vigenere.decrypt(encrypted, "KEYWORD", alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ")    # => "ATTACKATDAWN"
+decrypted == plaintext  # Should be true
+```
+
+When you attempt to encrypt a string, which contains character that is not in the cipher's alphabet, then `ShiftCiphers::CipherError` is rised:
+
+```ruby
+plaintext = "ATTACK!"
+encrypted = ShiftCiphers::Vigenere.encrypt(plaintext, "KEYWORD", alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+# Raises ShiftCiphers::CipherError: Invalid input "ATTACK!". Character "!" is not in the alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+```
+
+You can avoid this exception by telling cipher not to encrypt characters which are not in its alphabet. This is done by passing `nonalphabet_char_strategy` argument to `encrypt`/`decrypt` class method (or by using `nonalphabet_char_strategy=` instance method):
+
+```ruby
+plaintext = "ATTACK AT DAWN!"
+encrypted = ShiftCiphers::Vigenere.encrypt(plaintext, "KEYWORD", alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ", nonalphabet_char_strategy: :dont_encrypt)
+decrypted = ShiftCiphers::Vigenere.decrypt(encrypted, "KEYWORD", alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ", nonalphabet_char_strategy: :dont_encrypt)
+puts plaintext  # => ATTACK AT DAWN!
+puts encrypted  # => KXRWQB DD HYSB!
+decrypted == plaintext  # Should be true
+```
+
+[1]: https://en.wikipedia.org/wiki/Caesar_cipher
+[2]: https://en.wikipedia.org/wiki/Vigen%C3%A8re_cipher
+[3]: https://en.wikipedia.org/wiki/Autokey_cipher
+[4]: https://en.wikipedia.org/wiki/Pseudorandom_number_generator

data/lib/shift_ciphers/alphabets.rb

@@ -1,12 +1,12 @@
-module ShiftCiphers
-  module Alphabets
-    NUMS = (0..9).to_a.map(&:to_s).join
-    LOWER_ALPHA = ('a'..'z').to_a.join
-    UPPER_ALPHA = ('A'..'Z').to_a.join
-    ALPHA = LOWER_ALPHA + UPPER_ALPHA
-    ALPHANUMS = NUMS + ALPHA
-    SPECIAL = " !@#$%^&*()-_=+{}[];:'\",./<>?"
-
-    DEFAULT = ALPHANUMS + SPECIAL
-  end
+module ShiftCiphers
+  module Alphabets
+    NUMS = (0..9).to_a.map(&:to_s).join
+    LOWER_ALPHA = ('a'..'z').to_a.join
+    UPPER_ALPHA = ('A'..'Z').to_a.join
+    ALPHA = LOWER_ALPHA + UPPER_ALPHA
+    ALPHANUMS = NUMS + ALPHA
+    SPECIAL = " !@#$%^&*()-_=+{}[];:'\",./<>?"
+
+    DEFAULT = ALPHANUMS + SPECIAL
+  end
 end

data/lib/shift_ciphers/caesar.rb

@@ -1,49 +1,49 @@
-module ShiftCiphers
-  class Caesar
-    DEFAULT_OFFSET = 13
-    attr_accessor :offset, :alphabet, :nonalphabet_char_strategy
-
-    def initialize(offset: DEFAULT_OFFSET, alphabet: Alphabets::DEFAULT, nonalphabet_char_strategy: :error)
-      @offset = offset
-      @alphabet = alphabet
-      @nonalphabet_char_strategy = nonalphabet_char_strategy
-    end
-
-    def encrypt(plaintext)
-      process(plaintext, :encrypt)
-    end
-
-    def decrypt(ciphertext)
-      process(ciphertext, :decrypt)
-    end
-
-    protected
-
-    def process(text, direction)
-      text.each_char.reduce("") do |ciphertext, char|
-        char_idx = alphabet.index(char)
-        if !char_idx.nil?
-          rel_offset = offset * (direction == :encrypt ? 1 : -1)
-          ciphertext << alphabet[(char_idx + rel_offset) % alphabet.size]
-        else
-          if nonalphabet_char_strategy == :dont_encrypt
-            ciphertext << char
-          else
-            raise CipherError.new("Character #{char.inspect} is not in the alphabet: #{alphabet.inspect}")
-          end
-        end
-      end
-    end
-
-    class << self
-      def encrypt(plaintext, **options)
-        self.new(**options).encrypt(plaintext)
-      end
-
-      def decrypt(ciphertext, **options)
-        self.new(**options).decrypt(ciphertext)
-      end
-    end
-
-  end
+module ShiftCiphers
+  class Caesar
+    DEFAULT_OFFSET = 13
+    attr_accessor :offset, :alphabet, :nonalphabet_char_strategy
+
+    def initialize(offset: DEFAULT_OFFSET, alphabet: Alphabets::DEFAULT, nonalphabet_char_strategy: :error)
+      @offset = offset
+      @alphabet = alphabet
+      @nonalphabet_char_strategy = nonalphabet_char_strategy
+    end
+
+    def encrypt(plaintext)
+      process(plaintext, true)
+    end
+
+    def decrypt(ciphertext)
+      process(ciphertext, false)
+    end
+
+    protected
+
+    def process(text, encrypting = true)
+      text.each_char.reduce("") do |result, char|
+        char_idx = alphabet.index(char)
+        if !char_idx.nil?
+          rel_offset = offset * (encrypting ? 1 : -1)
+          result << alphabet[(char_idx + rel_offset) % alphabet.size]
+        else
+          if nonalphabet_char_strategy == :dont_encrypt
+            result << char
+          else
+            raise CipherError.new("Character #{char.inspect} is not in the alphabet: #{alphabet.inspect}")
+          end
+        end
+      end
+    end
+
+    class << self
+      def encrypt(plaintext, **options)
+        self.new(**options).encrypt(plaintext)
+      end
+
+      def decrypt(ciphertext, **options)
+        self.new(**options).decrypt(ciphertext)
+      end
+    end
+
+  end
 end

data/lib/shift_ciphers/error.rb

@@ -1,3 +1,3 @@
-module ShiftCiphers
-  class CipherError < StandardError; end
+module ShiftCiphers
+  class CipherError < StandardError; end
 end

data/lib/shift_ciphers/hardened_vigenere.rb

@@ -0,0 +1,55 @@
+module ShiftCiphers
+  class HardenedVigenere < Vigenere
+
+    def initialize(key, alphabet: Alphabets::DEFAULT, nonalphabet_char_strategy: :error)
+      validate_key(key, alphabet)
+      @key = key
+      @alphabet = alphabet
+      @nonalphabet_char_strategy = nonalphabet_char_strategy
+    end
+
+    protected
+
+    def process(text, encrypting = true)
+      offsets_stream = create_offsets_stream
+      plaintext_char = ""
+      text.each_char.reduce("") do |result, char|
+        char_idx = alphabet.index(char)
+        if !char_idx.nil?
+          rel_offset = offsets_stream.next(plaintext_char) * (encrypting ? 1 : -1)
+          result_char = alphabet[(char_idx + rel_offset) % alphabet.size]
+          plaintext_char = encrypting ? char : result_char
+          result << result_char
+        else
+          if nonalphabet_char_strategy == :dont_encrypt
+            result << char
+          else
+            raise CipherError.new("Invalid input #{text.inspect}. Character #{char.inspect} is not in the alphabet: #{alphabet.inspect}")
+          end
+        end
+      end
+    end
+
+    def create_offsets_stream
+      RandomOffsetsStream.new(key, alphabet.size - 1)
+    end
+
+
+    class RandomOffsetsStream
+      SEEDING_RAND_MAX = 2**32-1
+
+      def initialize(key, max)
+        @random = key.bytes.reduce(Random.new(0)) do |random, byte|
+          Random.new(random.rand(SEEDING_RAND_MAX) ^ byte)
+        end
+        @max = max
+      end
+
+      def next(plaintext_char)
+        plaintext_byte = plaintext_char.bytes.reduce(0){|a,e| a ^ e}
+        @random = Random.new(@random.rand(SEEDING_RAND_MAX) ^ plaintext_byte)
+        @random.rand(@max)
+      end
+    end
+  end
+end

data/lib/shift_ciphers/version.rb

@@ -1,10 +1,10 @@
-module ShiftCiphers
-  module Version
-    MAJOR = 0
-    MINOR = 0
-    PATCH = 2
-    LABEL = nil
-  end
-
-  VERSION = ([Version::MAJOR, Version::MINOR, Version::PATCH, Version::LABEL].compact * '.').freeze
+module ShiftCiphers
+  module Version
+    MAJOR = 0
+    MINOR = 0
+    PATCH = 3
+    LABEL = nil
+  end
+
+  VERSION = ([Version::MAJOR, Version::MINOR, Version::PATCH, Version::LABEL].compact * '.').freeze
 end

data/lib/shift_ciphers/vigenere.rb

@@ -1,72 +1,77 @@
-module ShiftCiphers
-  class Vigenere
-    attr_accessor :key, :alphabet, :nonalphabet_char_strategy
-
-    def initialize(key, alphabet: Alphabets::DEFAULT, nonalphabet_char_strategy: :error)
-      validate_key(key, alphabet)
-      @key = key
-      @alphabet = alphabet
-      @nonalphabet_char_strategy = nonalphabet_char_strategy
-      set_key_offsets
-    end
-
-    def key=(key)
-      validate_key(key, alphabet)
-      @key = key
-      set_key_offsets
-    end
-
-    def alphabet=(alphabet)
-      validate_key(key, alphabet)
-      @alphabet = alphabet
-    end
-
-    def encrypt(plaintext)
-      process(plaintext, :encrypt)
-    end
-
-    def decrypt(ciphertext)
-      process(ciphertext, :decrypt)
-    end
-
-    protected
-
-    def process(text, direction)
-      key_offsets = @key_offsets.cycle
-      text.each_char.reduce("") do |ciphertext, char|
-        char_idx = alphabet.index(char)
-        if !char_idx.nil?
-          rel_offset = key_offsets.next * (direction == :encrypt ? 1 : -1)
-          ciphertext << alphabet[(char_idx + rel_offset) % alphabet.size]
-        else
-          if nonalphabet_char_strategy == :dont_encrypt
-            ciphertext << char
-          else
-            raise CipherError.new("Invalid input #{text.inspect}. Character #{char.inspect} is not in the alphabet: #{alphabet.inspect}")
-          end
-        end
-      end
-    end
-
-    def validate_key(key, alphabet)
-      key.each_char do |char|
-        raise CipherError.new("Invalid key #{key.inspect}. Character #{char.inspect} is not in the alphabet: #{alphabet.inspect}") unless alphabet.include?(char)
-      end
-    end
-
-    def set_key_offsets
-      @key_offsets = @key.chars.map {|c| alphabet.index(c) }
-    end
-
-    class << self
-      def encrypt(plaintext, key, **options)
-        self.new(key, **options).encrypt(plaintext)
-      end
-
-      def decrypt(ciphertext, key, **options)
-        self.new(key, **options).decrypt(ciphertext)
-      end
-    end
-
-  end
+module ShiftCiphers
+  class Vigenere
+    attr_accessor :key, :alphabet, :nonalphabet_char_strategy
+
+    def initialize(key, alphabet: Alphabets::DEFAULT, nonalphabet_char_strategy: :error)
+      validate_key(key, alphabet)
+      @key = key
+      @alphabet = alphabet
+      @nonalphabet_char_strategy = nonalphabet_char_strategy
+      set_key_offsets
+    end
+
+    def key=(key)
+      validate_key(key, alphabet)
+      @key = key
+      set_key_offsets
+    end
+
+    def alphabet=(alphabet)
+      validate_key(key, alphabet)
+      @alphabet = alphabet
+    end
+
+    def encrypt(plaintext)
+      process(plaintext, true)
+    end
+
+    def decrypt(ciphertext)
+      process(ciphertext, false)
+    end
+
+    protected
+
+    def process(text, encrypting = true)
+      offsets_stream = create_offsets_stream
+      text.each_char.reduce("") do |result, char|
+        char_idx = alphabet.index(char)
+        if !char_idx.nil?
+          rel_offset = offsets_stream.next * (encrypting ? 1 : -1)
+          result << alphabet[(char_idx + rel_offset) % alphabet.size]
+        else
+          if nonalphabet_char_strategy == :dont_encrypt
+            result << char
+          else
+            raise CipherError.new("Invalid input #{text.inspect}. Character #{char.inspect} is not in the alphabet: #{alphabet.inspect}")
+          end
+        end
+      end
+    end
+
+    def set_key_offsets
+      @key_offsets = @key.chars.map {|c| alphabet.index(c) }
+    end
+
+    def create_offsets_stream
+      @key_offsets.cycle
+    end
+
+    def validate_key(key, alphabet)
+      key.each_char do |char|
+        raise CipherError.new("Invalid key #{key.inspect}. Character #{char.inspect} is not in the alphabet: #{alphabet.inspect}") unless alphabet.include?(char)
+      end
+    end
+
+
+    class << self
+      def encrypt(plaintext, key, **options)
+        self.new(key, **options).encrypt(plaintext)
+      end
+
+      def decrypt(ciphertext, key, **options)
+        self.new(key, **options).decrypt(ciphertext)
+      end
+    end
+
+  end
 end

data/lib/shift_ciphers.rb

@@ -1,5 +1,6 @@
-require 'shift_ciphers/version'
-require 'shift_ciphers/alphabets'
-require 'shift_ciphers/error'
-require 'shift_ciphers/caesar'
-require 'shift_ciphers/vigenere'
+require 'shift_ciphers/version'
+require 'shift_ciphers/alphabets'
+require 'shift_ciphers/error'
+require 'shift_ciphers/caesar'
+require 'shift_ciphers/vigenere'
+require 'shift_ciphers/hardened_vigenere'

data/shift_ciphers.gemspec

@@ -1,26 +1,26 @@
-# coding: utf-8
-
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'shift_ciphers/version'
-
-Gem::Specification.new do |s|
-  s.name          = "shift_ciphers"
-  s.version       = ShiftCiphers::VERSION
-  s.authors       = ["Tomasz Więch"]
-  s.email         = ["tewu.dev@gmail.com"]
-
-  s.summary       = "Implementation of Caesar and Vigenere ciphers"
-  s.description   = "Implementation of Caesar and Vigenere ciphers"
-  s.homepage      = "https://github.com/TeWu/shift-ciphers"
-  s.license       = "MIT"
-
-  s.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(doc|test|spec|features|bin)/|Rakefile|Gemfile*|CHANGELOG}) || f.start_with?('.') }
-  s.require_paths = ["lib"]
-
-  s.required_ruby_version = ">= 2.1.0"
-
-  s.add_development_dependency "bundler", "~> 1.16"
-  s.add_development_dependency "pry", "~> 0.11"
-  s.add_development_dependency "rspec", "~> 3.8"
+# coding: utf-8
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'shift_ciphers/version'
+
+Gem::Specification.new do |s|
+  s.name          = "shift_ciphers"
+  s.version       = ShiftCiphers::VERSION
+  s.authors       = ["Tomasz Więch"]
+  s.email         = ["tewu.dev@gmail.com"]
+
+  s.summary       = "Implementation of Caesar and Vigenere ciphers"
+  s.description   = "Implementation of Caesar and Vigenere ciphers"
+  s.homepage      = "https://github.com/TeWu/shift-ciphers"
+  s.license       = "MIT"
+
+  s.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(doc|test|spec|features|bin)/|Rakefile|Gemfile*|CHANGELOG}) || f.start_with?('.') }
+  s.require_paths = ["lib"]
+
+  s.required_ruby_version = ">= 2.1.0"
+
+  s.add_development_dependency "bundler", "~> 1.16"
+  s.add_development_dependency "pry", "~> 0.11"
+  s.add_development_dependency "rspec", "~> 3.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shift_ciphers
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Tomasz Więch
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-10 00:00:00.000000000 Z
+date: 2018-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -65,6 +65,7 @@ files:
 - lib/shift_ciphers/alphabets.rb
 - lib/shift_ciphers/caesar.rb
 - lib/shift_ciphers/error.rb
+- lib/shift_ciphers/hardened_vigenere.rb
 - lib/shift_ciphers/version.rb
 - lib/shift_ciphers/vigenere.rb
 - shift_ciphers.gemspec