sub_cipher 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: efc3e2913656d45254d35d24732ffe43218d23e8
+  data.tar.gz: 0425ba813eb72cf118b906863b7ee445564c3c5d
+SHA512:
+  metadata.gz: 2ed311f95e325bd5c6253c16370e4d4a8bcd7d99fd6accb6412b052a2095973542fe88e5ec04d1ac8cdc8790deb531f930c173c8f7b9332d2f01490109d154af
+  data.tar.gz: f626cd93638eb663944c9b48ddb0ac7f10fcc2fe43be608bdf51326d78047d45f676cf8d22477925cbc80bf93019d659fd1b2716188c60c78497f1a8a9397353

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/HISTORY.md

@@ -0,0 +1,7 @@
+## v1.0.1 / 2014-10-15
+
+* [Doc] Fix too long description issue in gemspec
+
+## v1.0.0 / 2014-10-15
+
+* [Init] Initial Release

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Sibevin Wang
+
+MIT License
+
+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

@@ -0,0 +1,112 @@
+# Sub(stitution) Cipher
+
+[![Gem Version](https://badge.fury.io/rb/sub_cipher.png)][gem]
+[![Build Status](https://travis-ci.org/sibevin/sub_cipher.png?branch=build)][travis]
+[![Coverage Status](https://coveralls.io/repos/sibevin/sub_cipher/badge.png?branch=cover-check)][coveralls]
+
+[gem]: https://rubygems.org/gems/sub_cipher
+[travis]: https://travis-ci.org/sibevin/sub_cipher
+[coveralls]:https://coveralls.io/r/sibevin/sub_cipher?branch=cover-check
+
+Encode/Decode text with the substitution cipher
+
+## Installation
+
+    $ gem install sub_cipher
+
+## Usage
+
+Use default seeds(alphabets) to generate the mapping, note that the letters with different cases would be mapped to the same letter, for example: if "a" is mapped to "b", then "A" is mapped to "B".
+
+    sc = SubCipher.gen
+    sc.encode("Here is a secret.")
+    # "Wyky gn q nyakyr."
+    sc.decode("Wyky gn q nyakyr.")
+    # "Here is a secret."
+    sc.seed
+    # "abcdefghijklmnopqrstuvwxyz"
+    sc.map
+    # "qeahyftwgpjixodzbknrlscvum"
+
+The `seed` and `map` method shows how to map the cipher, the above example means mapping `"abcdefghijklmnopqrstuvwxyz"` to `"qeahyftwgpjixodzbknrlscvum"`
+
+## Options
+
+### Seed
+
+Use `:s` (or `:seed`) to map the given seeds only
+
+    sc = SubCipher.gen(seed: "abcde")
+    sc.encode("Here is a secret.")
+    # "Hcrc is e scbrct."
+    sc.decode("Hcrc is e scbrct.")
+    # "Here is a secret."
+    sc.seed
+    # "abcde"
+    sc.map
+    # "edbac"
+
+### Map
+
+Use `:m` (or `:map`) option to initalize cipher with a map. Note that the `:seed` option would be skipped if both `:seed` and `:map` options are given.
+
+    sc = SubCipher.gen(seed: "bdeac")
+    sc.encode("Here is a secret.")
+    # "Hara is b saerat."
+    sc.decode("Hara is b saerat.")
+    # "Here is a secret."
+    sc.seed
+    # "abcde"
+    sc.map
+    # "bdeca"
+
+### Keep Case
+
+If you want to map letters with different cases to different letters, use `k: false` (or `keep_case: false`) option.
+
+    sc = SubCipher.gen(keep_case: false)
+    sc.encode("Here is a secret.")
+    # "alXl wE s EleXlk."
+    sc.decode("alXl wE s EleXlk.")
+    # "Here is a secret."
+    sc.seed
+    # "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
+    sc.map
+    # "PNAgWKOaxtCUdqHpIuJRhjTMnDsbeQlFiGwrzLfBvVYXEkZcoSmy"
+
+If there is a seed(assigned by `seed` or `map` option) which is not an alphabet, `keep_case: false` would be applied.
+
+    sc = SubCipher.gen(seed: "abcdeABCDE ,.")
+    sc.encode("Here is a secret.")
+    # "HdrdAisA,AsdBrdtE"
+    sc.decode("HdrdAisA,AsdBrdtE")
+    # "Here is a secret."
+    sc.seed
+    # " ,.ABCDEabcde"
+    sc.map
+    # "AaE ebCc,DB.d"
+
+## Test
+
+Go to gem folder and run
+
+    ruby ./test/test_all.rb
+
+(Note that you need minitest ~> 5.0 to run these tests)
+
+# Contributing
+
+1. Fork it ( https://github.com/sibevin/sub_cipher/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Write tests for your code
+4. Commit your changes (both code and tests) (`git commit -am 'Add some feature'`)
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create a new Pull Request
+
+## Authors
+
+Sibevin Wang
+
+## Copyright
+
+Copyright (c) 2014 Sibevin Wang. Released under the MIT license.

data/lib/sub_cipher.rb

@@ -0,0 +1,161 @@
+require "sub_cipher/sub_cipher_error"
+
+module SubCipher
+  # The alphabet seed
+  ALPHABETS = ('a'..'z')
+
+  # The supported options
+  SUPPORTED_OPTS = {
+    :seed => {
+      :abbr => :s,
+      :type => String
+    },
+    :map => {
+      :abbr => :m,
+      :type => String
+    },
+    :keep_case => {
+      :abbr => :k
+    },
+  }
+
+  # The default options
+  DEFAULT_OPTS = {
+    :seed => [ALPHABETS.to_a, ALPHABETS.to_a.map{ |a| a.upcase }].flatten.join,
+    :keep_case => true
+  }
+
+  # The major method to generate a sub cipher.
+  # @param options [Hash]
+  #   The options to tell sub cipher how to encode/decode.
+  #   Three options :seed, :map and :keep_case are supported.
+  #   Please see {file:README} to get more examples
+  # @return [SubCipherObject]
+  #   The generated sub cipher.
+  # @raise [SubCipherError]
+  #   Please see {SubCipher::SubCipherError}
+  def SubCipher.gen(options = {})
+    SubCipherObject.new(options)
+  end
+
+  # The sub cipher class.
+  class SubCipherObject
+    # The sub cipher contructor.
+    # @param options (see SubCipher.gen)
+    # @return (see SubCipher.gen)
+    # @raise (see SubCipher.gen)
+    def initialize(options)
+      opts = check_opt(options)
+      opts.each do |key, value|
+        if (!SUPPORTED_OPTS.key?(key) && !SUPPORTED_OPTS.values.map {|v| v[:abbr]}.include?(key))
+          raise SubCipherError.new(:unknown_option, key)
+        end
+        case key
+        when :seed
+          @map = value.chars.to_a.uniq.shuffle
+        when :map
+          @map = value.chars.to_a.uniq
+        when :keep_case
+          @keep_case = (value ? true : false)
+        end
+      end
+      support_keep_case = true
+      @map.each do |m|
+        if !ALPHABETS.include?(m.downcase)
+          support_keep_case = false
+          break
+        end
+      end
+      @keep_case = (support_keep_case && @keep_case ? true : false)
+      if @keep_case
+        @map = @map.map{ |m| m.downcase }.uniq
+      end
+      seed = @map.sort
+      @mapping = {}
+      seed.each_with_index do |s, index|
+        @mapping[s] = @map[index]
+      end
+    end
+
+    # Encode the given string.
+    # @param str [String]
+    #   The original string to encode.
+    # @return [String]
+    #   The encoded result.
+    def encode(str)
+      str.chars.map { |c| convert(c) }.join
+    end
+
+    # Decode the given string.
+    # @param str [String]
+    #   The encoded string to decode.
+    # @return [String]
+    #   The decoded result.
+    def decode(str)
+      str.chars.map { |c| convert(c, true) }.join
+    end
+
+    # Show the map string, for mapping display.
+    # For example, if the seed string is "abc" and map string is "cab",
+    # then the mapping is "a" => "c", "b" => "a", "c" => "b".
+    # @return [String]
+    #   The map string.
+    def map
+      @map.join
+    end
+
+    # Show the seed string, for mapping display.
+    # For example, if the seed string is "abc" and map string is "cab",
+    # then the mapping is "a" => "c", "b" => "a", "c" => "b".
+    # @return [String]
+    #   The seed string.
+    def seed
+      @map.sort.join
+    end
+
+    private
+
+    # Covert single char with the mapping.
+    def convert(char, reverse = false)
+      if @keep_case
+        if reverse
+          if @mapping.value?(char)
+            return @mapping.index(char)
+          elsif @mapping.value?(char.downcase)
+            return @mapping.index(char.downcase).upcase
+          else
+            return char
+          end
+        else
+          if @mapping.key?(char)
+            return @mapping[char]
+          elsif @mapping.key?(char.downcase)
+            return @mapping[char.downcase].upcase
+          else
+            return char
+          end
+        end
+      else
+        if reverse
+          @mapping.value?(char) ? @mapping.index(char) : char
+        else
+          @mapping.key?(char) ? @mapping[char] : char
+        end
+      end
+    end
+
+    # Check the given options.
+    def check_opt(opts)
+      SUPPORTED_OPTS.each do |key, value|
+        if (opts[key] != nil) && opts.keys.include?(value[:abbr])
+          raise SubCipherError.new(:duplicated_option, opts)
+        end
+        opts.merge!(key => opts[value[:abbr]]) if opts[value[:abbr]] != nil
+        if (opts[key] != nil) && (value[:type] != nil) && !(opts[key]).is_a?(value[:type])
+          raise SubCipherError.new(:invalid_option_value, opts)
+        end
+      end
+      DEFAULT_OPTS.merge(opts)
+    end
+  end
+end

data/lib/sub_cipher/sub_cipher_error.rb

@@ -0,0 +1,46 @@
+module SubCipher
+
+  # A customized exception for SubCipher
+  class SubCipherError < StandardError
+
+    # Errors used in SubCipher
+    ERRORS = {
+      :unknown_option => {
+        :value => 1,
+        :msg => "Unknown option"
+      },
+      :duplicated_option => {
+        :value => 2,
+        :msg => "The same options are given."
+      },
+      :invalid_option_value => {
+        :value => 3,
+        :msg => "The given option value is invalid."
+      },
+    }
+
+    attr_reader :code, :value, :msg, :info
+
+    # The SubCipherError constructor.
+    # @param error [Fixnum, String]
+    #   You can give a error number defined in the keys of {SubCipher::SubCipherError::ERRORS} or a string message for internal usage.
+    # @param info [Hash]
+    #   Anything you want to put in the info attribute of SubCipherError.
+    def initialize(error, info = {})
+      @code = error
+      @info = info
+      if ERRORS.keys.include?(error)
+        @value = ERRORS[error][:value]
+        @msg = ERRORS[error][:msg]
+      elsif error.class.name == 'String'
+        @code = :internal
+        @value = 90000
+        @msg = error
+      else
+        @code = :internal
+        @value = 99999
+        @msg = "Internal Error"
+      end
+    end
+  end
+end

data/lib/sub_cipher/version.rb

@@ -0,0 +1,3 @@
+module SubCipher
+  VERSION = "1.0.1"
+end

data/sub_cipher.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sub_cipher/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sub_cipher"
+  spec.version       = SubCipher::VERSION
+  spec.authors       = ["Sibevin Wang"]
+  spec.email         = ["sibevin@gmail.com"]
+  spec.summary       = %q{Encode/Decode text with substitution cipher}
+  spec.description   = %q{Encode/Decode text with substitution cipher, please see "README" to get more details.}
+  spec.homepage      = "https://github.com/sibevin/sub_cipher"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency 'minitest', '~> 5.0'
+end

data/test/test_all.rb

@@ -0,0 +1,97 @@
+require 'minitest/autorun'
+
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}")
+require "test_helper"
+require "sub_cipher"
+
+class TestByte < Minitest::Test
+  def test_should_encode_and_decode_with_default_seed
+    sc = SubCipher.gen()
+    target_str = 'In cryptography, a substitution cipher is a method of encoding by which units of plaintext are replaced with ciphertext, according to a regular system; the "units" may be single letters (the most common), pairs of letters, triplets of letters, mixtures of the above, and so forth. The receiver deciphers the text by performing an inverse substitution.'
+    encoded_str = sc.encode(target_str)
+    decoded_str = sc.decode(encoded_str)
+    assert_equal(decoded_str, target_str)
+    assert_equal(sc.seed, ('a'..'z').to_a.join)
+    assert_match(/^[a-z]*$/, sc.map)
+  end
+
+  def test_should_encode_and_decode_with_keep_case_false
+    sc = SubCipher.gen(:keep_case => false)
+    target_str = 'In cryptography, a substitution cipher is a method of encoding by which units of plaintext are replaced with ciphertext, according to a regular system; the "units" may be single letters (the most common), pairs of letters, triplets of letters, mixtures of the above, and so forth. The receiver deciphers the text by performing an inverse substitution.'
+    encoded_str = sc.encode(target_str)
+    decoded_str = sc.decode(encoded_str)
+    assert_equal(decoded_str, target_str)
+    assert_equal(sc.seed, [('a'..'z').to_a, ('a'..'z').to_a.map{ |a| a.upcase }].flatten.sort.join)
+    assert_match(/^[a-zA-Z]*$/, sc.map)
+
+    sc = SubCipher.gen(:k => false)
+    target_str = 'In cryptography, a substitution cipher is a method of encoding by which units of plaintext are replaced with ciphertext, according to a regular system; the "units" may be single letters (the most common), pairs of letters, triplets of letters, mixtures of the above, and so forth. The receiver deciphers the text by performing an inverse substitution.'
+    encoded_str = sc.encode(target_str)
+    decoded_str = sc.decode(encoded_str)
+    assert_equal(decoded_str, target_str)
+  end
+
+  def test_should_encode_the_given_seed_only
+    seed = "abc"
+    sc = SubCipher.gen(:seed => seed)
+    target_str = "aaabbbcccdddeee"
+    encoded_str = sc.encode(target_str)
+    assert_match(/^[abc]{9}dddeee$/, encoded_str)
+    assert_equal(sc.seed, seed.chars.sort.join)
+    assert_match(/^[abc]*$/, sc.map)
+
+    sc = SubCipher.gen(:s => seed)
+    target_str = "aaabbbcccdddeee"
+    encoded_str = sc.encode(target_str)
+    assert_match(/^[abc]{9}dddeee$/, encoded_str)
+  end
+
+  def test_should_encode_with_the_given_map
+    map = "bca"
+    sc = SubCipher.gen(:map => map)
+    target_str = "aaabbbcccdddeee"
+    encoded_str = sc.encode(target_str)
+    assert(encoded_str == "bbbcccaaadddeee")
+    assert_equal(sc.seed, map.chars.to_a.uniq.sort.join)
+    assert_match(/^[abc]*$/, sc.map)
+
+    sc = SubCipher.gen(:m => map)
+    target_str = "aaabbbcccdddeee"
+    encoded_str = sc.encode(target_str)
+    assert(encoded_str == "bbbcccaaadddeee")
+  end
+
+  def test_should_keep_the_case_by_default
+    map = "bca"
+    sc = SubCipher.gen(:map => map)
+    target_str = "AAAbbbcccdddeee"
+    encoded_str = sc.encode(target_str)
+    assert(encoded_str == "BBBcccaaadddeee")
+    assert_equal(sc.seed, map.chars.to_a.uniq.sort.join)
+    assert_match(/^[abc]*$/, sc.map)
+  end
+
+  def test_should_mix_cases_if_keep_case_false
+    seed = "abcABC"
+    sc = SubCipher.gen(:seed => seed, :keep_case => false)
+    target_str = "aaabbbcccdddeee"
+    encoded_str = sc.encode(target_str)
+    assert_match(/^[abcABC]{9}dddeee$/, encoded_str)
+    assert_equal(sc.seed, seed.chars.sort.join)
+  end
+
+  def test_should_raise_unknown_option_exception
+    e = assert_raises(SubCipher::SubCipherError) { SubCipher.gen(:unknown_option => "unknown_option") }
+    assert(e.code == :unknown_option)
+  end
+
+  def test_should_raise_duplicated_option_exception
+    e = assert_raises(SubCipher::SubCipherError) { SubCipher.gen(:map => "abc", :m => "def") }
+    assert(e.code == :duplicated_option)
+  end
+
+  def test_should_raise_invalid_option_value_exception
+    e = assert_raises(SubCipher::SubCipherError) { SubCipher.gen(:map => ["a","b","c"]) }
+    assert(e.code == :invalid_option_value)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1 @@
+$LOAD_PATH.unshift("#{File.dirname(__FILE__)}/../lib")

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: sub_cipher
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- Sibevin Wang
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Encode/Decode text with substitution cipher, please see "README" to get
+  more details.
+email:
+- sibevin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- HISTORY.md
+- LICENSE.txt
+- README.md
+- lib/sub_cipher.rb
+- lib/sub_cipher/sub_cipher_error.rb
+- lib/sub_cipher/version.rb
+- sub_cipher.gemspec
+- test/test_all.rb
+- test/test_helper.rb
+homepage: https://github.com/sibevin/sub_cipher
+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: Encode/Decode text with substitution cipher
+test_files:
+- test/test_all.rb
+- test/test_helper.rb