extras 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f103046f49374cf61bc34341760c19d4983be7a9
+  data.tar.gz: 16aca5fe7a55cc6ecbb4d3cd19f462e9f7753470
+SHA512:
+  metadata.gz: b58cb7195b2f4fada3e477b240467c190f7ae0815d52ef594ee827f428bcb39f458a3c7d44a9f5d8ae6797f6b58034948f126dd0f659d2c5d0c08527c03abb36
+  data.tar.gz: a3c5c9a244badd20e5279b8276ace39bb1ab064d78f0cd1944c9b4a6f0bc6d4f0375cfe4924d4f9e3a6f43fe3918aef51cfee8edc12cf71f84261b1f41b8ac1d

data/Gemfile

@@ -0,0 +1,24 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2015-2016 Jordon Bedwell - MIT License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+source "https://rubygems.org"
+gem "rake", :require => false
+gem "addressable"
+gem "i18n"
+gemspec
+
+group :test do
+  gem "liquid", :require => false
+  gem "codeclimate-test-reporter", :require => false
+  gem "luna-rspec-formatters", :require => false
+  gem "rspec", :require => false
+end
+
+group :development do
+  gem "luna-rubocop-formatters", :require => false
+  gem "rubocop", :github => "bbatsov/rubocop", :require => false
+  gem "pry", :require => false
+end

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2015-2016 Jordon Bedwell
+
+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/Rakefile

@@ -0,0 +1,13 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2015-2016 Jordon Bedwell - MIT License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+require "luna/rubocop/rake/task"
+$LOAD_PATH.unshift(File.expand_path("../lib", __FILE__))
+require "rspec/core/rake_task"
+
+task :default => [:spec]
+RSpec::Core::RakeTask.new :spec
+task :test => :spec

data/lib/extras/all.rb

@@ -0,0 +1,9 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2015-2016 Jordon Bedwell - MIT License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+Dir[File.join(File.expand_path(__dir__), "{*,**/*}.rb")].each do |f|
+  require f
+end

data/lib/extras/array.rb

@@ -0,0 +1,62 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2015-2016 Jordon Bedwell - MIT License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+module Extras
+  module Array
+    module ClassMethods
+      def allowed
+        @allowed ||= begin
+          out = {
+            :keys => [::NilClass, ::Hash, ::TrueClass, \
+              ::FalseClass, ::Regexp, ::Array, ::Set, ::Fixnum,
+              ::Bignum, ::Float]
+          }
+        end
+      end
+    end
+
+    # ------------------------------------------------------------------------
+    # Stringify an array's keys, skipping anything within the allowed list.
+    # ------------------------------------------------------------------------
+
+    def stringify(allowed_keys: nil, allowed_vals: nil)
+      keys = allowed_keys || self.class.allowed[:keys]
+
+      map do |v|
+        v = v.to_s unless keys.include?(v.class)
+        !v.respond_to?(:stringify) ? v : v.stringify({
+          :allowed_keys => allowed_keys,
+          :allowed_vals => allowed_vals
+        })
+      end
+    end
+
+    # ------------------------------------------------------------------------
+    # Symbolize an array's keys, skpping anything within the allowed list.
+    # ------------------------------------------------------------------------
+
+    def symbolize(allowed_keys: nil, allowed_vals: nil)
+      keys = allowed_keys || self.class.allowed[:keys]
+
+      map do |v|
+        v = v.to_sym unless !v.respond_to?(:to_sym) || keys.include?(v.class)
+        !v.respond_to?(:symbolize) ? v : v.symbolize({
+          :allowed_keys => allowed_keys,
+          :allowed_vals => allowed_vals
+        })
+      end
+    end
+  end
+end
+
+#
+
+class Array
+  prepend Extras::Array
+  class << self
+    prepend Extras::Array::ClassMethods
+  end
+end

data/lib/extras/hash.rb

