corefines 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6ff01826fd1321effe7725bd8de106831ae6400c
-  data.tar.gz: 6441dd63f2e8896861f092fce7c3001258aefdb1
+  metadata.gz: ea0feea695c1bc742c15a3ca74b9e4aa98d1d632
+  data.tar.gz: cce9dd830c78ddec528b274c8a42119dd79bf51d
 SHA512:
-  metadata.gz: 4e3b8f57a51c0c947e9ae175481676b4b2c9423f687533a8d549069d39a3d35cd66b4830fff0430c83f821b15ac312b61db3e99d2de9271bae5dda2f181a0132
-  data.tar.gz: e5d5affb24e366e957d40894bfaec32bd1cd1f59693816fd8777e2cddcf19f5981080a2d5abe0ab6a1e07398d0ad98fe7c7f3aa9ac3d82b39ef3eb9416875db4
+  metadata.gz: 36952b5e7ac736ae14986a44737fd7232a7ead39091ac4075b67b470dee862e260876511b757b316e326e95aa869fac6415adf6a7c775e7da9f34c72fe43bdcf
+  data.tar.gz: b70e5551f42ad5f19f44e65427bbf9d09c59b78a167e46e022ee1c33a65b81ae283fd497cd52b0acbd83ad5e416b8c3ba6932e0993e0900b47120d3a7cabd547

data/CHANGELOG.adoc

@@ -3,6 +3,13 @@
 :doc-base-url: http://www.rubydoc.info/github/jirutka/corefines/Corefines
 :issue-uri: {repo-uri}/issues
 
