inline_encryption 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 16d2dbac242627fd934085109d15186d5ce6467c
-  data.tar.gz: ebb1094e6923741890f66e725f5dab491e4c9cda
+SHA256:
+  metadata.gz: 8579ebc960ba6c9f084553a3f948c18aa15013c5ceda7d4ff9d84191b386defa
+  data.tar.gz: cbb00c55dadcfba3f757e90222aa04e5779037afd9fee2b0fddaf35937c06983
 SHA512:
-  metadata.gz: a1534f625ef45b19cc5b188169c9fd76ba74005fef25ca9ef97f26a37e9156e7711a185aa66eb08c5fb50f380acbd78accc43ef178d904030be058665a45db76
-  data.tar.gz: bc230d72d58413c72c528c6ce5245181dc60a088c0cb4386dd522162cb9ca1f07523e26623de9bd8176ce34c60fd55654ec57c4921006cda85ab41412283432f
+  metadata.gz: 9a4d667b844ce6bdd816022d4abd763a6488d89cec23e9e32680748e6f2a9eb6e5d489ae419c6a9eb5f1382ba7579e7997334aa8581fd144312293a23aea0f5f
+  data.tar.gz: 1adff188699044cf0e9facff5393e96a47f20393335b7ee45e5de761fa438ced3d8b3b5865d9b87755c8b5137f380b9771d08732d6ad28cac9201e54dcae6c95

data/.pre-commit-config.yaml

@@ -0,0 +1,21 @@
+repos:
+-   hooks:
+    -   id: check-added-large-files
+    -   id: check-merge-conflict
+    -   id: check-yaml
+    -   id: detect-aws-credentials
+    -   id: detect-private-key
+    -   id: end-of-file-fixer
+    -   id: trailing-whitespace
+    repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v4.1.0
+-   hooks:
+    -   id: commitizen
+        stages:
+        - commit-msg
+    repo: https://github.com/commitizen-tools/commitizen
+    rev: v2.20.3
+-   hooks:
+    -   id: rubocop
+    repo: https://github.com/jumanjihouse/pre-commit-hooks
+    rev: 2.1.5

data/.rubocop.yml

@@ -0,0 +1,12 @@
+inherit_from: .rubocop_todo.yml
+
+# The behavior of RuboCop can be controlled via the .rubocop.yml
+# configuration file. It makes it possible to enable/disable
+# certain cops (checks) and to alter their behavior if they accept
+# any parameters. The file can be placed either in your home
+# directory or in some project directory.
+#
+# RuboCop will start looking for the configuration file in the directory
+# where the inspected file is and continue its way up to the root directory.
+#
+# See https://docs.rubocop.org/rubocop/configuration

data/.rubocop_todo.yml

@@ -0,0 +1,20 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2022-01-11 17:25:54 UTC using RuboCop version 1.24.1.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 1
+# Configuration parameters: Include.
+# Include: **/*.gemspec
+Gemspec/RequiredRubyVersion:
+  Exclude:
+    - 'inline_encryption.gemspec'
+
+# Offense count: 4
+# Configuration parameters: CountComments, CountAsOne, ExcludedMethods, IgnoredMethods.
+# IgnoredMethods: refine
+Metrics/BlockLength:
+  Max: 63

data/.tool-versions

@@ -0,0 +1,2 @@
+ruby 2.7.4
+pre-commit 2.15.0

data/.travis.yml

@@ -1,8 +1,8 @@
 language: ruby
 rvm:
-  - '2.2.10'
   - '2.3.8'
   - '2.4.4'
   - '2.5.3'
+  - '2.7.4'
 script: bundle exec rspec spec
 bundler_args: --without development debugger

data/Gemfile

@@ -1,20 +1,23 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 gemspec
 
-gem 'bundler', '~> 1.7'
+gem 'bundler', '>= 2.2.33'
 gem 'hashie'
 gem 'i18n'
 gem 'thor'
 
 group :debugger do
-  gem 'byebug'
+  gem 'byebug', '~> 11'
 end
 
 group :development do
   gem 'guard'
   gem 'guard-rspec'
-end 
+  gem 'rubocop'
+end
 
 group :development, :test do
   gem 'rake'
@@ -23,4 +26,3 @@ group :development, :test do
   gem 'simplecov', require: false
   gem 'yard'
 end
-

data/Guardfile

