shift_ciphers 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f59faf5d08db9b955f06c617b9b0191523bed8039b6c1a03f822cdcd0129c580
-  data.tar.gz: d50f539e74132d01760f19cd6a7a0982f779f166e6d165070f03637528ce7986
+  metadata.gz: 7339c2a602c6851a97eb2ae8e9a8fb0bba7acedf908cf9bdfa44b10258b6b52f
+  data.tar.gz: dab0336c772360bdd50888e7aae4c26215f9fc8d423e1b6086322debd90f9334
 SHA512:
-  metadata.gz: 31cbc305b50e2010c10c0581e8ed8f04733558479fdcdf199349395aa7ec479f22bd3d5d3c71a51daf15a023828b2514c678d47cd6c50b78981c6ec8734a62a5
-  data.tar.gz: ce84442a71e158009e8e85cd9e65c854da49ca959299eb6dc6bc47b2d05fe54886a90d4ba50cfbce83a5e5057b76de5770d1beae678ec7c73671f89acc735434
+  metadata.gz: ca83d8402f7f5e9365e54fbf5b8c01d5557603701a8a9afae17f941dcbfc68f204079d391763c9d084db4e7d9c3886b4fde1e53de4f0ca6d63984cd649647ec6
+  data.tar.gz: 5b6486223be628db1143c7b3864f510f39902cbb803a688c7891cd1933f86dffdc2c77af63654df2e827452e963ad7fa260b6ae58a69f43ba7ca8de7cd6dda6e

data/README.md

@@ -1,4 +1,4 @@
-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 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.
@@ -14,14 +14,56 @@ 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_cyphertext = caesar.encrypt("ATTACKATDAWN")
-p caesar_cyphertext
-p caesar.decrypt(caesar_cyphertext)
-
-key = "5ecr3t"
-vigenere_cyphertext = ShiftCiphers::Vigenere.encrypt("ATTACKATDAWN", key)
-p key
-p vigenere_cyphertext
-p ShiftCiphers::Vigenere.decrypt(vigenere_cyphertext, key)
+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
+```

data/lib/shift_ciphers/alphabets.rb

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

data/lib/shift_ciphers/caesar.rb

@@ -1,41 +1,49 @@
-require 'shift_ciphers/shift_ciphers'
-
 module ShiftCiphers
   class Caesar
     DEFAULT_OFFSET = 13
-    attr_accessor :offset, :alphabet
+    attr_accessor :offset, :alphabet, :nonalphabet_char_strategy
 
-    def initialize(offset = DEFAULT_OFFSET, alphabet = ALPHABET)
+    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)
-      self.class.encrypt(plaintext, offset, alphabet)
+      process(plaintext, :encrypt)
     end
 
-    def decrypt(cyphertext)
-      self.class.decrypt(cyphertext, offset, alphabet)
+    def decrypt(ciphertext)
+      process(ciphertext, :decrypt)
     end
 
-    class << self
-      def encrypt(plaintext, offset = DEFAULT_OFFSET, alphabet = ALPHABET)
-        process(plaintext, offset, :encrypt, alphabet)
+    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
 
-      def decrypt(cyphertext, offset = DEFAULT_OFFSET, alphabet = ALPHABET)
-        process(cyphertext, offset, :decrypt, alphabet)
+    class << self
+      def encrypt(plaintext, **options)
+        self.new(**options).encrypt(plaintext)
       end
 
-      protected
-
-      def process(text, offset, direction = :encrypt, alphabet = ALPHABET)
-        offset *= (direction == :encrypt ? 1 : -1)
-        text.each_char.reduce("") do |cyphertext, char|
-          char_idx = alphabet.index(char)
-          cyphertext << alphabet[(char_idx + offset) % alphabet.size]
-        end
+      def decrypt(ciphertext, **options)
+        self.new(**options).decrypt(ciphertext)
       end
     end
+
   end
 end

data/lib/shift_ciphers/error.rb

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

data/lib/shift_ciphers/version.rb

@@ -2,7 +2,7 @@ module ShiftCiphers
   module Version
     MAJOR = 0
     MINOR = 0
-    PATCH = 1
+    PATCH = 2
     LABEL = nil
   end
 

data/lib/shift_ciphers/vigenere.rb

@@ -1,41 +1,72 @@
-require 'shift_ciphers/shift_ciphers'
-
 module ShiftCiphers
   class Vigenere
-    attr_accessor :key, :alphabet
+    attr_accessor :key, :alphabet, :nonalphabet_char_strategy
 
-    def initialize(key, alphabet = ALPHABET)
+    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)
-      self.class.encrypt(plaintext, key, alphabet)
+      process(plaintext, :encrypt)
     end
 
-    def decrypt(cyphertext)
-      self.class.decrypt(cyphertext, key, alphabet)
+    def decrypt(ciphertext)
+      process(ciphertext, :decrypt)
     end
 
-    class << self
-      def encrypt(plaintext, key, alphabet = ALPHABET)
-        process(plaintext, key, :encrypt, alphabet)
+    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 decrypt(cyphertext, key, alphabet = ALPHABET)
-        process(cyphertext, key, :decrypt, alphabet)
+    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
 
-      protected
+    def set_key_offsets
+      @key_offsets = @key.chars.map {|c| alphabet.index(c) }
+    end
 
-      def process(text, key, direction = :encrypt, alphabet = ALPHABET)
-        key_chars = key.chars.cycle
-        text.each_char.reduce("") do |cyphertext, char|
-          char_idx = alphabet.index(char)
-          offset = alphabet.index(key_chars.next) * (direction == :encrypt ? 1 : -1)
-          cyphertext << alphabet[(char_idx + offset) % alphabet.size]
-        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,3 +1,5 @@
 require 'shift_ciphers/version'
+require 'shift_ciphers/alphabets'
+require 'shift_ciphers/error'
 require 'shift_ciphers/caesar'
 require 'shift_ciphers/vigenere'

data/shift_ciphers.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   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.5.0"
+  s.required_ruby_version = ">= 2.1.0"
 
   s.add_development_dependency "bundler", "~> 1.16"
   s.add_development_dependency "pry", "~> 0.11"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shift_ciphers
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Tomasz Więch
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-06 00:00:00.000000000 Z
+date: 2018-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -62,8 +62,9 @@ files:
 - LICENSE
 - README.md
 - lib/shift_ciphers.rb
+- lib/shift_ciphers/alphabets.rb
 - lib/shift_ciphers/caesar.rb
-- lib/shift_ciphers/shift_ciphers.rb
+- lib/shift_ciphers/error.rb
 - lib/shift_ciphers/version.rb
 - lib/shift_ciphers/vigenere.rb
 - shift_ciphers.gemspec
@@ -79,7 +80,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/shift_ciphers/shift_ciphers.rb

@@ -1,6 +0,0 @@
-module ShiftCiphers
-  ALPHABET = ((0..9).to_a.map(&:to_s) +
-              ('a'..'z').to_a +
-              ('A'..'Z').to_a
-             ).join + " !@#$%^&*()-_=+{}[];:'\",./<>?"
-end