+== 1.7.0 (2015-07-05)
+
+* Add new refinement {doc-base-url}/Enumerable/MapTo[Enumerable#map_to].
+* Add new refinement {doc-base-url}/Array/Wrap[Array#wrap].
+* Add new refinement {doc-base-url}/Enumerable/Many[Enumerable#many?].
+
+
 == 1.6.0 (2015-05-16)
 
 * Add new refinement {doc-base-url}/String/Camelcase[String#camelcase].

data/README.adoc

@@ -11,14 +11,14 @@ ifdef::env-github[:idprefix: user-content-]
 :gh-name: jirutka/{gem-name}
 :gh-branch: master
 :badge-style: flat
-:doc-base-url: http://www.rubydoc.info/github/jirutka/corefines/Corefines
+:doc-base-url: http://www.rubydoc.info/github/{gh-name}/{gh-branch}/Corefines
 
 ifdef::env-github[]
 image:https://img.shields.io/travis/{gh-name}/{gh-branch}.svg?style={badge-style}[Build Status, link="https://travis-ci.org/{gh-name}"]
 image:https://img.shields.io/codeclimate/coverage/github/{gh-name}.svg?style={badge-style}[Test Coverage, link="https://codeclimate.com/github/{gh-name}"]
 image:https://img.shields.io/codeclimate/github/{gh-name}.svg?style={badge-style}[Code Climate, link="https://codeclimate.com/github/{gh-name}"]
 image:https://img.shields.io/gem/v/{gem-name}.svg?style={badge-style}[Gem Version, link="https://rubygems.org/gems/{gem-name}"]
-image:https://img.shields.io/badge/yard-docs-blue.svg?style={badge-style}[Yard Docs, link="http://www.rubydoc.info/github/{gh-name}/frames"]
+image:https://img.shields.io/badge/yard-docs-blue.svg?style={badge-style}[Yard Docs, link="http://www.rubydoc.info/github/{gh-name}/{gh-branch}"]
 endif::env-github[]
 
 Corefines is a collection of general purpose _refinements_ for extending the core capabilities of Ruby’s built-in classes.
@@ -41,12 +41,12 @@ TODO
 Add this line to your application’s Gemfile:
 
 [source]
-gem 'corefines', '~> 1.6'
+gem 'corefines', '~> 1.7'
 
 or to your gemspec:
 
 [source]
-s.add_runtime_dependency 'corefines', '~> 1.6'
+s.add_runtime_dependency 'corefines', '~> 1.7'
 
 and then execute:
 
@@ -132,9 +132,12 @@ Not ideal indeed, but probably the best of what we can achieve.
 * {doc-base-url}/Array[Array]
 ** {doc-base-url}/Array/Second[#second]
 ** {doc-base-url}/Array/Third[#third]
+** {doc-base-url}/Array/Wrap[.wrap]
 * {doc-base-url}/Enumerable[Enumerable]
 ** {doc-base-url}/Enumerable/IndexBy[#index_by]
+** {doc-base-url}/Enumerable/Many[#many?]
 ** {doc-base-url}/Enumerable/MapSend[#map_send]
+** {doc-base-url}/Enumerable/MapTo[#map_to]
 * {doc-base-url}/Hash[Hash]
 ** {doc-base-url}/Hash/OpAdd[#+]
 ** {doc-base-url}/Hash/Compact[#compact]

data/lib/corefines/array.rb

@@ -25,6 +25,66 @@ module Corefines
       end
     end
 
+    ##
+    # @!method self.wrap(object)
+    #   Wraps its argument in an array unless it is already an array (or
+    #   array-like).
+    #
+    #   Specifically:
+    #
+    #   * If the argument is +nil+ an empty list is returned.
+    #   * Otherwise, if the argument responds to +to_ary+ it is invoked, and
+    #     its result returned.
+    #   * Otherwise, returns an array with the argument as its single element.
+    #
+    #   @example
+    #     Array.wrap(nil) # => []
+    #     Array.wrap([1, 2, 3]) # => [1, 2, 3]
+    #     Array.wrap(0) # => [0]
+    #
+    #   This method is similar in purpose to <tt>Kernel#Array</tt>, but there
+    #   are some differences:
+    #
+    #   * If the argument responds to +to_ary+ the method is invoked.
+    #     <tt>Kernel#Array</tt> moves on to try +to_a+ if the returned value is
+    #     +nil+, but <tt>Array.wrap</tt> returns +nil+ right away.
+    #   * If the returned value from +to_ary+ is neither +nil+ nor an +Array+
+    #     object, <tt>Kernel#Array</tt> raises an exception, while
+    #     <tt>Array.wrap</tt> does not, it just returns the value.
+    #   * It does not call +to_a+ on the argument, but returns an empty array
+    #     if argument is +nil+.
+    #
+    #   The second point is easily explained with some enumerables:
+    #
+    #     Array(foo: :bar) # => [[:foo, :bar]]
+    #     Array.wrap(foo: :bar) # => [{:foo=>:bar}]
+    #
+    #   There's also a related idiom that uses the splat operator:
+    #
+    #     [*object]
+    #
+    #   which returns <tt>[]</tt> for +nil+, but calls to
+    #   <tt>Array(object)</tt> otherwise.
+    #
+    #   The differences with <tt>Kernel#Array</tt> explained above apply to the
+    #   rest of <tt>object</tt>s.
+    #
+    #   @return [Array]
+    #
+    module Wrap
+      refine ::Array.singleton_class do
+        def wrap(object)
+          if object.nil?
+            []
+          elsif object.respond_to? :to_ary
+            object.to_ary || [object]
+          else
+            [object]
+          end
+        end
+      end
+    end
+
     include Support::AliasSubmodules
   end
 end

data/lib/corefines/enumerable.rb

@@ -36,6 +36,47 @@ module Corefines
       end
     end
 
+    ##
+    # @!method many?
+    #   Returns +true+ if the enumerable has more than one element.
+    #
+    #   This method is functionally equivalent to <tt>enum.to_a.size > 1</tt>,
+    #   or <tt>enum.select { ... }.length > 1</tt> when the block is given.
+    #
+    #   @example
+    #     [1].many?             # => false
+    #     [1, 2].many?          # => true
+    #     [1, 2, 3].many?       # => true
+    #     [1, nil].many?        # => true
+    #     [1, 2, 3].many? { |n| n > 2 }  # => false
+    #
+    #   @overload many?
+    #     @return [Boolean] +true+ if the enumerable has more than one element.
+    #
+    #   @overload many?(&block)
+    #     @yield [obj] gives each element to the block.
+    #     @return [Boolean] +true+ if the block returns a truthy value (i.e.
+    #       other than +nil+ and +false+) more than once.
+    #
+    module Many
+      Support.classes_including_module(::Enumerable) do |klass|
+
+        refine klass do
+          def many?
+            cnt = 0
+            if block_given?
+              any? do |element|
+                cnt += 1 if yield element
+                cnt > 1
+              end
+            else
+              any? { (cnt += 1) > 1 }
+            end
+          end
+        end
+      end
+    end
+
     ##
     # @!method map_send(method_name, *args, &block)
     #   Sends a message to each element and collects the result.
@@ -59,6 +100,32 @@ module Corefines
       end
     end
 
+    ##
+    # @!method map_to(klass)
+    #   Maps each element of this _enum_ into the _klass_ via constructor.
+    #
+    #   @example
+    #     ['/tmp', '/var/tmp'].map_to(Pathname) # => [#<Pathname:/tmp>, #<Pathname:/var/tmp>]
+    #
+    #   @param klass [#new] the klass to map each element to.
+    #   @return [Enumerable] a new array with instances of the _klass_ for
+    #     every element in _enum_.
+    #
+    module MapTo
+      Support.classes_including_module(::Enumerable) do |klass|
+
+        refine klass do
+          def map_to(klass)
+            map { |e| klass.new(e) }
+          end
+        end
+      end
+    end
+
     include Support::AliasSubmodules
+
+    class << self
+      alias_method :many?, :many
+    end
   end
 end

data/lib/corefines/string.rb

@@ -25,6 +25,10 @@ module Corefines
     #       "camel::ca-se-y".camelcase(':', '-')      # => "camelCaSeY"
     #       "camel42case".camelcase(/[0-9]+/)         # => "camelCase"
     #
+    #     @param *separators [String, Regexp] the patterns used to determine
+    #            where capitalization should occur. Defaults to <tt>/_+/</tt> and
+    #            <tt>\s+</tt>.
+    #
     #   @overload camelcase(first_letter, *separators)
     #     @example
     #       "camel case".camelcase(:upper)            # => "CamelCase"
@@ -33,10 +37,10 @@ module Corefines
     #     @param first_letter [:upper, :lower] desired case of the first
     #            character of a word - +:upper+ to be upcased, or +:lower+ to
     #            be downcased.
+    #     @param *separators [String, Regexp] the patterns used to determine
+    #            where capitalization should occur. Defaults to <tt>/_+/</tt> and
+    #            <tt>\s+</tt>.
     #
-    #   @param *separators [String, Regexp] the patterns used to determine
-    #          where capitalization should occur. Defaults to <tt>/_+/</tt> and
-    #          <tt>\s+</tt>.
     #   @return [String] a copy of the _str_ converted to camelcase.
     #
     module Camelcase

data/lib/corefines/version.rb

@@ -1,3 +1,3 @@
 module Corefines
-  VERSION = '1.6.0'
+  VERSION = '1.7.0'
 end

data/spec/array/wrap_spec.rb

@@ -0,0 +1,50 @@
+describe Array do
+  using Corefines::Array::wrap
+
+  describe '.wrap' do
+
+    context "array" do
+      it "returns the given array unchanged" do
+        ary = ['foo', 'bar']
+        expect( Array.wrap(ary) ).to be ary
+      end
+    end
+
+    context "nil" do
+      it "returns an empty array" do
+        expect( Array.wrap(nil) ).to eq []
+      end
+    end
+
+    context "an object" do
+      it "returns it wrapped in an array" do
+        o = Object.new
+        expect( Array.wrap(o) ).to eq [o]
+      end
+    end
+
+    context "string" do
+      it "returns it wrapped in an array" do
+        expect( Array.wrap("foo\nbar") ).to eq ["foo\nbar"]
+      end
+    end
+
+    context "object with #to_ary" do
+
+      it "returns result of #to_ary" do
+        o = Class.new { def to_ary; ['foo', 'bar'] end }.new
+        expect( Array.wrap(o) ).to eq o.to_ary
+      end
+
+      it "returns wrapped if #to_ary returns nil" do
+        o = Class.new { def to_ary; nil end }.new
+        expect( Array.wrap(o) ).to eq [o]
+      end
+
+      it "doesn't complain if #to_ary doesn't return an array" do
+        o = Class.new { def to_ary; :not_an_array end }.new
+        expect( Array.wrap(o) ).to eq o.to_ary
+      end
+    end
+  end
+end

data/spec/enumerable/many_spec.rb

@@ -0,0 +1,66 @@
+describe Enumerable do
+  using Corefines::Enumerable::many?
+
+  describe '#many?' do
+
+    shared_examples :without_block do |enum, expected|
+      context enum.class do
+        it { expect( enum.many? ).to be expected }
+      end
+    end
+
+    context "when empty" do
+      [ [], Set.new, {} ].each do |enum|
+        include_examples :without_block, enum, false
+      end
+    end
+
+    context "when one element" do
+      [ [42], Set.new([42]), {a: 42} ].each do |enum|
+        include_examples :without_block, enum, false
+      end
+    end
+
+    context "when two elements" do
+      [ [1, 2], Set.new([1, 2]), {a: 1, b: 2} ].each do |enum|
+        include_examples :without_block, enum, true
+      end
+    end
+
+    context "when two nil elements" do
+      [ [nil, nil], {a: nil, b: nil} ].each do |enum|
+        include_examples :without_block, enum, true
+      end
+    end
+
+    context "when more than two elements" do
+      [ [1, 2, 3], Set.new([1, 2, 3]), {a: 1, b: 2, c: 3} ].each do |enum|
+        include_examples :without_block, enum, true
+      end
+    end
+
+
+    context "with block" do
+
+      context "that yields true for one element" do
+        context Array do
+          it { expect( [1, 2].many? { |n| n > 1 } ).to eq false }
+        end
+
+        context Hash do
+          it { expect( {a: 1, b: 2}.many? { |k, v| v > 1 } ).to eq false }
+        end
+      end
+
+      context "that yield true for two elements" do
+        context Array do
+          it { expect( [1, 2].many? { |n| n > 0 } ).to eq true }
+        end
+
+        context Hash do
+          it { expect( {a: 1, b: 2}.many? { |k, v| k.is_a?(Symbol) } ).to eq true }
+        end
+      end
+    end
+  end
+end

data/spec/enumerable/map_to_spec.rb

@@ -0,0 +1,15 @@
+require 'pathname'
+
+describe Enumerable do
+  using Corefines::Enumerable::map_to
+
+  describe '#map_to' do
+
+    context Array do
+      it "creates instance of the klass for every element and collects the result" do
+        ary = ['/tmp', '/var/tmp']
+        expect( ary.map_to(Pathname) ).to eq ary.map { |e| Pathname.new(e) }
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: corefines
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.0
 platform: ruby
 authors:
 - Jakub Jirutka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-16 00:00:00.000000000 Z
+date: 2015-07-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: asciidoctor
@@ -122,8 +122,11 @@ files:
 - lib/corefines/version.rb
 - spec/array/second_spec.rb
 - spec/array/third_spec.rb
+- spec/array/wrap_spec.rb
 - spec/enumerable/index_by_spec.rb
+- spec/enumerable/many_spec.rb
 - spec/enumerable/map_send_spec.rb
+- spec/enumerable/map_to_spec.rb
 - spec/hash/compact_spec.rb
 - spec/hash/except_spec.rb
 - spec/hash/only_spec.rb