@@ -1,10 +1,11 @@
+# frozen_string_literal: true
+
 # A sample Guardfile
 # More info at https://github.com/guard/guard#readme
 
 guard 'rspec', all_after_pass: true, failed_mode: :focus, all_on_start: true, cmd: 'rspec' do
   watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$}){ |m| "spec/lib/#{m[1]}_spec.rb" }
-  watch('spec/spec_helper.rb'){ "spec" }
-  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
+  watch(%r{^lib/(.+)\.rb$}) { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb') { 'spec' }
+  watch(%r{^spec/support/(.+)\.rb$}) { 'spec' }
 end
-

data/Rakefile

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

data/bin/inline_encryption

@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
+
 # -*- mode: ruby -*-
 require 'bundler'
 Bundler.setup

data/inline_encryption.gemspec

@@ -1,5 +1,7 @@
-# -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+require 'English'
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'inline_encryption/version'
 
@@ -8,22 +10,19 @@ Gem::Specification.new do |spec|
   spec.version       = InlineEncryption::VERSION
   spec.authors       = ['rubyisbeautiful']
   spec.email         = 'bcptaylor+github@gmail.com'
-  spec.description   = %q{ A simple encryption tool based on common convention }
-  spec.summary       = %q{ A simple encryption tool based on common convention and designed as a drop in for Stringish things }
-  spec.homepage      = 'http://github.com/rubyisbeautiful/inline_encryption'
+  spec.description   = ' A simple encryption tool based on common convention '
+  spec.summary       = ' A drop-in simple encryption tool for stringish things '
+  spec.homepage      = 'https://github.com/rubyisbeautiful/inline_encryption'
   spec.license       = 'MIT'
 
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
   spec.required_ruby_version = '>= 2.1.5'
 
-  spec.executables   = ['inline_encryption']
+  spec.executables = ['inline_encryption']
 
   spec.add_runtime_dependency 'hashie'
   spec.add_runtime_dependency 'i18n'
   spec.add_runtime_dependency 'thor'
-
-
 end

data/lib/inline_encryption/base.rb

@@ -1,10 +1,10 @@
+# frozen_string_literal: true
+
 require 'base64'
 
 module InlineEncryption
-
+  # Base module including core functionality
   module Base
-
-
     # @param [String] data encryption target
     # @return [String] encrypted target
     # @raise [EncryptionFailureError] couldn't encrypt the target
@@ -13,63 +13,57 @@ module InlineEncryption
 
       begin
         encrypted = config.real_key.public_encrypt(data)
-        converted = Base64.encode64(encrypted)
-      rescue => e
+        Base64.encode64(encrypted)
+      rescue StandardError
         err = EncryptionFailureError.exception I18n.t('target', data: data)
         raise err
       end
     end
 
-
     # @param [String] data encryption target
     # @return [String] encrypted target, or fail_text on error (default data)
-    def encrypt(data, fail_text=nil)
+    def encrypt(data, fail_text = nil)
       config.check_required_variables
 
       begin
         encrypt!(data)
-      rescue EncryptionFailureError => e
-        return fail_text.nil? ? data : fail_text.to_s
+      rescue EncryptionFailureError
+        fail_text.nil? ? data : fail_text.to_s
       end
     end
 
-
     # @param [String] data decryption target
     # @return [String] decrypted target
     # @raise [DecryptionFailureError] couldn't decrypt the target
     def decrypt!(data)
       config.check_required_variables
-      raise MisconfigurationError.new(I18n.t('error.pub_key_decrypt')) unless config.real_key.private?
+      raise MisconfigurationError, I18n.t('error.pub_key_decrypt') unless config.real_key.private?
 
       begin
         converted = Base64.decode64(data)
-        decrypted = config.real_key.private_decrypt(converted)
-      rescue => e
-        err = DecryptionFailureError.exception I18n.t('encrypted', data)
+        config.real_key.private_decrypt(converted)
+      rescue StandardError
+        err = DecryptionFailureError.exception I18n.t('encrypted', data: data)
         raise err
       end
     end
 
-
     # @param [String] data decryption target
     # @param [String] fail_text text to be returned in the case of a decryption failure
     # @return [String] decrypted target
-    def decrypt(data, fail_text=nil)
+    def decrypt(data, fail_text = nil)
       config.check_required_variables
 
       begin
         decrypt!(data)
-      rescue DecryptionFailureError => e
-        return fail_text.nil? ? data : fail_text.to_s
+      rescue DecryptionFailureError
+        fail_text.nil? ? data : fail_text.to_s
       end
     end
 
-
     # @return [InlineEncryption::Config] the configuration instance
     def config
       @config ||= Config.new
     end
-
   end
-
-end
+end

data/lib/inline_encryption/cli.rb

@@ -1,31 +1,26 @@
+# frozen_string_literal: true
+
 require 'thor'
 
 module InlineEncryption
-
+  # CLI class for using on commandline
   class CLI < Thor
-
-    def initialize(args=[], opts=[], config={})
+    def initialize(args = [], opts = [], config = {})
       super(args, opts, config)
     end
 
-
     desc 'encrypt [DATA]', 'encrypt stuff'
-    class_option :require, :aliases => ['-r'], :type => :string
+    class_option :require, aliases: ['-r'], type: :string
     def encrypt(data)
       load_environment(options[:require]) if options[:require]
 
       puts InlineEncryption.encrypt(data)
     end
 
-
-
     protected
 
-
     def load_environment(file)
       require File.expand_path(file)
     end
-
   end
-
-end
+end

data/lib/inline_encryption/config.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require 'hashie/extensions/ruby_version_check'
 require 'hashie/extensions/indifferent_access'
 require 'hashie/extensions/method_access'
 require 'hashie/extensions/dash/indifferent_access'
@@ -5,7 +8,6 @@ require 'hashie/dash'
 require 'openssl'
 
 module InlineEncryption
-
   # known configuration variables
   # key - a String containing the private key, a filename pointing to the private key, or an OpenSSL::PKey::RSA
   class Config < Hash
@@ -15,26 +17,30 @@ module InlineEncryption
     # checks required, currently only the 'key'
     # @raises [InlineEncryption::MissingRequiredVariableError] raise on a missing variable
     def check_required_variables
-      raise MissingRequiredVariableError.new(I18n.t('error.missing_key')) unless self.has_key?(:key)
+      raise MissingRequiredVariableError, I18n.t('error.missing_key') unless key?(:key)
     end
 
-
     # @return [OpenSSL::PKey::RSA] the OpenSSL key instance
     def real_key
       case self[:key]
-        when NilClass
-          nil
-        when String
-          if File.exists?(self[:key])
-            OpenSSL::PKey::RSA.new(File.read(self[:key]))
-          else
-            OpenSSL::PKey::RSA.new(self[:key])
-          end
-        when OpenSSL::PKey::RSA
-          self[:key]
+      when NilClass
+        nil
+      when String
+        load_or_use_key(self[:key])
+      when OpenSSL::PKey::RSA
+        self[:key]
       end
     end
-  end
 
+    private
 
-end
+    # @return OpenSSL::PKey::RSA
+    def load_or_use_key(str)
+      if File.exist?(str)
+        OpenSSL::PKey::RSA.new(File.read(str))
+      else
+        OpenSSL::PKey::RSA.new(str)
+      end
+    end
+  end
+end

data/lib/inline_encryption/errors.rb

@@ -1,8 +1,8 @@
-module InlineEncryption
+# frozen_string_literal: true
 
+module InlineEncryption
   class MissingRequiredVariableError < StandardError; end
   class DecryptionFailureError < StandardError; end
   class EncryptionFailureError < StandardError; end
   class MisconfigurationError < StandardError; end
-
-end
+end

data/lib/inline_encryption/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module InlineEncryption
-  VERSION = '2.0.1'
+  VERSION = '2.1.0'
 end

data/lib/inline_encryption.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'i18n'
 require 'base64'
 require 'inline_encryption/version'
@@ -5,6 +7,7 @@ require 'inline_encryption/config'
 require 'inline_encryption/base'
 require 'inline_encryption/errors'
 
+# top level module InlineEncryption
 module InlineEncryption
   extend InlineEncryption::Base
 
@@ -14,6 +17,4 @@ module InlineEncryption
     I18n.enforce_available_locales = false
     @_i18n_initialized_for_ie = true
   end
-
-
 end

data/spec/inline_encryption/base_spec.rb

@@ -1,15 +1,15 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'base64'
 
 describe InlineEncryption::Base do
-
   before :all do
     @default_key = OpenSSL::PKey::RSA.generate(2048)
   end
 
   describe 'encrypt' do
-
-    let(:str){ 'foo' }
+    let(:str) { 'foo' }
 
     before :each do
       InlineEncryption.config[:key] = @default_key
@@ -20,19 +20,18 @@ describe InlineEncryption::Base do
     end
 
     it 'should fail to encrpyt and return the target' do
-      InlineEncryption.config[:key] = OpenSSL::PKey::RSA.generate(32)
-      expect(InlineEncryption.encrypt(str*2)).to eq(str*2)
+      InlineEncryption.config[:key] = OpenSSL::PKey::RSA.generate(2048)
+      expect(InlineEncryption.encrypt(nil)).to eq(nil)
     end
 
     it 'should fail to encrypt and return the fail_text' do
-      InlineEncryption.config[:key] = OpenSSL::PKey::RSA.generate(32)
-      expect(InlineEncryption.encrypt(str*2, 'chunky')).to eq('chunky')
+      InlineEncryption.config[:key] = OpenSSL::PKey::RSA.generate(2048)
+      expect(InlineEncryption.encrypt(nil, 'chunky')).to eq('chunky')
     end
-
   end
 
   describe 'encrypt!' do
-    let(:str){ 'foo' }
+    let(:str) { 'foo' }
 
     before :each do
       InlineEncryption.config[:key] = @default_key
@@ -43,57 +42,46 @@ describe InlineEncryption::Base do
     end
 
     it 'should fail to encrpyt and raise' do
-      InlineEncryption.config[:key] = OpenSSL::PKey::RSA.generate(32)
-      expect{ InlineEncryption.encrypt!(str*2) }.to raise_error(InlineEncryption::EncryptionFailureError)
+      InlineEncryption.config[:key] = OpenSSL::PKey::RSA.generate(2048)
+      expect { InlineEncryption.encrypt!(nil) }.to raise_error(InlineEncryption::EncryptionFailureError)
     end
-
   end
 
   describe 'decrypt' do
-
-    before :all do
-      @str = Base64.encode64(@default_key.public_encrypt('chunky'))
-    end
+    let(:str) { Base64.encode64(@default_key.public_encrypt('chunky')) }
 
     it 'should decrypt' do
       InlineEncryption.config[:key] = @default_key
-      expect(InlineEncryption.decrypt(@str)).to eq('chunky')
+      expect(InlineEncryption.decrypt(str)).to eq('chunky')
     end
 
     it 'should fail to decrypt and return the target' do
-      InlineEncryption.config[:key] = OpenSSL::PKey::RSA.generate(32)
-      expect(InlineEncryption.decrypt(@str)).to eq(@str)
+      InlineEncryption.config[:key] = OpenSSL::PKey::RSA.generate(2048)
+      expect(InlineEncryption.decrypt(str)).to eq(str)
     end
 
     it 'should fail to decrypt and return the fail_text' do
-      InlineEncryption.config[:key] = OpenSSL::PKey::RSA.generate(32)
-      expect(InlineEncryption.decrypt(@str, 'chunky')).to eq('chunky')
+      InlineEncryption.config[:key] = OpenSSL::PKey::RSA.generate(2048)
+      expect(InlineEncryption.decrypt(str, 'chunky')).to eq('chunky')
     end
 
     it 'should fail to decrpyt and raise if using a public key to decrypt' do
       InlineEncryption.config[:key] = @default_key.public_key
-      expect{ InlineEncryption.decrypt('whatevs') }.to raise_error(InlineEncryption::MisconfigurationError)
+      expect { InlineEncryption.decrypt('whatevs') }.to raise_error(InlineEncryption::MisconfigurationError)
     end
-
   end
 
   describe 'decrypt!' do
-
-    before :all do
-      @str = Base64.encode64(@default_key.public_encrypt('chunky'))
-    end
+    let(:str) { Base64.encode64(@default_key.public_encrypt('chunky')) }
 
     it 'should decrypt' do
       InlineEncryption.config[:key] = @default_key
-      expect(InlineEncryption.decrypt!(@str)).to eq('chunky')
+      expect(InlineEncryption.decrypt!(str)).to eq('chunky')
     end
 
     it 'should fail to decrpyt and raise' do
-      InlineEncryption.config[:key] = OpenSSL::PKey::RSA.generate(32)
-      expect{ InlineEncryption.decrypt!(@str) }.to raise_error(InlineEncryption::DecryptionFailureError)
+      InlineEncryption.config[:key] = OpenSSL::PKey::RSA.generate(2048)
+      expect { InlineEncryption.decrypt!(str) }.to raise_error(InlineEncryption::DecryptionFailureError)
     end
-
   end
-
 end
-

data/spec/inline_encryption/cli_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'base64'
 require 'inline_encryption/cli'
@@ -7,10 +9,8 @@ def tmp_filename
 end
 
 describe InlineEncryption::CLI do
-
   describe 'initialize' do
-
-    let(:subject){ InlineEncryption::CLI.new }
+    let(:subject) { InlineEncryption::CLI.new }
 
     before :all do
       @default_key = OpenSSL::PKey::RSA.generate(2048)
@@ -24,18 +24,15 @@ describe InlineEncryption::CLI do
     end
 
     it 'should require a file if passed' do
-      subject = InlineEncryption::CLI.new(['foo'], [ '-r', 'foo.rb' ], {})
+      subject = InlineEncryption::CLI.new(['foo'], ['-r', 'foo.rb'], {})
 
       expect(subject).to receive(:load_environment).with('foo.rb')
 
       subject.encrypt('foo')
     end
-
   end
 
-
   describe 'load_environment' do
-
     before :each do
       FileUtils.mkdir_p File.dirname(tmp_filename)
       File.open(tmp_filename, 'w') do |file|
@@ -49,9 +46,7 @@ describe InlineEncryption::CLI do
 
     it 'should require the file' do
       subject.send(:load_environment, tmp_filename)
-      expect{ FooForInlineEncryptionSpec }.not_to raise_error
+      expect { FooForInlineEncryptionSpec }.not_to raise_error
     end
-
   end
-
 end

data/spec/inline_encryption/config_spec.rb

@@ -1,24 +1,23 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe InlineEncryption::Config do
-
   describe 'check_required_values' do
-    let(:subject){ InlineEncryption::Config.new }
+    let(:subject) { InlineEncryption::Config.new }
 
     it "should raise if 'key' is not set" do
-      expect{ subject.check_required_variables }.to raise_error(InlineEncryption::MissingRequiredVariableError)
+      expect { subject.check_required_variables }.to raise_error(InlineEncryption::MissingRequiredVariableError)
     end
 
     it "should not raise if 'key' is set" do
       subject[:key] = 'foo'
-      expect{ subject.check_required_variables }.not_to raise_error
+      expect { subject.check_required_variables }.not_to raise_error
     end
-
   end
 
-
   describe 'real_key' do
-    let(:subject){ InlineEncryption::Config.new }
+    let(:subject) { InlineEncryption::Config.new }
 
     it 'should return nil if key is NilClass' do
       subject[:key] = nil
@@ -27,14 +26,14 @@ describe InlineEncryption::Config do
     end
 
     it 'should return the key value if key is an OpenSSL::PKey::RSA key' do
-      key = OpenSSL::PKey::RSA.new(128)
+      key = OpenSSL::PKey::RSA.new(512)
       subject[:key] = key
 
       expect(subject.real_key).to eq(key)
     end
 
     it 'should return an OpenSSL::PKey::RSA key from the given String' do
-      temp_key = OpenSSL::PKey::RSA.generate(32)
+      temp_key = OpenSSL::PKey::RSA.generate(512)
       key = temp_key.to_s
       subject[:key] = key
 
@@ -43,16 +42,14 @@ describe InlineEncryption::Config do
     end
 
     it 'should load the contents of the given file if exists and use as key' do
-      temp_key = OpenSSL::PKey::RSA.generate(32)
+      temp_key = OpenSSL::PKey::RSA.generate(512)
       key = 'foo'
       subject[:key] = key
-      allow(File).to receive(:exists?).with('foo').and_return(true)
+      allow(File).to receive(:exist?).with('foo').and_return(true)
       allow(File).to receive(:read).with('foo').and_return(temp_key.to_s)
 
       expect(subject.real_key.to_s).to eq(temp_key.to_s)
       expect(subject.real_key).to be_an_instance_of OpenSSL::PKey::RSA
     end
   end
-
-
-end
+end

data/spec/inline_encryption_spec.rb

@@ -1,13 +1,13 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe InlineEncryption do
-
   it 'should load Base' do
-    expect{ InlineEncryption::Base }.not_to raise_error
+    expect { InlineEncryption::Base }.not_to raise_error
   end
 
   it 'should be extended by Base' do
     expect(InlineEncryption.respond_to?(:config)).to be_truthy
   end
-
 end