corefines 1.2.0 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c7839672b793a5df3d5ffa892272260eccf0c0db
-  data.tar.gz: 0a263d7e00645c8451d93461bfe9ed81cd8ccc1c
+  metadata.gz: de04dfa5cd06fc172ea71b0f428f04b76b6b0527
+  data.tar.gz: 0deb05f19ce1dddd0ca60d13e8f9101dee5d49c0
 SHA512:
-  metadata.gz: 93f5a5a21061dea9e9aaddf7ea5520e7743a0c84c9635d42c63cdaed032fae12e328e141a60d40ac22ea7d986b3cda8a258374a583df7fdbcafbf7d8856bc317
-  data.tar.gz: 7b31c6b28bb018d1b0ee9fd9368922a0a282a545e461c0e6f488111ea0837abcdee533249d97560c7f31adc47aaf8cc2698fd4dc03bf353ce2435b226aef7e2d
+  metadata.gz: 078f83c0f36e11534267b88cb445aad00f8483c6ddf9e1e3c2f804044d09f619655b75560038bc2f99cafccf577f0468ea0e32fca166069ed2c5ff7bcb78e5e2
+  data.tar.gz: 366f0084b4bac8eec6666fc40fb6091896be88c1d3d90f9c59047227e354bcd99ce82b991a26935639c35f1b483e59471ea0a717492dd94918d281846cbc72a5

data/CHANGELOG.adoc

@@ -3,6 +3,14 @@
 :doc-base-url: http://www.rubydoc.info/github/jirutka/corefines/Corefines
 :issue-uri: {repo-uri}/issues
 
