morseficator 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 701e8ad0c9dbac4e8d21a1b8147a64a6c0c69d4c1656ddabc4305473b203ea73
+  data.tar.gz: bc777718fb99edae238894d99c61026e953d6a7ecc671dcb53946eb6e6470736
+SHA512:
+  metadata.gz: 1b754b1f2a0ec85ae3a1ec68f939a41f1253e3a56dce429959ec1e24110d9e8dfccbf14643c49fcdbecff48016c29ac201f7f9fcae75cd1990d4efad8986d545
+  data.tar.gz: 76008d058985eab5fc9e172049cd2f9227f00e6fd556e6d01bd4f41f55d82ea68651c28d5ec467ccea293366e145f423ec1f12724787b35afc1e3b867efde895

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,6 @@
+AllCops:
+  NewCops: enable
+
+Metrics/BlockLength:
+  Exclude:
+    - spec/**/*

data/Gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in morseficator.gemspec
+gemspec
+
+gem 'rake', '~> 12.0'
+gem 'rspec', '~> 3.0'

data/Gemfile.lock

@@ -0,0 +1,37 @@
+PATH
+  remote: .
+  specs:
+    morseficator (0.1.0)
+      bundler
+      clamp (~> 1.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    clamp (1.3.2)
+    diff-lcs (1.4.4)
+    rake (12.3.3)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  morseficator!
+  rake (~> 12.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.1.4

data/README.md

@@ -0,0 +1,54 @@
+# Morseficator
+
+You're competing in a battle on a far away planet and you're in some trouble. You need to send a distress call to your home base for reinforcements, however, enemy agents are listening. Luckily your team have a secret encoding for messages. It's Morse code with further obfuscation.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'morseficator'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install morseficator
+
+## Usage
+
+```
+Usage:
+    morseficator [OPTIONS] [TEXT]
+
+Parameters:
+    [TEXT]             text to hide from an enemy
+
+Options:
+    -f, --file FILE    use a file as an input
+    -h, --help         print help
+```
+
+Alternatively you can use `Morseficator` module directly in your code:
+
+```ruby
+irb(main):001:0> require 'morseficator'
+=> true
+irb(main):002:0> Morseficator.run(text: 'HELLO WORLD')
+=> "4|1|1a2|1a2|c/1b|c|1a1|1a2|a2"
+irb(main):003:0> Morseficator.run(file: '/path/to/file')
+=> "1a|3|a2\n1a|3|a2"
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/duderman/morseficator.

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'morseficator'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/morseficator

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'clamp'
+require 'morseficator'
+
+RED = '\033[0;31m'
+NC = '\033[0m'
+
+Clamp do
+  parameter '[TEXT]', 'text to hide from an enemy', attribute_name: :text
+  option ['-f', '--file'], 'FILE', 'use a file as an input', attribute_name: :file
+
+  def execute
+    puts Morseficator.run(text: text, file: file)
+  rescue Morseficator::Input::Error => e
+    signal_usage_error(red(e.message))
+  rescue Morseficator::Error => e
+    signal_error(red(e.message))
+  end
+
+  private
+
+  def red(message)
+    "\e[31m#{message}\e[0m"
+  end
+end

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/morseficator.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'morseficator/version'
+
+# Main module
+module Morseficator
+  class Error < StandardError; end
+
+  autoload :Encryptor, 'morseficator/encryptor.rb'
+  autoload :LetterEncoder, 'morseficator/letter_encoder.rb'
+  autoload :WordEncoder, 'morseficator/word_encoder.rb'
+  autoload :LineEncoder, 'morseficator/line_encoder.rb'
+  autoload :Encoder, 'morseficator/encoder.rb'
+  autoload :Input, 'morseficator/input.rb'
+
+  module_function
+
+  def run(text: nil, file: nil)
+    input = Input.build(text: text, file: file)
+    Encoder.encode(input)
+  end
+end

data/lib/morseficator/encoder.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Morseficator
+  # Encodes given input and prints it to output
+  class Encoder
+    def self.encode(*args)
+      new(*args).call
+    end
+
+    def initialize(input)
+      @input = input
+    end
+
+    def call
+      @input.map_lines { LineEncoder.encode(_1) }.join("\n")
+    end
+  end
+end

data/lib/morseficator/encryptor.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Morseficator
+  # Converts a single letter to a matching morse code
+  module Encryptor
+    CYPHER = {
+      'A' => '1a',
+      'B' => 'a3',
+      'C' => 'a1a1',
+      'D' => 'a2',
+      'E' => '1',
+      'F' => '2a1',
+      'G' => 'b1',
+      'H' => '4',
+      'I' => '2',
+      'J' => '1c',
+      'K' => 'a1a',
+      'L' => '1a2',
+      'M' => 'b',
+      'N' => 'a1',
+      'O' => 'c',
+      'P' => '1b1',
+      'Q' => 'b1a',
+      'R' => '1a1',
+      'S' => '3',
+      'T' => 'a',
+      'U' => '2a',
+      'V' => '3a',
+      'W' => '1b',
+      'X' => 'a2a',
+      'Y' => 'a1b',
+      'Z' => 'b2',
+      '0' => 'e',
+      '1' => '1d',
+      '2' => '2c',
+      '3' => '3b',
+      '4' => '4a',
+      '5' => '5',
+      '6' => 'a4',
+      '7' => 'b3',
+      '8' => 'c2',
+      '9' => 'd1'
+    }.freeze
+
+    module_function
+
+    def encrypt(letter)
+      raise(Morseficator::Error, "Argument isn't a string") unless letter.is_a?(String)
+      raise(Morseficator::Error, 'Only single letters are supported') if letter.length > 1
+
+      return '' if letter.empty?
+
+      CYPHER[letter.to_s] || raise(Morseficator::Error, "Unkonwn letter '#{letter}'")
+    end
+  end
+end

data/lib/morseficator/input.rb

@@ -0,0 +1,22 @@
+module Morseficator
+  # Input factory
+  module Input
+    class Error < Error; end
+
+    autoload :String, 'morseficator/input/string.rb'
+    autoload :File, 'morseficator/input/file.rb'
+
+    module_function
+
+    def build(text: nil, file: nil)
+      raise(Error, 'Missing an input') unless text || file
+      raise(Error, 'Chose either text or file input') if text && file
+
+      if text
+        String.new(text)
+      else
+        File.new(file)
+      end
+    end
+  end
+end

data/lib/morseficator/input/file.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Morseficator
+  module Input
+    # Represents a file input
+    class File
+      def initialize(file)
+        @file = file
+      end
+
+      def map_lines(&block)
+        file.each_line.map { block.call(_1.chomp) }
+      end
+
+      private
+
+      def file
+        ::File.open(@file, 'r')
+      rescue Errno::ENOENT
+        raise(Morseficator::Input::Error, "File '#{@file}' wasn't found")
+      rescue Errno::EACCES
+        raise(Morseficator::Input::Error, "Don't have access to a file '#{@file}'")
+      rescue StandardError
+        raise(Morseficator::Input::Error, "Can't open file '#{@file}'")
+      end
+    end
+  end
+end

data/lib/morseficator/input/string.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Morseficator
+  module Input
+    # String input adapter
+    class String
+      def initialize(string)
+        @string = string
+      end
+
+      def map_lines(&block)
+        @string.split("\n").map(&block)
+      end
+    end
+  end
+end

data/lib/morseficator/letter_encoder.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Morseficator
+  # Encodes a single letter
+  class LetterEncoder
+    def self.encode(*args)
+      new(*args).call
+    end
+
+    def initialize(letter)
+      @letter = letter
+    end
+
+    def call
+      Encryptor.encrypt(letter)
+    end
+
+    private
+
+    def letter
+      @letter.to_s.upcase
+    end
+  end
+end

data/lib/morseficator/line_encoder.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Morseficator
+  # Encodes a line of text word by word joining the result using a separator
+  class LineEncoder
+    def self.encode(*args)
+      new(*args).call
+    end
+
+    SEPARATOR = '/'
+    SPLIT_BY = ' '
+
+    def initialize(object)
+      @object = object
+    end
+
+    def call
+      entities.map { encoder.encode(_1) }.join(self.class::SEPARATOR)
+    end
+
+    private
+
+    def encoder
+      WordEncoder
+    end
+
+    def entities
+      @object.split(self.class::SPLIT_BY)
+    end
+  end
+end

data/lib/morseficator/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Morseficator
+  VERSION = '0.1.0'
+end

data/lib/morseficator/word_encoder.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Morseficator
+  # Encodes a word letter by letter joining the result using a separator
+  class WordEncoder < LineEncoder
+    def self.encode(*args)
+      new(*args).call
+    end
+
+    SEPARATOR = '|'
+    SPLIT_BY = ''
+
+    private
+
+    def encoder
+      LetterEncoder
+    end
+  end
+end

data/morseficator.gemspec

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'lib/morseficator/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'morseficator'
+  spec.version       = Morseficator::VERSION
+  spec.authors       = ['Nikolay Norkin']
+  spec.email         = ['zduderman@gmail.com']
+
+  spec.summary       = 'Gem that can hide your communications from an enemy'
+  spec.description   = 'Takes a message you are willing to send and encrypts
+                          it using a top-secret algorithm'
+  spec.homepage      = 'https://github.com/duderman/morseficator'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.7.0')
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/duderman/morseficator'
+
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.executables   = 'morseficator'
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'bundler'
+  spec.add_runtime_dependency 'clamp', '~> 1.3'
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: morseficator
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nikolay Norkin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-10-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: clamp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: |-
+  Takes a message you are willing to send and encrypts
+                            it using a top-secret algorithm
+email:
+- zduderman@gmail.com
+executables:
+- morseficator
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/console
+- bin/morseficator
+- bin/setup
+- lib/morseficator.rb
+- lib/morseficator/encoder.rb
+- lib/morseficator/encryptor.rb
+- lib/morseficator/input.rb
+- lib/morseficator/input/file.rb
+- lib/morseficator/input/string.rb
+- lib/morseficator/letter_encoder.rb
+- lib/morseficator/line_encoder.rb
+- lib/morseficator/version.rb
+- lib/morseficator/word_encoder.rb
+- morseficator.gemspec
+homepage: https://github.com/duderman/morseficator
+licenses: []
+metadata:
+  homepage_uri: https://github.com/duderman/morseficator
+  source_code_uri: https://github.com/duderman/morseficator
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Gem that can hide your communications from an enemy
+test_files: []