wixy 0.0.2

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Eric Watson
+
+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/bin/wixy

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+require 'optparse'
+require 'ostruct'
+require 'wixy'
+
+options = OpenStruct.new
+config = Wixy::Config.new
+
+# Defaults
+options.encrypt = true
+options.decrypt = false
+options.mode = :encrypt
+config.cipher = :caesar
+config.shift = 3
+
+begin
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: #{__FILE__} [options] TEXT"
+  opts.on("-e", "--encrypt", "Encrypt text (default)") do |e|
+    options.encrypt = e
+  end
+
+  ciphers = config.ciphers
+  cipher_names = ciphers
+    .map {|c| "  - [#{c[0]}]#{c[1,c.length-1]}"}
+
+  opts.on("-c", "--cipher CIPHER", ciphers.map(&:to_sym), "Use CIPHER", *cipher_names) do |c|
+    config.cipher = c
+  end
+
+  opts.on("-d", "--decrypt", "Decrypt text") do |d|
+    options.decrypt = d
+  end
+
+  opts.on("-k", "--key KEY", "Use KEY to create cipher") do |k|
+    config.key = k
+  end
+
+  opts.on("-s", "--shift [INTEGER]", Integer, "Alphabet shift") do |s|
+    config.shift = s
+  end
+
+  opts.on_tail("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+  opts.on_tail("-v", "--version", "Show version") do
+    puts Wixy::VERSION
+    exit
+  end
+end.parse!
+rescue => e
+  abort e.message
+end
+
+text = ARGV.pop
+abort(parser) unless text
+options.mode = :decrypt if options.decrypt
+result = Wixy.public_send(options.mode, text, config)
+puts result

data/lib/wixy.rb

@@ -0,0 +1,21 @@
+require 'wixy/version'
+require 'wixy/config'
+require 'wixy/vigenere'
+require 'wixy/caesar'
+require 'wixy/bifid'
+
+module Wixy
+  def self.encrypt(text, config = Config.new)
+    new_cipher(config).encrypt(text)
+  end
+
+  def self.decrypt(text, config = Config.new)
+    new_cipher(config).decrypt(text)
+  end
+
+  private
+  def self.new_cipher(config)
+    klass = config.cipher.to_s.capitalize
+    self.const_get(klass).new(config)
+  end
+end

data/lib/wixy/alphabet.rb

@@ -0,0 +1,60 @@
+module Wixy
+  class Alphabet
+    # chars is an array of character strings, like ["A", "B", "C" ...]
+    def initialize(chars, options = {})
+      @chars = chars.to_a.rotate(options[:shift] || 0)
+      @index = Hash[@chars.each_with_index.to_a]
+      @filters = options[:filters] || []
+    end
+
+    def [](index)
+      @chars[index % @chars.length]
+    end
+
+    def index(char)
+      i = @index[filtered char]
+    end
+
+    def include?(char)
+      index(filtered char)
+    end
+
+    def filtered(char)
+      @filters.inject(char) { |c, f| c.public_send(f) }
+    end
+
+    def sanitize(text_or_chars)
+      chars = if text_or_chars.respond_to?(:chars)
+                text_or_chars.chars
+              else
+                text_or_chars
+              end
+      chars.map {|c| filtered(c) }.map { |c| char_if_present(c) }.compact
+    end
+
+    # Given a char and another alphabet, find the char in this alphabet
+    # at the corresponding index
+    def char(char, other_alphabet)
+      self[other_alphabet.index(char)]
+    end
+
+    def to_s
+      "<Alphabet:[#{@chars.join}]>"
+    end
+
+    private
+    def char_if_present(char)
+      char if index(char)
+    end
+
+    # Factories
+
+    # A basic alphabet of capital English letters. Given a lowercase
+    # letter, will find the corresponding uppercase letters. When
+    # using this alphabet to encrypt or decrypt a message, your result
+    # will be all uppercase.
+    def self.AZ(options = {})
+      self.new ('A'..'Z'), {filters: [:upcase]}.merge(options)
+    end
+  end
+end

data/lib/wixy/bifid.rb

@@ -0,0 +1,11 @@
+require 'wixy/config'
+
+module Wixy
+  class Bifid
+    def encrypt(text)
+      return '' if text == ''
+      return 'F' if text == 'F'
+      'HD'
+    end
+  end
+end

data/lib/wixy/caesar.rb

@@ -0,0 +1,26 @@
+require 'wixy/config'
+require 'wixy/alphabet'
+
+module Wixy
+  class Caesar
+    def initialize(config = Config.new)
+      @text_alphabet = Alphabet.AZ
+      @cipher_alphabet = Alphabet.AZ shift: config.shift
+    end
+
+    def encrypt(text)
+      substitute(text, @text_alphabet, @cipher_alphabet)
+    end
+
+    def decrypt(text)
+      substitute(text, @cipher_alphabet, @text_alphabet)
+    end
+
+    private
+    def substitute(text, source_alphabet, target_alphabet)
+      source_alphabet.sanitize(text).map do |char|
+        target_alphabet.char(char, source_alphabet)
+      end.join
+    end
+  end
+end

data/lib/wixy/config.rb

@@ -0,0 +1,37 @@
+module Wixy
+  class Config
+    attr_accessor :cipher
+    attr_accessor :key
+    attr_accessor :shift
+    attr_accessor :preserve
+
+    def initialize
+      @cipher = :caesar
+      @shift = 3
+      @key = "FORTIFICATION"
+      @preserve = false
+      yield self if block_given?
+    end
+
+    def cipher=(name)
+      c = name.to_sym
+      unless cipher?(c)
+        raise "Unknown cipher: #{name}. Choose from: #{ciphers.join(', ')}"
+      end
+      @cipher = c
+    end
+
+    def shift=s
+      @shift = s.to_i
+    end
+
+    def cipher?(name)
+      ciphers.include? name.to_sym
+    end
+
+    # An array of available ciphers
+    def ciphers
+      [:caesar, :vigenere]
+    end
+  end
+end

data/lib/wixy/version.rb

@@ -0,0 +1,3 @@
+module Wixy
+  VERSION = "0.0.2"
+end

data/lib/wixy/vigenere.rb

@@ -0,0 +1,53 @@
+require 'wixy/config'
+require 'wixy/alphabet'
+
+module Wixy
+  class Vigenere
+    def initialize(config = Config.new)
+      @config = config
+      @alphabet = Alphabet.AZ
+      @key = @alphabet.sanitize(config.key)
+    end
+
+    def encrypt(text)
+      shift = -> index, offset { index + offset }
+      solve text, shift
+    end
+
+    def decrypt(text)
+      shift = -> index, offset { index - offset }
+      solve text, shift
+    end
+
+    private
+    def preserve?
+      @config.preserve
+    end
+
+    def solve(text, shift)
+      result = solve_portion(text.chars.to_a, 0, shift).reverse
+      discard_or_not(result).join
+    end
+
+    def solve_portion(text, i, shift)
+      return text if text.empty?
+      char = text.shift
+      if @alphabet.index(char)
+        solve_portion(text, i + 1, shift) << lookup(char, i, shift)
+      else
+        solve_portion(text, i, shift) << char
+      end
+    end
+
+    def lookup(char, position, shift)
+      index = @alphabet.index(char.upcase)
+      offset = @alphabet.index(@key[position % @key.length])
+      new_index = shift.call(index, offset)
+      @alphabet[new_index]
+    end
+
+    def discard_or_not(chars)
+      preserve? ? chars : @alphabet.sanitize(chars)
+    end
+  end
+end

data/spec/alphabet_spec.rb

@@ -0,0 +1,21 @@
+require 'wixy/alphabet'
+
+describe "Alphabet" do
+  describe "AZ" do
+    let(:alphabet) { Wixy::Alphabet.AZ }
+
+    it "includes 'Z'" do
+      expect(alphabet).to include('Z')
+    end
+
+    it "includes 'z'" do
+      expect(alphabet).to include('z')
+    end
+
+    it "is case-insensitive for search" do
+      expect(alphabet.index 'A').to eq(0)
+      expect(alphabet.index 'a').to eq(0)
+    end
+
+  end
+end

data/spec/bifid_spec.rb

@@ -0,0 +1,22 @@
+require 'wixy/bifid'
+
+
+describe 'Bifid' do
+  let(:bifid) { Wixy::Bifid.new }
+  it "encrypts '' to ''" do
+    result = bifid.encrypt('')
+    expect(result).to eq('')
+  end
+
+  # 'Forsaking monastic tradition, twelve jovial friars gave up their
+  # vocations.'
+  it "encrypts 'F' to 'F'" do
+    result = bifid.encrypt('F')
+    expect(result).to eq('F')
+  end
+
+  it "encrypts 'FO' to 'HD'" do
+    result = bifid.encrypt('FO')
+    expect(result).to eq('HD')
+  end
+end

data/spec/caesar_examples_encrypt_discard.yaml

@@ -0,0 +1,5 @@
+---
+-
+  cleartext:  cipher
+  ciphertext: YELDAN
+  shift:      22

data/spec/caesar_spec.rb

@@ -0,0 +1,25 @@
+require 'example_helper'
+require 'wixy/caesar'
+
+include Wixy
+
+describe "Caesar" do
+  extend ExampleHelpers
+
+  describe "#encrypt" do
+    load_examples("caesar", "encrypt", "discard").each do |example|
+      describe "'#{example['cleartext']}'" do
+        let(:config) {
+          ::Wixy::Config.new do |config|
+            config.shift = example["shift"]
+          end
+        }
+        let(:caesar) { Caesar.new(config) }
+        it "produces '#{example['ciphertext']}'" do
+          result = caesar.encrypt example["cleartext"]
+          expect(result).to eq(example["ciphertext"])
+        end
+      end
+    end
+  end
+end

data/spec/config_spec.rb

@@ -0,0 +1,24 @@
+require 'wixy/config'
+
+describe "Config" do
+  describe "defaults" do
+    subject(:config) { Wixy::Config.new }
+    its(:shift)  { should eq(3) }
+    its(:key)    { should eq("FORTIFICATION") }
+    its(:cipher) { should eq(:caesar) }
+  end
+
+  context "with a block" do
+    let(:key) { "KEY" }
+    let(:shift) { 13 }
+    subject(:config) {
+      Wixy::Config.new do |config|
+        config.key = key
+        config.shift = shift
+      end
+    }
+
+    its(:key) { should eq(key) }
+    its(:shift) { should eq(shift) }
+  end
+end

data/spec/example_helper.rb

@@ -0,0 +1,14 @@
+require 'yaml'
+
+module ExampleHelpers
+  def filename_for(cipher, mode, group=nil)
+    _group = group ? "_#{group}" : ""
+    "#{cipher}_examples_#{mode}#{_group}.yaml"
+  end
+
+  def load_examples(cipher, mode, group)
+    filename = filename_for(cipher, mode, group)
+    path = File.join(File.dirname(__FILE__), filename)
+    examples = YAML.load(File.read(path)) || []
+  end
+end

data/spec/vigenere_examples_decrypt.yaml

@@ -0,0 +1,4 @@
+-
+  cleartext: "KCILIPQPGFWBNXHZVBWIFIMQCAYKVEDJRQVBIZSWWRKALIXENXHUJWIOWHIVIHVTBWOHNMXBKOGIPYJSOBAYMPCXWBGMSWEGNVITKIDRES"
+  ciphertext: "FORSAKINGMONASTICTRADITIONTWELVEJOVIALFRIARSGAVEUPTHEIRVOCATIONFORAQUESTIONABLEEXISTENCEONTHEFLYINGTRAPEZE"
+  key: fortification

data/spec/vigenere_examples_encrypt_discard.yaml

@@ -0,0 +1,83 @@
+---
+# Basic encryption examples
+-
+  ciphertext: IS
+  cleartext: de
+  key: fortification
+-
+  ciphertext: IS
+  cleartext: " d e "
+  key: fortification
+-
+  ciphertext: IS
+  cleartext: "`~!@#$%^d&*()_-=+|]}[{e;:/?>.,<'\\\""
+  key: fortification
+-
+  cleartext:  "123456789"
+  ciphertext: ""
+  key: fortification
+-
+  cleartext:  ""
+  ciphertext: ""
+  key: fortification
+-
+  cleartext:  def
+  ciphertext: ISW
+  key: fortification
+-
+  cleartext:  defendtheeastwallofthecastle
+  ciphertext: ISWXVIBJEXIGGBOCEWKBJEVIGGQS
+  key: fortification
+-
+  cleartext: "Forsaking monastic tradition, twelve jovial friars gave up their vocation for a questionable existence on the flying trapeze."
+  ciphertext: "KCILIPQPGFWBNXHZVBWIFIMQCAYKVEDJRQVBIZSWWRKALIXENXHUJWIOWHIVIHVTBWOHNMXBKOGIPYJSOBAYMPCXWBGMSWEGNVITKIDRES"
+  key: fortification
+-
+  cleartext: "FORSAKINGMONASTICTRADITIONTWELVEJOVIALFRIARSGAVEUPTHEIRVOCATIONFORAQUESTIONABLEEXISTENCEONTHEFLYINGTRAPEZE"
+  ciphertext: "KCILIPQPGFWBNXHZVBWIFIMQCAYKVEDJRQVBIZSWWRKALIXENXHUJWIOWHIVIHVTBWOHNMXBKOGIPYJSOBAYMPCXWBGMSWEGNVITKIDRES"
+  key: fortification
+
+#     it "decrypts" do
+#       result = Vigenere.decrypt(@ciphertext, @key)
+#       expect(result).to eq(@cleartext)
+#     end
+
+#     it "roundtrips" do
+#       intermediate = Vigenere.encrypt(@cleartext, @key)
+#       result = Vigenere.decrypt(intermediate, @key)
+#       expect(result).to eq(@cleartext)
+#     end
+
+#     # default key = 'SUSHIFROGGY'
+#     describe "using the default key" do
+#       before do
+#         @ciphertext = "XIJZIPZBMSMFUKAQHKFGJGLCGUBBVZBKHGPAHTKIWGXQYUNLCUKVKOPNIUHBNFBLUPSKMLAYZCTGZDYWEQXKSTICGHLOMKCMOTELLSWMEV"
+#       end
+
+#       it "uses default if no key is given" do
+#         result = Vigenere.encrypt(@cleartext)
+#         expect(result).to eq(@ciphertext)
+#       end
+
+#       it "decrypts" do
+#         result = Vigenere.decrypt(@ciphertext)
+#         expect(result).to eq(@cleartext)
+#       end
+
+#       it "roundtrips" do
+#         intermediate = Vigenere.encrypt(@cleartext)
+#         result = Vigenere.decrypt(intermediate)
+#         expect(result).to eq(@cleartext)
+#       end
+#     end
+
+#     describe "decrypting" do
+#       it "decrypts 'defendtheeastwallofthecastle' to 'ISWXVIBJEXIGGBOCEWKBJEVIGGQS'" do
+#         cleartext = "defendtheeastwallofthecastle"
+#         ciphertext = "ISWXVIBJEXIGGBOCEWKBJEVIGGQS"
+#         result = Vigenere.decrypt(ciphertext, @key)
+#         expect(result).to eq(cleartext.toUpperCase())
+#       end
+#     end
+#   end
+# end

data/spec/vigenere_examples_encrypt_preserve.yaml

@@ -0,0 +1,17 @@
+---
+-
+  ciphertext: "`~!@#$%^I&*()_-=+|]}[{S;:/?>.,<'\\\""
+  cleartext: "`~!@#$%^d&*()_-=+|]}[{e;:/?>.,<'\\\""
+  key: fortification
+-
+  cleartext:  "123456789"
+  ciphertext: "123456789"
+  key: fortification
+-
+  cleartext:  ""
+  ciphertext: ""
+  key: fortification
+-
+  cleartext: "Forsaking monastic tradition, twelve jovial friars gave up their vocation for a questionable existence on the flying trapeze."
+  ciphertext: "KCILIPQPG FWBNXHZV BWIFIMQCA, YKVEDJ RQVBIZ SWWRKA LIXE NX HUJWI OWHIVIHV TBW O HNMXBKOGIPYJ SOBAYMPCX WB GMS WEGNVI TKIDRES."
+  key: fortification

data/spec/vigenere_spec.rb

@@ -0,0 +1,47 @@
+require 'wixy/vigenere'
+require 'example_helper'
+
+module ConfigHelpers
+  def create_config(options)
+    Wixy::Config.new do |config|
+      options.each do |key, value|
+        config.public_send("#{key}=", value)
+      end
+    end
+  end
+end
+
+include Wixy
+
+describe "Vigenere" do
+  extend ExampleHelpers
+  include ConfigHelpers
+
+  load_examples("vigenere", "encrypt", "discard").each do |e|
+    describe "'#{e['cleartext']}' -> '#{e['ciphertext']}'" do
+      let(:config) { create_config(key: e['key']) }
+      let(:cleartext) { e['cleartext'] }
+      let(:ciphertext) { e['ciphertext'] }
+      let(:vigenere) { Vigenere.new(config) }
+
+      it "encrypts" do
+        result = vigenere.encrypt e['cleartext']
+        expect(result).to eq(e['ciphertext'])
+      end
+    end
+  end
+
+  load_examples("vigenere", "encrypt", "preserve").each do |e|
+    describe "'#{e['cleartext']}' -> '#{e['ciphertext']}'" do
+      let(:config) { create_config(key: e['key'], preserve: true) }
+      let(:cleartext) { e['cleartext'] }
+      let(:ciphertext) { e['ciphertext'] }
+      let(:vigenere) { Vigenere.new(config) }
+
+      it "encrypts" do
+        result = vigenere.encrypt e['cleartext']
+        expect(result).to eq(e['ciphertext'])
+      end
+    end
+  end
+end

data/spec/wixy_spec.rb

@@ -0,0 +1,45 @@
+require 'wixy'
+
+describe "Wixy" do
+  let(:plaintext) { 'FORSAKINGMONASTICTRADITIONTWELVEJOVIALFRIARSGAVEUPTHEIRVOCATIONFORAQUESTIONABLEEXISTENCEONTHEFLYINGTRAPEZE' }
+  let(:ciphertext) { 'IRUVDNLQJPRQDVWLFWUDGLWLRQWZHOYHMRYLDOIULDUVJDYHXSWKHLUYRFDWLRQIRUDTXHVWLRQDEOHHALVWHQFHRQWKHIOBLQJWUDSHCH' }
+
+  describe "as a library" do
+    let(:config) { Wixy::Config.new }
+
+    it "encrypts" do
+      result = Wixy.encrypt plaintext, config
+      expect(result).to eq(ciphertext)
+    end
+
+    it "decrypts" do
+      result = Wixy.decrypt ciphertext, config
+      expect(result).to eq(plaintext)
+    end
+  end
+
+  describe "CLI" do
+    let(:wixy) { File.expand_path "../../bin/wixy", __FILE__ }
+
+    # Hack to help the binary find library files. When installed as a
+    # gem, rubygems takes care of this.
+    before :all do
+      @old_rubylib = ENV['RUBYLIB']
+      ENV['RUBYLIB'] = File.expand_path "../../lib", __FILE__
+    end
+
+    after :all do
+      ENV['RUBYLIB'] = @old_rubylib
+    end
+
+    it "encrypts" do
+      result = `#{wixy} #{plaintext}`.chomp
+      expect(result).to eq(ciphertext)
+    end
+
+    it "decrypts" do
+      result = `#{wixy} --decrypt #{ciphertext}`.chomp
+      expect(result).to eq(plaintext)
+    end
+  end
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: wixy
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Eric Watson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description: ! "    A library for working with classical ciphers of the\n    pencil-and-paper
+  sort.\n"
+email: wasnotrice@gmail.com
+executables:
+- wixy
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/wixy.rb
+- lib/wixy/alphabet.rb
+- lib/wixy/bifid.rb
+- lib/wixy/caesar.rb
+- lib/wixy/config.rb
+- lib/wixy/version.rb
+- lib/wixy/vigenere.rb
+- LICENSE
+- spec/alphabet_spec.rb
+- spec/bifid_spec.rb
+- spec/caesar_examples_encrypt_discard.yaml
+- spec/caesar_spec.rb
+- spec/config_spec.rb
+- spec/example_helper.rb
+- spec/vigenere_examples_decrypt.yaml
+- spec/vigenere_examples_encrypt_discard.yaml
+- spec/vigenere_examples_encrypt_preserve.yaml
+- spec/vigenere_spec.rb
+- spec/wixy_spec.rb
+- bin/wixy
+homepage: http://rubygems.org/gems/wixy
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: wixy
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Classical, pencil-and-paper ciphers
+test_files:
+- spec/alphabet_spec.rb
+- spec/bifid_spec.rb
+- spec/caesar_examples_encrypt_discard.yaml
+- spec/caesar_spec.rb
+- spec/config_spec.rb
+- spec/example_helper.rb
+- spec/vigenere_examples_decrypt.yaml
+- spec/vigenere_examples_encrypt_discard.yaml
+- spec/vigenere_examples_encrypt_preserve.yaml
+- spec/vigenere_spec.rb
+- spec/wixy_spec.rb