+== 1.3.0 (2015-04-29)
+
+* Add new refinement {doc-base-url}/String/ToRegexp[String#to_regexp].
+* Add new refinement {doc-base-url}/String/RelativePathFrom[String#relative_path_from].
+* Add new refinement {doc-base-url}/Hash/Except[Hash#except].
+* Add new refinement {doc-base-url}/Hash/Only[Hash#only].
+
+
 == 1.2.0 (2015-04-27)
 
 * Add new refinement {doc-base-url}/String/Indent[String#indent].

data/README.adoc

@@ -41,12 +41,12 @@ TODO
 Add this line to your application’s Gemfile:
 
 [source]
-gem 'corefines', '~> 1.2'
+gem 'corefines', '~> 1.3'
 
 or to your gemspec:
 
 [source]
-s.add_runtime_dependency 'corefines', '~> 1.2'
+s.add_runtime_dependency 'corefines', '~> 1.3'
 
 and then execute:
 
@@ -139,6 +139,10 @@ Not ideal indeed, but probably the best of what we can achieve.
 ** {doc-base-url}/Hash/OpAdd[#+]
 ** {doc-base-url}/Hash/Compact[#compact]
 ** {doc-base-url}/Hash/Compact[#compact!]
+** {doc-base-url}/Hash/Except[#except]
+** {doc-base-url}/Hash/Except[#except!]
+** {doc-base-url}/Hash/Only[#only]
+** {doc-base-url}/Hash/Only[#only!]
 ** {doc-base-url}/Hash/Rekey[#rekey]
 ** {doc-base-url}/Hash/Rekey[#rekey!]
 ** {doc-base-url}/Hash/SymbolizeKeys[#symbolize_keys]
@@ -159,11 +163,13 @@ Not ideal indeed, but probably the best of what we can achieve.
 ** {doc-base-url}/Object/Try[#try!]
 * {doc-base-url}/String[String]
 ** {doc-base-url}/String/Color[#color]
-** {doc-base-url}/String/Concat[#concat]
+** {doc-base-url}/String/Concat[#concat!]
 ** {doc-base-url}/String/Decolor[#decolor]
 ** {doc-base-url}/String/Indent[#indent]
+** {doc-base-url}/String/RelativePathFrom[#relative_path_from]
 ** {doc-base-url}/String/Remove[#remove]
 ** {doc-base-url}/String/ToB[#to_b]
+** {doc-base-url}/String/ToRegexp[#to_regexp]
 ** {doc-base-url}/String/Unindent[#unindent] (alias `#strip_heredoc`)
 * {doc-base-url}/Symbol[Symbol]
 ** {doc-base-url}/Symbol/Call[#call]
@@ -177,6 +183,7 @@ Most of the extension methods are based on, or highly inspired from:
 * https://github.com/rubyworks/facets[Ruby Facets]
 * https://github.com/gregwebs/methodchain[methodchain]
 * https://github.com/fazibear/colorize[colorize]
+* https://github.com/seamusabshere/to_regexp[to_regexp]
 
 Very useful articles about refinements and how to “trick” them:
 

data/lib/corefines/hash.rb

@@ -31,6 +31,86 @@ module Corefines
       end
     end
 
+    ##
+    # @!method except(*keys)
+    #   @example
+    #     hash = { a: 1, b: 2, c: 3, d: 4 }
+    #     hash.except(:a, :d)  # => { b: 2, c: 3 }
+    #     hash  # => { a: 1, b: 2, c: 3, d: 4 }
+    #
+    #   @param *keys the keys to exclude from the hash.
+    #   @return [Hash] a new hash without the specified key/value pairs.
+    #
+    # @!method except!(*keys)
+    #   Removes the specified keys/value pairs in-place.
+    #
+    #   @example
+    #     hash = { a: 1, b: 2, c: 3, d: 4 }
+    #     hash.except(:a, :d)  # => { b: 2, c: 3 }
+    #     hash  # => { b: 2, c: 3 }
+    #
+    #   @see #except
+    #   @param *keys (see #except)
+    #   @return [Hash] a hash containing the removed key/value pairs.
+    #
+    module Except
+      refine ::Hash do
+        def except(*keys)
+          keys.each_with_object(dup) do |k, hash|
+            hash.delete(k)
+          end
+        end
+
+        def except!(*keys)
+          keys.each_with_object(dup.clear) do |k, deleted|
+            deleted[k] = delete(k) if has_key? k
+          end
+        end
+      end
+    end
+
+    ##
+    # @!method only(*keys)
+    #   @example
+    #     hash = { a: 1, b: 2, c: 3, d: 4 }
+    #     hash.only(:a, :d)  # => { a: 1, d: 4 }
+    #     hash  # => { a: 1, b: 2, c: 3, d: 4 }
+    #
+    #   @param *keys the keys to include in the hash.
+    #   @return [Hash] a new hash with only the specified key/value pairs.
+    #
+    # @!method only!(*keys)
+    #   Removes all key/value pairs except the ones specified by _keys_.
+    #
+    #   @example
+    #     hash = { a: 1, b: 2, c: 3, d: 4 }
+    #     hash.only(:a, :d)  # => { a: 1, d: 4 }
+    #     hash  # => { a: 1, d: 4 }
+    #
+    #   @see #only
+    #   @param *keys (see #only)
+    #   @return [Hash] a hash containing the removed key/value pairs.
+    #
+    module Only
+      refine ::Hash do
+        def only(*keys)
+          # Note: self.dup is used to preserve the default_proc.
+          keys.each_with_object(dup.clear) do |k, hash|
+            hash[k] = self[k] if has_key? k
+          end
+        end
+
+        def only!(*keys)
+          deleted = keys.each_with_object(dup) do |k, hash|
+            hash.delete(k)
+          end
+          replace only(*keys)
+
+          deleted
+        end
+      end
+    end
+
     ##
     # @!method +(other_hash)
     #   Alias for +#merge+.
@@ -157,6 +237,8 @@ module Corefines
 
     class << self
       alias_method :compact!, :compact
+      alias_method :except!, :except
+      alias_method :only!, :only
       alias_method :rekey!, :rekey
       alias_method :symbolize_keys!, :symbolize_keys
     end

data/lib/corefines/string.rb

@@ -1,3 +1,4 @@
+# coding: utf-8
 require 'corefines/support/alias_submodules'
 
 module Corefines
@@ -170,6 +171,32 @@ module Corefines
       end
     end
 
+    ##
+    # @!method relative_path_from(base_dir)
+    #   Returns a relative path from the given _base_dir_ to the path
+    #   represented by this _str_. This method doesn't access the filesystem
+    #   and assumes no symlinks.
+    #
+    #   If _str_ is absolute, then _base_dir_ must be absolute too.
+    #   If _str_ is relative, then _base_dir_ must be relative too.
+    #
+    #   @example
+    #     '/home/flynn/tron'.relative_path_from('/home')  # => flynn/tron
+    #     '/home'.relative_path_from('/home/flynn/tron')  # => ../..
+    #
+    #   @param base_dir [String, Pathname] the base directory to calculate
+    #          relative path from.
+    #   @return [String] a relative path from _base_dir_ to this _str_.
+    #   @raise ArgumentError if it cannot find a relative path.
+    #
+    module RelativePathFrom
+      refine ::String do
+        def relative_path_from(base_dir)
+          ::Pathname.new(self).relative_path_from(::Pathname.new(base_dir)).to_s
+        end
+      end
+    end
+
     ##
     # @!method remove(*patterns)
     #   Returns a copy of this string with *all* occurrences of the _patterns_
@@ -236,6 +263,68 @@ module Corefines
       end
     end
 
+    ##
+    # @!method to_regexp(opts = {})
+    #   Returns a regular expression represented by this string.
+    #
+    #   @example
+    #     '/^foo/'.to_regexp                  # => /^foo/
+    #     '/foo/i'.to_regexp                  # => /foo/i
+    #     'foo'.to_regexp                     # => nil
+    #
+    #     'foo'.to_regexp(literal: true)      # => /foo/
+    #     '^foo*'.to_regexp(literal: true)    # => /\^foo\*/
+    #
+    #     '/foo/'.to_regexp(detect: true)     # => /foo/
+    #     '$foo/'.to_regexp(detect: true)     # => /\$foo\//
+    #     ''.to_regexp(detect: true)          # => nil
+    #
+    #     '/foo/'.to_regexp(multiline: true)  # => /foo/m
+    #
+    #   @param opts [Hash] options
+    #   @option opts :literal [Boolean] treat meta characters and other regexp
+    #           codes as just a text. Never returns +nil+. (default: false)
+    #   @option opts :detect [Boolean] if string starts and ends with a slash,
+    #           treat it as a regexp, otherwise interpret it literally.
+    #           (default: false)
+    #   @option opts :ignore_case [Boolean] same as +/foo/i+. (default: false)
+    #   @option opts :multiline [Boolean] same as +/foo/m+. (default: false)
+    #   @option opts :extended [Boolean] same as +/foo/x+. (default: false)
+    #
+    #   @return [Regexp, nil] a regexp, or +nil+ if +:literal+ is not set or
+    #     +false+ and this string doesn't represent a valid regexp or is empty.
+    #
+    module ToRegexp
+      refine ::String do
+        def to_regexp(opts = {})
+
+          if opts[:literal]
+            content = ::Regexp.escape(self)
+
+          elsif self =~ %r{\A/(.*)/([imxnesu]*)\z}
+            content, inline_opts = $1, $2
+            content.gsub! '\\/', '/'
+
+            { ignore_case: 'i', multiline: 'm', extended: 'x' }.each do |k, v|
+              opts[k] ||= inline_opts.include? v
+            end if inline_opts
+
+          elsif opts[:detect] && !self.empty?
+            content = ::Regexp.escape(self)
+          else
+            return
+          end
+
+          options = 0
+          options |= ::Regexp::IGNORECASE if opts[:ignore_case]
+          options |= ::Regexp::MULTILINE if opts[:multiline]
+          options |= ::Regexp::EXTENDED if opts[:extended]
+
+          ::Regexp.new(content, options)
+        end
+      end
+    end
+
     ##
     # @!method unindent
     #   Remove excessive indentation. Useful for multi-line strings embeded in

data/lib/corefines/version.rb

@@ -1,3 +1,3 @@
 module Corefines
-  VERSION = '1.2.0'
+  VERSION = '1.3.0'
 end

data/spec/hash/except_spec.rb

@@ -0,0 +1,65 @@
+describe Hash do
+  using Corefines::Hash::except
+
+  subject(:hash) { {:one => 'ONE', 'two' => 'TWO', 3 => 'THREE'} }
+
+  let(:hash_with_proc) { Hash.new(&default_proc) }
+  let(:default_proc) { proc {} }
+
+  let(:hash_with_default) { Hash.new(default_value) }
+  let(:default_value) { 42 }
+
+
+  describe '#except' do
+
+    context "existing keys" do
+      it "returns a copy of the hash without the specified keys" do
+        expect( hash.except(:one, 3) ).to eql({'two' => 'TWO'})
+        expect( hash.except('two') ).to eql({:one => 'ONE', 3 => 'THREE'})
+      end
+    end
+
+    context "non-existing key" do
+      it "returns a copy of the hash unchanged" do
+        expect( hash.except(:x) ).to eql hash
+        expect( hash.except(:x) ).to_not equal(hash)
+      end
+    end
+
+    it "preserves the default_proc" do
+      expect( hash_with_proc.except(:one).default_proc ).to equal default_proc
+    end
+
+    it "preserves the default" do
+      expect( hash_with_default.except(:one).default ).to eq default_value
+    end
+  end
+
+
+  describe '#except!' do
+
+    context "existing keys" do
+      it "removes the specified keys/value pairs and returns them" do
+        expect( hash.except!(:one, 3) ).to eql({:one => 'ONE', 3 => 'THREE'})
+        is_expected.to eq({'two' => 'TWO'})
+      end
+    end
+
+    context "non-existing key" do
+      it "keeps the hash unchanged and returns an empty hash" do
+        expect( hash.except!(:x) ).to eq({})
+        expect( hash ).to equal hash
+      end
+    end
+
+    it "preserves the default_proc" do
+      expect( hash_with_proc.except!(:one).default_proc ).to equal default_proc
+      expect( hash_with_proc.default_proc ).to equal default_proc
+    end
+
+    it "preserves the default" do
+      expect( hash_with_default.except!(:one).default ).to eq default_value
+      expect( hash_with_default.default ).to eq default_value
+    end
+  end
+end

data/spec/hash/only_spec.rb

@@ -0,0 +1,67 @@
+describe Hash do
+  using Corefines::Hash::only
+
+  let(:hash) { {:one => 'ONE', 'two' => 'TWO', 3 => 'THREE'} }
+  let!(:original) { hash.dup }
+
+  let(:hash_with_proc) { Hash.new(&default_proc) }
+  let(:default_proc) { proc {} }
+
+  let(:hash_with_default) { Hash.new(default_value) }
+  let(:default_value) { 42 }
+
+
+  describe '#only' do
+
+    context "existing keys" do
+      it "returns a copy of the hash with only the specified keys" do
+        expect( hash.only(:one, 3) ).to eq({:one => 'ONE', 3 => 'THREE'})
+        expect( hash.only('two') ).to eq({'two' => 'TWO'})
+      end
+    end
+
+    context "non-existing key" do
+      it "returns an empty hash" do
+        expect( hash.only(:x) ).to eq({})
+      end
+    end
+
+    it "preserves the default_proc" do
+      expect( hash_with_proc.only(:one).default_proc ).to equal default_proc
+    end
+
+    it "preserves the default" do
+      expect( hash_with_default.only(:one).default ).to eq default_value
+    end
+  end
+
+
+  describe '#only!' do
+
+    context "existing keys" do
+      it "removes all key/value pairs except the specified and returns the removed" do
+        expect( hash.only!(:one, 3) ).to eq({'two' => 'TWO'})
+        expect( hash ).to eq({:one => 'ONE', 3 => 'THREE'})
+      end
+    end
+
+    context "non-existing key" do
+      it "removes all key/value pairs and returns a copy of the original hash" do
+        result = hash.only!(:x)
+        expect( result ).to eq original
+        expect( result ).to_not equal original
+        expect( hash ).to eq({})
+      end
+    end
+
+    it "preserves the default_proc" do
+      expect( hash_with_proc.only!(:one).default_proc ).to equal default_proc
+      expect( hash_with_proc.default_proc ).to equal default_proc
+    end
+
+    it "preserves the default" do
+      expect( hash_with_default.only!(:one).default ).to eq default_value
+      expect( hash_with_default.default ).to eq default_value
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,4 +1,4 @@
-require 'simplecov'
+require 'simplecov' unless RUBY_ENGINE == 'jruby'
 require 'corefines'
 
 RSpec.configure do |config|

data/spec/string/relative_path_from_spec.rb

@@ -0,0 +1,29 @@
+describe String do
+  using Corefines::String::relative_path_from
+
+  describe '#relative_path_from' do
+
+    [
+      [ '/home/flynn/tron', '/home',            'flynn/tron' ],
+      [ '/home',            '/home/flynn/tron', '../..'      ],
+      [ 'home/flynn/tron',  'home',             'flynn/tron' ],
+      [ '../bin/run',       '.',                '../bin/run' ],
+      [ '/usr/bin/../lib',  '/',                'usr/lib'    ]
+    ]
+    .each do |path, base, expected|
+      it "returns '#{expected}' for path '#{path}' and base '#{base}'" do
+        expect(path.relative_path_from(base)).to eql expected
+      end
+    end
+
+    context "mismatched relative and absolute path" do
+      {
+        '/home/flynn' => 'home',
+        'home/flynn'  => '/home'
+      }
+      .each do |path, base|
+        it { expect { path.relative_path_from(base) }.to raise_error ArgumentError }
+      end
+    end
+  end
+end

data/spec/string/to_regexp_spec.rb

@@ -0,0 +1,75 @@
+# coding: utf-8
+
+describe String do
+  using Corefines::String::to_regexp
+
+  describe 'to_regexp' do
+
+    context "with defaults" do
+      {
+        '/foo/'      => /foo/,
+        '/foo/i'     => /foo/i,
+        '/foo/m'     => /foo/m,
+        '/foo/x'     => /foo/x,
+        '/foo/imx'   => /foo/imx,
+        '/foo.*(o)/' => /foo.*(o)/,
+        '/česk[yý]/' => /česk[yý]/,
+        '/foo\/bar/' => %r{foo/bar},
+        '/foo'       => nil,
+        '/foo/z'     => nil
+      }
+      .each do |str, expected|
+        it "returns regexp '#{expected.inspect}' for string '#{str}'" do
+          expect(str.to_regexp).to eql expected
+        end
+      end
+
+      %w[n e s u nesu].each do |kcode|
+        it "ignores encoding option: #{kcode}" do
+          expect("/foo/#{kcode}".to_regexp).to eql /foo/
+        end
+      end
+    end
+
+    context "with literal" do
+      {
+        '/(foo)*/' => %r{/\(foo\)\*/},
+        '^foo)'     => /\^foo\)/
+      }
+      .each do |str, expected|
+        it "returns regexp '#{expected.inspect}' for string '#{str}" do
+          expect(str.to_regexp(literal: true)).to eql expected
+        end
+      end
+    end
+
+    context "with detect" do
+      {
+        ''           => nil,
+        'foo'        => /foo/,
+        '(foo)*'     => /\(foo\)\*/,
+        '/[a-z]'     => %r{/\[a\-z\]},
+        '^.foo/x'    => %r{\^\.foo/x},
+        '//'         => //,
+        '/(foo)*/im' => /(foo)*/im
+      }
+      .each do |str, expected|
+        it "returns regexp '#{expected.inspect}' for string '#{str}'" do
+          expect(str.to_regexp(detect: true)).to eql expected
+        end
+      end
+    end
+
+    context "with ignore_case" do
+      it { expect('/foo/'.to_regexp(ignore_case: true)).to eql /foo/i }
+    end
+
+    context "with multiline" do
+      it { expect('/foo/'.to_regexp(multiline: true)).to eql /foo/m }
+    end
+
+    context "with extended" do
+      it { expect('/foo/'.to_regexp(extended: true)).to eql /foo/x }
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: corefines
 version: !ruby/object:Gem::Version
-  version: 1.2.0
+  version: 1.3.0
 platform: ruby
 authors:
 - Jakub Jirutka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-26 00:00:00.000000000 Z
+date: 2015-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: asciidoctor
@@ -125,6 +125,8 @@ files:
 - spec/enumerable/index_by_spec.rb
 - spec/enumerable/map_send_spec.rb
 - spec/hash/compact_spec.rb
+- spec/hash/except_spec.rb
+- spec/hash/only_spec.rb
 - spec/hash/op_add_spec.rb
 - spec/hash/rekey_spec.rb
 - spec/hash/symbolize_keys_spec.rb
@@ -143,8 +145,10 @@ files:
 - spec/string/concat_spec.rb
 - spec/string/decolor_spec.rb
 - spec/string/indent_spec.rb
+- spec/string/relative_path_from_spec.rb
 - spec/string/remove_spec.rb
 - spec/string/to_b_spec.rb
+- spec/string/to_regexp_spec.rb
 - spec/string/unindent_spec.rb
 - spec/support/alias_submodules_spec.rb
 - spec/support/classes_including_module_spec.rb