sym 2.2.1 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dba3a8013e135db50a8294dd619302d1c10b8109
-  data.tar.gz: 28cc2c0edbff0ecec89e265109c11e3c9c67da01
+  metadata.gz: ba48a5359afbfb7ab1dd26e998a8534d6b5a1cd1
+  data.tar.gz: 4441338abdc75c4cc94ce8bf62e0cfa124c22290
 SHA512:
-  metadata.gz: f78ca029db09962c423fb57e38c86e03b8417977714c6e087a80b31f0b9f6392ec7c6f2f8ebd1c41d9b7d75c82e0755f4ac37fd68393090c2a2eb17a81909d25
-  data.tar.gz: 1d6c15f15761ceb1187e45455408a27b371a15a798d139a840614427fd52ac0a4574c5475d83a7d483e2b3f4d6e4c321cdc5beddbd89d6e943066f9972d9c984
+  metadata.gz: a58d04eee85fe8f9d888c432bd1a076437073448420d1ab83d2439a96f54665f33538cb7212ea9f287af646e369e767c89192af5c46140ce45e85bf9c455784a
+  data.tar.gz: 1796761a05b5c3eaa614999bca47bde80ba0967a2c6471d38b349171c49ed601888fcafc028aeedd46df90252063587ef1ab385b026cd4dcbdbedb553a50b5f5

data/.document

@@ -1,2 +1,2 @@
-lib/ exe/ - README.md MANAGING-KEYS.md LICENSE 
+lib/ exe/ - README.md LICENSE sym-3.0-cli.md
 

data/.yardopts

@@ -1,4 +1,3 @@
-
 --protected
 --no-private
 --embed-mixin ClassMethods

data/README.md

@@ -1,5 +1,7 @@
 # Sym — Light Weight Symmetric Encryption for Humans
 