@@ -0,0 +1,125 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2015-2016 Jordon Bedwell - MIT License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+module Extras
+  module Hash
+    module ClassMethods
+      def allowed
+        @allowed ||= begin
+          {
+            :keys => [],
+            :vals => [::NilClass, ::Hash, ::TrueClass, \
+              ::FalseClass, ::Regexp, ::Array, ::Set, ::Fixnum,
+              ::Bignum, ::Float]
+          }
+        end
+      end
+    end
+
+    # ------------------------------------------------------------------------
+    # Symbolize keys and values of the current hash, skipping allowed objects.
+    # ------------------------------------------------------------------------
+
+    def symbolize(allowed_keys: nil, allowed_vals: nil)
+      keys = allowed_keys || self.class.allowed[:keys]
+      vals = allowed_vals || self.class.allowed[:vals]
+
+      each_with_object({}) do |(k, v), h|
+        k = k.to_sym unless !k.respond_to?(:to_sym) || keys.include?(k.class)
+        v = v.to_sym unless !v.respond_to?(:to_sym) || vals.include?(v.class)
+
+        h[k] = !v.respond_to?(:symbolize) ? v : v.symbolize({
+          :allowed_keys => allowed_keys,
+          :allowed_vals => allowed_vals
+        })
+      end
+    end
+
+    # ------------------------------------------------------------------------
+    # Stringify keys and values of the current hash, skipping objects
+    # that are allowed to be skipped (leaving them as is, untouched.)
+    # ------------------------------------------------------------------------
+
+    def stringify(allowed_keys: nil, allowed_vals: nil)
+      keys = allowed_keys || self.class.allowed[:keys]
+      vals = allowed_vals || self.class.allowed[:vals]
+
+      each_with_object({}) do |(k, v), h|
+        v = v.to_s if !v.respond_to?(:stringify) && !vals.include?(v.class)
+        k = k.to_s unless keys.include?(k.class)
+
+        h[k] = !v.respond_to?(:stringify) ? v : v.stringify({
+          :allowed_keys => allowed_keys,
+          :allowed_vals => allowed_vals
+        })
+      end
+    end
+
+    # ------------------------------------------------------------------------
+    # Stringify the keys of the current hash, skipping allowed objects.
+    # ------------------------------------------------------------------------
+
+    def stringify_keys(allowed: nil)
+      allowed ||= self.class.allowed[:keys]
+      each_with_object({}) do |(k, v), h|
+        k = k.to_s unless allowed.include?(k.class)
+        h[k] = !v.respond_to?(:stringify_keys) ? v : v.stringify_keys({
+          :allowed => allowed
+        })
+      end
+    end
+
+    # ------------------------------------------------------------------------
+    # Symbolize the keys of the current hash, skipping allowed objects.
+    # ------------------------------------------------------------------------
+
+    def symbolize_keys(allowed: nil)
+      allowed ||= self.class.allowed[:keys]
+      each_with_object({}) do |(k, v), h|
+        k = k.to_sym if k.respond_to?(:to_sym) && !allowed.include?(k.class)
+        h[k] = !v.respond_to?(:symbolize_keys) ? v : v.symbolize_keys({
+          :allowed => allowed
+        })
+      end
+    end
+
+    # ------------------------------------------------------------------------
+    # Merge hash into hash into hash into hash.
+    # ------------------------------------------------------------------------
+
+    def deep_merge(new_h)
+      merge(new_h) do |_, ov, nv|
+        if ov.respond_to?(:deep_merge) && nv.respond_to?(:deep_merge)
+          then ov.deep_merge(
+            nv
+          )
+
+        else
+          nv
+        end
+      end
+    end
+
+    # ------------------------------------------------------------------------
+    # Check to see if any of the given keys exist.
+    # ------------------------------------------------------------------------
+
+    def any_key?(*keys)
+      keys.any? do |k|
+        key?(k)
+      end
+    end
+  end
+end
+
+#
+
+class Hash
+  prepend Extras::Hash
+  class << self
+    prepend Extras::Hash::ClassMethods
+  end
+end

data/lib/extras/shell.rb

@@ -0,0 +1,59 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2015-2016 Jordon Bedwell - MIT License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+require "shellwords"
+
+module Extras
+  module Shell
+
+    # ------------------------------------------------------------------------
+    # rubocop:disable Metrics/CyclomaticComplexity
+    # Escapes a string double checking if it will double escape.
+    # rubocop:disable Metrics/PerceivedComplexity
+    # Note: This is taken from Ruby 2.3 StdLib.
+    # ------------------------------------------------------------------------
+
+    def escape(str, original: false)
+      if original
+        return super(
+          str
+        )
+      end
+
+      if !str || str.empty? || str == '""' || str == "''"
+        return '""'
+
+      elsif str.is_a?(Array)
+        str.map do |v|
+          escape(v)
+        end
+
+      elsif str.is_a?(Hash)
+        str.each do |k, v|
+          str[k] = escape(
+            v
+          )
+        end
+
+      else
+        regexp = /((?:\\)?[^A-Za-z0-9_\-.,:\/@\n])/
+        str = str.gsub(regexp) { $1.start_with?("\\") ? $1 : "\\#{$1}" }
+        str = str.gsub(/\n/, "'\n'")
+        str
+      end
+    end
+
+    alias shellescape escape
+  end
+end
+
+#
+
+module Shellwords
+  class << self
+    prepend Extras::Shell
+  end
+end

data/lib/extras/string.rb

@@ -0,0 +1,36 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2015-2016 Jordon Bedwell - MIT License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+require "forwardable/extended"
+
+module Extras
+  module String
+    extend Forwardable::Extended
+    rb_delegate :regexp_escape, {
+      :alias_of => :escape,
+      :to => Regexp,
+      :args => [
+        :self
+      ]
+    }
+
+    # ------------------------------------------------------------------------
+    # Note: This method has support for "\char" escaping to prevent splits.
+    # Split a string into an array.
+    # ------------------------------------------------------------------------
+
+    def to_a(char: "\s", strip: true)
+      escaped = char.regexp_escape
+      split(/(?<!\\)#{escaped}/).map do |v|
+        strip ? v.gsub(/\\#{escaped}/, char) : v
+      end
+    end
+  end
+end
+
+class String
+  prepend Extras::String
+end

data/lib/extras/version.rb

@@ -0,0 +1,9 @@
+# ----------------------------------------------------------------------------
+# Frozen-string-literal: true
+# Copyright: 2015-2016 Jordon Bedwell - MIT License
+# Encoding: utf-8
+# ----------------------------------------------------------------------------
+
+module Extras
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: extras
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jordon Bedwell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: forwardable-extended
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+description: Add some neat little extras into your Ruby stuff.
+email:
+- jordon@envygeeks.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- LICENSE
+- Rakefile
+- lib/extras/all.rb
+- lib/extras/array.rb
+- lib/extras/hash.rb
+- lib/extras/shell.rb
+- lib/extras/string.rb
+- lib/extras/version.rb
+homepage: http://github.com/envygeeks/extras
+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.6.2
+signing_key: 
+specification_version: 4
+summary: Add neat extras into your Ruby stuff.
+test_files: []