+<hr/>
+[![Gitter](https://img.shields.io/gitter/room/gitterHQ/gitter.svg)](https://gitter.im/kigster/sym)
 [![Gem Version](https://badge.fury.io/rb/sym.svg)](https://badge.fury.io/rb/sym)
 [![Downloads](http://ruby-gem-downloads-badge.herokuapp.com/sym?type=total)](https://rubygems.org/gems/sym)
 [![Documentation](http://inch-ci.org/github/kigster/sym.png)](http://inch-ci.org/github/kigster/sym)
@@ -9,6 +11,8 @@
 [![Test Coverage](https://codeclimate.com/github/kigster/sym/badges/coverage.svg)](https://codeclimate.com/github/kigster/sym/coverage)
 [![Issue Count](https://codeclimate.com/github/kigster/sym/badges/issue_count.svg)](https://codeclimate.com/github/kigster/sym)
 
+<hr/>
+
 ## Description
 
 > __sym__ is a command line utility and a Ruby API that makes it _trivial to encrypt and decrypt sensitive data_. Unlike many other existing encryption tools, __sym__ focuses on usability and streamlined interface (CLI), with the goal of making encryption easy and transparent. The result? There is no excuse for keeping your application secrets unencrypted :) 

data/Rakefile

@@ -2,13 +2,26 @@ require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 require 'yard'
 
+def shell(*args)
+  puts "running: #{args.join(' ')}"
+  system(args.join(' '))
+end
+
+task :permissions do 
+  shell("find . -type f -exec chmod o+r,g+r {} \\;")
+  shell("find . -type d -exec chmod o+rx,g+rx {} \\;")
+end
+
+task :build => :permissions
 
 YARD::Rake::YardocTask.new(:doc) do |t|
-  t.files = %w(lib/**/*.rb exe/*.rb - README.md MANAGING-KEYS.md LICENSE)
-  t.options.unshift('--title', '"Sym – Symmetric Key Encryption for Your Data"')
+  t.files = %w(lib/**/*.rb exe/*.rb - README.md LICENSE sym-3.0-cli.md)
+  t.options.unshift('--title','"Sym – Symmetric Key Encryption for Your Data"')
   t.after = ->() { exec('open doc/index.html') }
 end
 
 RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
+
+

data/lib/sym.rb

@@ -32,7 +32,9 @@ Sym::Configuration.configure do |config|
   }
 end
 
-
+require 'sym/extensions/stdlib'
+require 'sym/extensions/class_methods'
+require 'sym/extensions/instance_methods'
 #
 # == Using Sym Library
 #
@@ -94,22 +96,6 @@ end
 # Each class including the +Sym+ module would get their own +#private_key#
 # class-instance variable accessor, and a possible value.
 #
-# For example:
-#
-#
-
-module Kernel
-  def require_dir(___dir)
-    @___dir ||= File.dirname(__FILE__)
-    # require files using a consistent order based on the dir/file name.
-    # this should be OS-neutral
-    Dir["#{@___dir}/#{___dir}/*.rb"].sort.each do |___file|
-      require(___file)
-    end
-  end
-end
-
-require_dir 'sym/extensions'
 
 module Sym
   def self.included(klass)
@@ -133,7 +119,8 @@ module Sym
 
   COMPLETION_FILE        = '.sym.completion'.freeze
   COMPLETION_PATH        = "#{ENV['HOME']}/#{COMPLETION_FILE}".freeze
-  LOGGER                 = Logger.new(nil).freeze # empty logger
+  NIL_LOGGER             = Logger.new(nil).freeze # empty logger
+  LOGGER                 = Logger.new(STDOUT).freeze
   ENV_ARGS_VARIABLE_NAME = 'SYM_ARGS'.freeze
 
   BASH_COMPLETION        = {

data/lib/sym/app.rb

@@ -1,6 +1,6 @@
 require 'sym'
 require 'active_support/inflector'
-
+require 'colored2'
 module Sym
 
   # The {Sym::App} Module is responsible for handing user input and executing commands.
@@ -25,26 +25,45 @@ module Sym
       STDERR
     end
 
-    def self.error(
-      config: {},
+    def self.log(level, *args, **opts)
+      Sym::LOGGER.send(level, *args) if opts[:debug]
+    end
+
+    def self.error(config: {},
       exception: nil,
       type: nil,
       details: nil,
       reason: nil,
-      comments: nil)
-
-      self.out.puts([\
-                    "#{(type || exception.class.name).titleize}:".red.bold.underlined +
-                    (sprintf '  %s', details || exception.message).red.italic,
-                    (reason ? "\n#{reason.blue.bold.italic}" : nil),
-                    (comments ? "\n\n#{comments}" : nil)].compact.join("\n"))
-      self.out.puts "\n" + exception.backtrace.join("\n").bold.red if exception && config && config[:trace]
+      comments: nil,
+      command: nil)
+
+      lines = []
+
+      error_type    = "#{(type || exception.class.name)}"
+      error_details = (details || exception.message)
+
+      if exception && (config && config[:trace] || reason == 'Unknown Error')
+        lines << "#{error_type.red.underlined}: #{error_details.white.on.red}\n"
+        lines << exception.backtrace.join("\n").red.bold if config[:trace]
+        lines << "\n"
+      end
+
+      operation = command ? "to #{command.class.short_name.to_s.humanize.downcase}" : ''
+      reason    = exception.message if reason.nil? && exception
+
+      lines << " error #{operation} → ".white.on.red+ " #{reason}".bold.red if reason
+      lines << "#{comments}" if comments
+
+      error_report = lines.compact.join("\n") || 'Undefined error'
+
+      self.out.puts(error_report) if error_report.present?
       self.exit_code = 1
     end
 
     def self.is_osx?
       Gem::Platform.local.os.eql?('darwin')
     end
+
     def self.this_os
       Gem::Platform.local.os
     end

data/lib/sym/app/cli.rb

@@ -2,19 +2,20 @@ require 'slop'
 require 'sym'
 require 'colored2'
 require 'yaml'
-require 'forwardable'
 require 'openssl'
+require 'highline'
+
 require 'sym/application'
 require 'sym/errors'
+
 require 'sym/app/commands'
 require 'sym/app/keychain'
 require 'sym/app/private_key/handler'
-require 'highline'
 
-require_relative 'output/file'
-require_relative 'output/file'
-require_relative 'output/stdout'
-require_relative 'cli_slop'
+require 'sym/app/output/base'
+require 'sym/app/output/file'
+require 'sym/app/output/stdout'
+require 'sym/app/cli_slop'
 
 module Sym
   module App
@@ -55,9 +56,6 @@ module Sym
       # brings in #parse(Array[String] args)
       include CLISlop
 
-      extend Forwardable
-      def_delegators :@application, :command
-
       attr_accessor :opts, :application, :outputs, :output_proc
 
       def initialize(argv_original)
@@ -75,23 +73,26 @@ module Sym
         end
 
         command_no_color(argv_original) if opts[:no_color]
-
         self.application = ::Sym::Application.new(opts)
-
         select_output_stream
       end
 
 
       def execute
         return Sym::App.exit_code if Sym::App.exit_code != 0
-
         result = application.execute
-        if result.is_a?(Hash)
-          self.output_proc = ::Sym::App::Args.new({}).output_class
-          error(result)
-        else
-          self.output_proc.call(result)
+        case result
+          when Hash
+            self.output_proc = ::Sym::App::Args.new({}).output_class
+            error(result)
+          else
+            self.output_proc.call(result)
         end
+        Sym::App.exit_code
+      end
+
+      def command
+        @command ||= self.application&.command
       end
 
       private
@@ -103,7 +104,9 @@ module Sym
       end
 
       def error(hash)
-        Sym::App.error(hash.merge(config: (opts ? opts.to_hash : {})))
+        hash.merge!(config: opts.to_hash) if opts
+        hash.merge!(command: @command) if @command
+        Sym::App.error(**hash)
       end
 
       def select_output_stream

data/lib/sym/app/commands.rb

@@ -54,7 +54,8 @@ end
 
 require 'sym/app/commands/base_command'
 require 'sym/app/commands/bash_completion'
-require 'sym/app/commands/encrypt_decrypt'
+require 'sym/app/commands/encrypt'
+require 'sym/app/commands/decrypt'
 require 'sym/app/commands/generate_key'
 require 'sym/app/commands/keychain_add_key'
 require 'sym/app/commands/open_editor'

data/lib/sym/app/commands/base_command.rb

@@ -69,6 +69,10 @@ module Sym
           raise Sym::Errors::AbstractMethodCalled.new(:run)
         end
 
+        def content
+          @content ||= (opts[:string] || (opts[:file].eql?('-') ? STDIN.read : File.read(opts[:file])))
+        end
+
         def to_s
           "#{self.class.short_name.to_s.bold.yellow}, with options: #{application.args.argv.join(' ').gsub(/--/, '').bold.green}"
         end

data/lib/sym/app/commands/bash_completion.rb

@@ -5,7 +5,7 @@ module Sym
       class BashCompletion < BaseCommand
 
         required_options [:bash_completion]
-        try_after :generate_key, :open_editor, :encrypt_decrypt
+        try_after :generate_key, :open_editor, :encrypt, :decrypt
 
         def execute
           install_completion_file

data/lib/sym/app/commands/{encrypt_decrypt.rb → decrypt.rb}

@@ -2,11 +2,11 @@ require 'sym/app/commands/base_command'
 module Sym
   module App
     module Commands
-      class EncryptDecrypt < BaseCommand
+      class Decrypt < BaseCommand
         include Sym
 
         required_options [ :private_key, :keyfile, :keychain, :interactive ],
-                         [ :encrypt, :decrypt ],
+                         [ :decrypt ],
                          [ :file, :string ]
 
         try_after :generate_key
@@ -14,12 +14,6 @@ module Sym
         def execute
           send(application.action, content, application.key)
         end
-
-        private
-
-        def content
-          @content ||= (opts[:string] || (opts[:file].eql?('-') ? STDIN.read : File.read(opts[:file])))
-        end
       end
     end
   end

data/lib/sym/app/commands/encrypt.rb

@@ -0,0 +1,20 @@
+require 'sym/app/commands/base_command'
+module Sym
+  module App
+    module Commands
+      class Encrypt < BaseCommand
+        include Sym
+
+        required_options [ :private_key, :keyfile, :keychain, :interactive ],
+                         [ :encrypt ],
+                         [ :file, :string ]
+
+        try_after :generate_key
+
+        def execute
+          send(application.action, content, application.key)
+        end
+      end
+    end
+  end
+end

data/lib/sym/app/commands/generate_key.rb

@@ -7,6 +7,8 @@ module Sym
 
         required_options :generate
 
+        try_after :show_help
+
         def execute
           retries ||= 0
 

data/lib/sym/app/commands/keychain_add_key.rb

@@ -8,7 +8,7 @@ module Sym
         required_options [:private_key, :keyfile, :interactive],
                          :keychain
 
-        try_after :generate_key, :encrypt_decrypt, :password_protect_key
+        try_after :generate_key, :encrypt, :decrypt, :password_protect_key
 
         def execute
           add_to_keychain_if_needed(self.key)

data/lib/sym/app/commands/open_editor.rb

@@ -14,7 +14,7 @@ module Sym
                            :edit,
                            :file
 
-        try_after :generate_key, :encrypt_decrypt
+        try_after :generate_key, :encrypt, :decrypt
 
         attr_accessor :tempfile
 

data/lib/sym/app/commands/password_protect_key.rb

@@ -8,7 +8,7 @@ module Sym
         required_options [:private_key, :keyfile, :keychain, :interactive],
                          :password
 
-        try_after :generate_key, :encrypt_decrypt
+        try_after :generate_key, :encrypt, :decrypt
 
         def execute
           retries ||= 0

data/lib/sym/app/commands/print_key.rb

@@ -6,7 +6,7 @@ module Sym
       class PrintKey < BaseCommand
         required_options [ :keychain, :keyfile ]
 
-        try_after :generate_key, :encrypt_decrypt, :password_protect_key, :keychain_add_key
+        try_after :generate_key, :encrypt, :decrypt, :password_protect_key, :keychain_add_key
 
         def execute
           self.key

data/lib/sym/app/password/cache.rb

@@ -36,7 +36,7 @@ module Sym
           self.enabled = opts[:enabled]
           self.verbose = opts[:verbose]
           self.timeout = opts[:timeout] || ::Sym::Configuration.config.password_cache_timeout
-          self.provider = Providers.provider(opts[:provider])
+          self.provider = Providers.provider(opts[:provider], opts[:provider_opts] || {})
           self.enabled = false unless self.provider
           self
         end

data/lib/sym/app/password/providers.rb

@@ -22,8 +22,8 @@ module Sym
             end
           end
 
-          def provider(p = nil)
-            provider_from_argument(p) || detect
+          def provider(p = nil, **opts, &block)
+            provider_from_argument(p, **opts, &block) || detect
           end
 
           private
@@ -32,12 +32,12 @@ module Sym
             klass.name.gsub(/.*::(\w+)Provider/, '\1').downcase.to_sym
           end
 
-          def provider_from_argument(p)
+          def provider_from_argument(p, **opts, &block)
             case p
               when String, Symbol
                 provider_class_name = "#{p.to_s.capitalize}Provider"
                 Sym::App::Password::Providers.const_defined?(provider_class_name) ?
-                  Sym::App::Password::Providers.const_get(provider_class_name).new :
+                  Sym::App::Password::Providers.const_get(provider_class_name).new(**opts, &block) :
                   nil
             end
           end

data/lib/sym/app/password/providers/drb_provider.rb

@@ -9,9 +9,11 @@ module Sym
 
           attr_accessor :coin
 
-          def initialize
-            Coin.uri  = Sym::Configuration.config.password_cache_arguments[:drb][:opts][:uri]
+          def initialize(**opts)
+            Coin.uri  = opts[:uri] || Sym::Configuration.config.password_cache_arguments[:drb][:opts][:uri]
             self.coin = Coin
+            alive?
+            self
           end
 
           def alive?
@@ -26,6 +28,10 @@ module Sym
           def read(*args)
             coin.send(:read, *args)
           end
+
+          def clear
+            coin.clear
+          end
         end
 
         register DrbProvider

data/lib/sym/app/password/providers/memcached_provider.rb

@@ -9,12 +9,12 @@ module Sym
         class MemcachedProvider
           attr_accessor :dalli
 
-          def initialize
+          def initialize(**opts)
             # disable logging
-            Dalli.logger = Sym::LOGGER
+            Dalli.logger = Sym::NIL_LOGGER
             self.dalli = ::Dalli::Client.new(
               * Sym::Configuration.config.password_cache_arguments[:memcached][:args],
-              ** Sym::Configuration.config.password_cache_arguments[:memcached][:opts]
+              ** Sym::Configuration.config.password_cache_arguments[:memcached][:opts].merge!(opts)
             )
           end
 
@@ -33,6 +33,10 @@ module Sym
             dalli.set(key, value)
           end
 
+          def clear
+            dalli.flush
+          end
+
         end
 
         register MemcachedProvider

data/lib/sym/app/private_key/decryptor.rb

@@ -33,7 +33,7 @@ module Sym
               if ((retries += 1) < 3)
                 retry
               else
-                raise(Sym::Errors::InvalidPasswordPrivateKey.new('Invalid password.'))
+                raise(Sym::Errors::InvalidPasswordProvidedForThePrivateKey.new('Invalid password.'))
               end
             end
           else

data/lib/sym/application.rb

@@ -1,6 +1,7 @@
 require 'colored2'
 require 'sym'
 require 'sym/app'
+require 'openssl'
 
 module Sym
   class Application
@@ -35,33 +36,46 @@ module Sym
     end
 
     def execute!
-      if !args.generate_key? &&
-        (args.require_key? || args.specify_key?)
+      if !args.generate_key? && (args.require_key? || args.specify_key?)
+        log :debug, 'operation requires a key...'
         self.key = Sym::App::PrivateKey::Handler.new(opts, input_handler, password_cache).key
-        raise Sym::Errors::NoPrivateKeyFound.new('Private key is required') unless self.key
+        unless self.key
+          log :error, 'Unable to determine the key, which appears to be required'
+          raise Sym::Errors::NoPrivateKeyFound, 'Private key is required'
+        end
       end
+      log :info, "detected command [#{command.class.name}]"
       unless command
-        raise Sym::Errors::InsufficientOptionsError.new(
-          'Can not determine what to do from the options ' + opts_hash.keys.reject { |k| !opts[k] }.to_s)
+        raise Sym::Errors::InsufficientOptionsError, 'Can not determine what to do from the options ' + opts_hash.keys.reject { |k| !opts[k] }.to_s
       end
       self.result = command.execute
     end
 
+    def log(*args)
+      Sym::App.log(*args, **opts)
+    end
+
     def execute
       execute!
 
     rescue ::OpenSSL::Cipher::CipherError => e
-      error type:      'Cipher Error',
-            details:   e.message,
-            reason:    'Perhaps either the secret is invalid, or encrypted data is corrupt.',
-            exception: e
+      { reason:    'Invalid key provided',
+        exception: e }
 
     rescue Sym::Errors::Error => e
-      error type:    e.class.name.split(/::/)[-1],
-            details: e.message
+      { reason:    e.class.name.gsub(/.*::/, '').underscore.humanize.downcase,
+        exception: e }
+
+    rescue TypeError => e
+      if e.message =~ /marshal/
+        { reason: 'Corrupt source data or invalid/corrupt key provided',
+          exception: e }
+      else
+        { exception: e }
+      end
 
     rescue StandardError => e
-      error exception: e
+      { exception: e }
     end
 
     def command
@@ -89,10 +103,6 @@ module Sym
       ]
     end
 
-    def error(hash)
-      hash
-    end
-
     def initialize_input_handler(handler = ::Sym::App::Input::Handler.new)
       self.input_handler = handler
     end

data/lib/sym/errors.rb

@@ -8,6 +8,7 @@ module Sym
     class InsufficientOptionsError < Sym::Errors::Error; end
 
     class PasswordError < Sym::Errors::Error; end
+    class NoPasswordProvided < Sym::Errors::PasswordError; end
     class PasswordsDontMatch < Sym::Errors::PasswordError; end
     class PasswordTooShort < Sym::Errors::PasswordError; end
 
@@ -19,9 +20,11 @@ module Sym
 
     class KeyError < Sym::Errors::Error; end
     class InvalidEncodingPrivateKey < Sym::Errors::KeyError; end
-    class InvalidPasswordPrivateKey < Sym::Errors::KeyError; end
+    class InvalidPasswordProvidedForThePrivateKey < Sym::Errors::KeyError; end
     class NoPrivateKeyFound < Sym::Errors::KeyError; end
 
+    class NoDataProvided < Sym::Errors::Error; end
+
     class KeyChainCommandError < Sym::Errors::Error; end
 
     # Method was called on an abstract class. Override such methods in

data/lib/sym/extensions/instance_methods.rb

@@ -25,31 +25,37 @@ module Sym
 
       # Expects key to be a base64 encoded key
       def encr(data, key, iv = nil)
-        raise Sym::Errors::NoPrivateKeyFound if key.nil?
-        _encr(data, encryption_config.data_cipher, iv) do |cipher_struct|
+        raise Sym::Errors::NoPrivateKeyFound unless key.present?
+        raise Sym::Errors::NoDataProvided unless data.present?
+        encrypt_data(data, encryption_config.data_cipher, iv) do |cipher_struct|
           cipher_struct.cipher.key = decode_key(key)
         end
       end
 
       # Expects key to be a base64 encoded key
       def decr(encrypted_data, key, iv = nil)
-        raise Sym::Errors::NoPrivateKeyFound if key.nil?
-        _decr(encrypted_data, encryption_config.data_cipher, iv) do |cipher_struct|
+        raise Sym::Errors::NoPrivateKeyFound unless key.present?
+        raise Sym::Errors::NoDataProvided unless encrypted_data.present?
+        decrypt_data(encrypted_data, encryption_config.data_cipher, iv) do |cipher_struct|
           cipher_struct.cipher.key = decode_key(key)
         end
       end
 
       def encr_password(data, password, iv = nil)
-        _encr(data, encryption_config.password_cipher, iv) do |cipher_struct|
-          key, salt                = _key_from_password(cipher_struct.cipher, password)
+        raise Sym::Errors::NoDataProvided unless data.present?
+        raise Sym::Errors::NoPasswordProvided unless password.present?
+        encrypt_data(data, encryption_config.password_cipher, iv) do |cipher_struct|
+          key, salt                = make_password_key(cipher_struct.cipher, password)
           cipher_struct.cipher.key = key
           cipher_struct.salt       = salt
         end
       end
 
       def decr_password(encrypted_data, password, iv = nil)
-        _decr(encrypted_data, encryption_config.password_cipher, iv) do |cipher_struct|
-          key,                     = _key_from_password(cipher_struct.cipher, password, cipher_struct.salt)
+        raise Sym::Errors::NoDataProvided unless encrypted_data.present?
+        raise Sym::Errors::NoPasswordProvided unless password.present?
+        decrypt_data(encrypted_data, encryption_config.password_cipher, iv) do |cipher_struct|
+          key,                     = make_password_key(cipher_struct.cipher, password, cipher_struct.salt)
           cipher_struct.cipher.key = key
         end
       end
@@ -62,7 +68,7 @@ module Sym
         encoded_key
       end
 
-      def _key_from_password(cipher, password, salt = nil)
+      def make_password_key(cipher, password, salt = nil)
         key_len = cipher.key_len
         salt    ||= OpenSSL::Random.random_bytes 16
         iter    = 20000
@@ -72,13 +78,13 @@ module Sym
       end
 
       # Expects key to be a base64 encoded key data
-      def _encr(data, cipher_name, iv = nil, &block)
+      def encrypt_data(data, cipher_name, iv = nil, &block)
         data, compression_enabled = encode_incoming_data(data)
         cipher_struct             = create_cipher(direction:   :encrypt,
                                                   cipher_name: cipher_name,
                                                   iv:          iv)
 
-        yield cipher_struct if block_given?
+        block.call(cipher_struct) if block
 
         encrypted_data = update_cipher(cipher_struct.cipher, data)
         wrapper_struct = WrapperStruct.new(
@@ -91,13 +97,13 @@ module Sym
       end
 
       # Expects key to be a base64 encoded key data
-      def _decr(encoded_data, cipher_name, iv = nil, &block)
+      def decrypt_data(encoded_data, cipher_name, iv = nil, &block)
         wrapper_struct = decode(encoded_data)
         cipher_struct  = create_cipher(cipher_name: cipher_name,
-                                       iv:          wrapper_struct.iv,
+                                       iv:          wrapper_struct.iv || iv,
                                        direction:   :decrypt,
                                        salt:        wrapper_struct.salt)
-        yield cipher_struct if block_given?
+        block.call(cipher_struct) if block
         decode(update_cipher(cipher_struct.cipher, wrapper_struct.encrypted_data))
       end
 

data/lib/sym/extensions/stdlib.rb

@@ -0,0 +1,23 @@
+
+module Kernel
+  def require_dir(___dir)
+    @___dir ||= File.dirname(__FILE__)
+    # require files using a consistent order based on the dir/file name.
+    # this should be OS-neutral
+    Dir["#{@___dir}/#{___dir}/*.rb"].sort.each do |___file|
+      require(___file)
+    end
+  end
+end
+
+class Object
+  unless self.methods.include?(:present?)
+    def present?
+      return false if self.nil?
+      if self.is_a?(String)
+        return false if self == ''
+      end
+      true
+    end
+  end
+end

data/lib/sym/version.rb

@@ -1,5 +1,5 @@
 module Sym
-  VERSION = '2.2.1'
+  VERSION = '2.3.0'
   DESCRIPTION = <<-eof
     Sym is a command line utility and a Ruby API that makes it trivial to encrypt and decrypt 
     sensitive data. Unlike many other existing encryption tools, sym focuses on usability and 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sym
 version: !ruby/object:Gem::Version
-  version: 2.2.1
+  version: 2.3.0
 platform: ruby
 authors:
 - Konstantin Gredeskoul
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-02-15 00:00:00.000000000 Z
+date: 2017-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colored2
@@ -249,7 +249,8 @@ files:
 - lib/sym/app/commands.rb
 - lib/sym/app/commands/base_command.rb
 - lib/sym/app/commands/bash_completion.rb
-- lib/sym/app/commands/encrypt_decrypt.rb
+- lib/sym/app/commands/decrypt.rb
+- lib/sym/app/commands/encrypt.rb
 - lib/sym/app/commands/generate_key.rb
 - lib/sym/app/commands/keychain_add_key.rb
 - lib/sym/app/commands/open_editor.rb
@@ -285,6 +286,7 @@ files:
 - lib/sym/errors.rb
 - lib/sym/extensions/class_methods.rb
 - lib/sym/extensions/instance_methods.rb
+- lib/sym/extensions/stdlib.rb
 - lib/sym/extensions/with_retry.rb
 - lib/sym/extensions/with_timeout.rb
 - lib/sym/version.rb