corefines 1.0.0

data/lib/corefines/support/classes_including_module.rb

@@ -0,0 +1,27 @@
+module Corefines
+  module Support
+
+    @classes_including_module = {}
+
+    ##
+    # @private
+    # Finds all classes that includes the specified module.
+    # Results are cached to speed-up repeated calls.
+    #
+    # @param mod [Module] the module.
+    # @yield [Class] gives each class that includes the _mod_.
+    #
+    def self.classes_including_module(mod)
+      @classes_including_module[mod] ||=
+        ::ObjectSpace.each_object(::Class).select do |klass|
+          begin
+            klass.included_modules.include?(mod)
+          rescue
+            # ignore errors
+          end
+        end
+
+      @classes_including_module[mod].each { |e| yield e }
+    end
+  end
+end

data/lib/corefines/support/fake_refinements.rb

@@ -0,0 +1,86 @@
+module Corefines
+  module Support
+    ##
+    # @private
+    # Faked Refinements somehow mimics refinements on Ruby engines that doesn't
+    # support them yet. It provides the same interface, but actually does just
+    # plain monkey-patching; the changes are *not* scoped like when using real
+    # refinements.
+    #
+    # It's useful when you want to use refinements, but also need to support
+    # older versions of Ruby, at least limited.
+    #
+    module FakeRefinements
+
+      MUTEX = Mutex.new
+      private_constant :MUTEX
+
+      def self.define_refine(target)
+        target.send(:define_method, :refine) do |klass, &block|
+          fail TypeError, "wrong argument type #{klass.class} (expected Class)" unless klass.is_a? ::Class
+          fail ArgumentError, "no block given" unless block
+
+          MUTEX.synchronize do
+            (@__pending_refinements ||= []) << [klass, block]
+          end
+          __refine__(klass) { module_eval &block } if respond_to?(:__refine__, true)
+
+          self
+        end
+        target.send(:private, :refine)
+      end
+
+      def self.define_using(target)
+        target.send(:define_method, :using) do |mod|
+          refinements = mod.instance_variable_get(:@__pending_refinements)
+
+          if refinements && !refinements.empty?
+            MUTEX.synchronize do
+              refinements.delete_if do |klass, block|
+                klass.class_eval &block
+                true
+              end
+            end
+          end
+
+          # Evaluate refinements from submodules recursively.
+          mod.included_modules.each do |submodule|
+            using submodule
+          end
+
+          self
+        end
+        target.send(:private, :using)
+      end
+
+      def self.alias_private_method(klass, new_name, old_name)
+        return if !klass.private_method_defined?(old_name) ||
+          klass.private_method_defined?(new_name)
+
+        klass.send(:alias_method, new_name, old_name)
+      end
+    end
+  end
+end
+
+
+# If Module doesn't define method +using+, then refinements are apparently not
+# supported on this platform, or running on MRI 2.0 that allows +using+ only on
+# top-level. Since refinements in MRI 2.0 are experimental and behaves
+# differently than in later versions, we use "faked refinements" even so.
+unless Module.private_method_defined? :using
+
+  warn "corefines: Your Ruby doesn't support refinements, so I'll fake them \
+using plain monkey-patching (not scoped!)."
+
+  m = Corefines::Support::FakeRefinements
+
+  # Define using on Module and the main object.
+  [Module, self.singleton_class].each do |klass|
+    m.alias_private_method(klass, :__using__, :using)
+    m.define_using(klass)
+  end
+
+  m.alias_private_method(Module, :__refine__, :refine)
+  m.define_refine(Module)
+end

data/lib/corefines/symbol.rb

@@ -0,0 +1,32 @@
+require 'corefines/support/alias_submodules'
+
+module Corefines
+  module Symbol
+
+    ##
+    # @!method call(*args, &block)
+    #   An useful extension for +&:symbol+ which makes it possible to pass
+    #   arguments for method in a block
+    #
+    #   @example
+    #     [1, 2, 3].map(&:to_s.(2)) #=> ['1', '10', '11']
+    #     %w[Chloe Drew Uma].map(&:gsub.('e', 'E')) #=> %w[ChloE DrEw Uma]
+    #
+    #   @param *args arguments being passed to the method.
+    #   @param block a block being passed to the method.
+    #   @return [Proc] a proc that invokes the method, identified by this
+    #     symbol and passing it the given arguments, on an object passed to it.
+    #
+    module Call
+      refine ::Symbol do
+        def call(*args, &block)
+          proc do |recv|
+            recv.__send__(self, *args, &block)
+          end
+        end
+      end
+    end
+
+    include Support::AliasSubmodules
+  end
+end

data/lib/corefines/version.rb

@@ -0,0 +1,3 @@
+module Corefines
+  VERSION = '1.0.0'
+end

data/lib/corefines.rb

@@ -0,0 +1,14 @@
+require 'corefines/version'
+require 'corefines/support/fake_refinements'
+
+# Refinements
+require 'corefines/array'
+require 'corefines/enumerable'
+require 'corefines/hash'
+require 'corefines/module'
+require 'corefines/object'
+require 'corefines/string'
+require 'corefines/symbol'
+
+# Provide an alternative, shorter, module name.
+CF = Corefines unless defined? CF

data/spec/array/second_spec.rb

@@ -0,0 +1,10 @@
+describe Array do
+  using Corefines::Array::second
+
+  describe '#second' do
+
+    it "returns the second element" do
+      expect(%w(a b c).second).to eq 'b'
+    end
+  end
+end

data/spec/array/third_spec.rb

@@ -0,0 +1,10 @@
+describe Array do
+  using Corefines::Array::third
+
+  describe '#third' do
+
+    it "returns the third element" do
+      expect(%w(a b c).third).to eq 'c'
+    end
+  end
+end

data/spec/enumerable/index_by_spec.rb

@@ -0,0 +1,13 @@
+describe Enumerable do
+  using Corefines::Enumerable::index_by
+
+  describe '#index_by' do
+
+    let(:input) { %w[alpha bee beta gamma] }
+    let(:expected) { {a: 'alpha', b: 'beta', g: 'gamma'} }
+
+    it "returns hash with the array's elements keyed be result of the block" do
+      expect(input.index_by { |s| s[0].to_sym }).to eq expected
+    end
+  end
+end

data/spec/enumerable/map_send_spec.rb

@@ -0,0 +1,24 @@
+describe Enumerable do
+  using Corefines::Enumerable::map_send
+
+  describe '#map_send' do
+
+    context Array do
+      it "sends a message to each element and collects the result" do
+        expect([1, 2, 3].map_send(:+, 3)).to eq [4, 5, 6]
+      end
+    end
+
+    context Hash do
+      it "sends a message to each element and collects the result" do
+        expect({a: 1, b: 2}.map_send(:at, 1)).to eq [1, 2]
+      end
+    end
+
+    context Set do
+      it "sends a message to each element and collects the result" do
+        expect(Set.new([1, 2, 3]).map_send(:+, 3)).to eq [4, 5, 6]
+      end
+    end
+  end
+end

data/spec/hash/compact_spec.rb

@@ -0,0 +1,48 @@
+describe Hash do
+  using Corefines::Hash::compact
+
+  let!(:original) { subject.dup }
+
+  describe '#compact' do
+
+    context "hash with some nil values" do
+      subject(:hash) { {a: true, b: false, c: nil, d: 'foo'} }
+
+      it "returns a new hash with no key-value pairs which value is nil" do
+        expect(hash.compact).to eq({a: true, b: false, d: 'foo'})
+        expect(hash).to eql original
+      end
+    end
+
+    context "hash with only nil values" do
+      subject(:hash) { {a: nil, b: nil} }
+
+      it "returns a new empty hash" do
+        expect(hash.compact).to be_empty
+        expect(hash).to eql original
+      end
+    end
+  end
+
+  describe '#compact!' do
+
+    context "hash with some nil values" do
+      subject(:hash) { {a: true, b: false, c: nil, d: 'foo'} }
+      let(:expected) { {a: true, b: false, d: 'foo'} }
+
+      it "removes key-value pairs which value is nil" do
+        expect(hash.compact!).to eq expected
+        expect(hash).to eq expected
+      end
+    end
+
+    context "hash with only nil values" do
+      subject(:hash) { {a: nil, b: nil} }
+
+      it "removes all key-value pairs" do
+        expect(hash.compact!).to be_empty
+        expect(hash).to be_empty
+      end
+    end
+  end
+end

data/spec/hash/op_plus_spec.rb

@@ -0,0 +1,11 @@
+describe Hash do
+  using Corefines::Hash::+
+
+  describe '#+' do
+    it 'merges hashes' do
+      a = {a: 1, b: 2}
+      b = {b: 3, c: 4}
+      expect(a + b).to eq({a: 1, b: 3, c: 4})
+    end
+  end
+end

data/spec/hash/rekey_spec.rb

@@ -0,0 +1,100 @@
+describe Hash do
+  using Corefines::Hash::rekey
+
+  let(:symbols) { {a: 1, b: 2, c: 3} }
+  let(:strings) { {'a' => 1, 'b' => 2, 'c' => 3} }
+  let(:mixed) { {'a' => 'foo', :b => 42, true => 66} }
+  let(:mixed_symbolized) { {:a => 'foo', :b => 42, true => 66} }
+
+  subject(:hash) { symbols }
+  let!(:original) { hash.dup }
+
+
+  describe '#rekey' do
+
+    context "with no arguments" do
+      subject(:hash) { mixed }
+
+      it "returns a new hash with symbolized keys" do
+        expect(hash.rekey).to eq mixed_symbolized
+        expect(hash).to eql original
+      end
+    end
+
+    context "with key_map" do
+      it "returns a new hash with translated keys" do
+        expect(hash.rekey(a: :x, c: 'y', d: 'z')).to eq({:x => 1, :b => 2, 'y' => 3})
+        expect(hash).to eql original
+      end
+    end
+
+    context "with block" do
+      it "yields key and value to the block" do
+        yielded = []
+        hash.rekey { |k, v| yielded << [k, v] }
+        expect(yielded).to eq [[:a, 1], [:b, 2], [:c, 3]]
+      end
+
+      it "returns a new hash with transformed keys" do
+        expect(hash.rekey { |k| k.to_s }).to eq strings
+        expect(hash).to eql original
+      end
+    end
+
+    context "with symbol proc" do
+      it "returns a new hash with transformed keys" do
+        expect(hash.rekey(&:to_s)).to eq strings
+        expect(hash).to eql original
+      end
+    end
+
+    context "with both key_map and block" do
+      it { expect { hash.rekey(a: 'x') { |k| k.to_s } }.to raise_error ArgumentError }
+    end
+  end
+
+
+  describe '#rekey!' do
+
+    context "with no arguments" do
+      subject(:hash) { mixed }
+
+      it "transforms keys to symbols and returns self" do
+        expect(hash.rekey!).to eq mixed_symbolized
+        expect(hash).to eq mixed_symbolized
+      end
+    end
+
+    context "with key_map" do
+      it "translates keys and returns self" do
+        expected = {:x => 1, :b => 2, 'y' => 3}
+        expect(hash.rekey!(a: :x, c: 'y', d: 'z')).to eq expected
+        expect(hash).to eq expected
+      end
+    end
+
+    context "with block" do
+      it "yields key and value to the block" do
+        yielded = []
+        hash.rekey! { |k, v| yielded << [k, v] }
+        expect(yielded).to eq [[:a, 1], [:b, 2], [:c, 3]]
+      end
+
+      it "transforms keys and returns self" do
+        expect(hash.rekey! { |k| k.to_s }).to eq strings
+        expect(hash).to eq strings
+      end
+    end
+
+    context "with symbol proc" do
+      it "transforms keys and returns self" do
+        expect(hash.rekey!(&:to_s)).to eq strings
+        expect(hash).to eq strings
+      end
+    end
+
+    context "with key_map and block" do
+      it { expect { hash.rekey!(a: 'x') { |k| k.to_s } }.to raise_error ArgumentError }
+    end
+  end
+end

data/spec/hash/symbolize_keys_spec.rb

@@ -0,0 +1,21 @@
+describe Hash do
+  using Corefines::Hash::symbolize_keys
+
+  subject(:mixed) { {'a' => 'foo', :b => 42, true => 66} }
+  let(:symbolized) { {:a => 'foo', :b => 42, true => 66} }
+  let!(:original) { mixed.dup }
+
+  describe '#symbolize_keys' do
+    it "returns a new hash with keys converted to symbols" do
+      expect(mixed.symbolize_keys).to eq symbolized
+      expect(mixed).to eql original
+    end
+  end
+
+  describe '#symbolize_keys!' do
+    it "converts keys to symbols" do
+      expect(mixed.symbolize_keys!).to eq symbolized
+      expect(mixed).to eq symbolized
+    end
+  end
+end

data/spec/module/alias_class_method_spec.rb

@@ -0,0 +1,21 @@
+describe Module do
+  using Corefines::Module::alias_class_method
+
+  describe '#alias_class_method' do
+
+    subject :klass do
+      Class.new do
+        def self.salute
+          'Meow!'
+        end
+      end
+    end
+
+    it "defines new class method that calls the old class method" do
+      klass.alias_class_method :say_hello!, :salute
+
+      expect(klass).to respond_to :say_hello!
+      expect(klass.say_hello!).to eq klass.salute
+    end
+  end
+end

data/spec/module/alias_method_chain_spec.rb

@@ -0,0 +1,76 @@
+describe Module do
+  using Corefines::Module::alias_method_chain
+
+  describe '#alias_method_chain' do
+
+    context "regular method" do
+
+      subject :obj do
+        Class.new {
+          def say; 'say' end
+          def say_with_accent; 'say_with_accent' end
+          alias_method_chain :say, :accent
+        }.new
+      end
+
+      it "defines method alias x_without_y -> x" do
+        expect(obj.say_without_accent).to eq 'say'
+      end
+
+      it "defines method alias x -> x_with_y" do
+        expect(obj.say).to eq 'say_with_accent'
+      end
+    end
+
+    context "method with punctuation" do
+
+      subject :obj do
+        Class.new {
+          def say!; 'say!' end
+          def say_with_accent!; 'say_with_accent!' end
+          alias_method_chain :say!, :accent
+        }.new
+      end
+
+      it "defines method alias x_without_y! -> x!" do
+        expect(obj.say_without_accent!).to eq 'say!'
+      end
+
+      it "defines method alias x! -> x_with_y!" do
+        expect(obj.say!).to eq 'say_with_accent!'
+      end
+    end
+
+    context "feature with punctuation" do
+
+      subject :obj do
+        Class.new {
+          def say; 'say' end
+          def say_with_accent?; 'say_with_accent?' end
+          alias_method_chain :say, :accent?
+        }.new
+      end
+
+      it "defines method alias x_without_y? -> x" do
+        expect(obj.say_without_accent?).to eq 'say'
+      end
+
+      it "defines method alias x -> x_with_y?" do
+        expect(obj.say).to eq 'say_with_accent?'
+      end
+    end
+
+
+    [:public, :protected, :private].each do |visibility|
+      it "preserves #{visibility} method visibility" do
+        klass = Class.new.class_eval <<-CLASS
+          def say; end
+          def say_with_accent; end
+          #{visibility} :say
+          alias_method_chain :say, :accent
+        CLASS
+        expect(klass.send("#{visibility}_method_defined?", :say)).to be true
+      end
+    end
+  end
+end

data/spec/object/blank_spec.rb

@@ -0,0 +1,128 @@
+# coding: utf-8
+using Corefines::Object::blank?
+
+describe Object do
+  let(:obj) { Object.new }
+
+  let :obj_empty do
+    Class.new { define_method(:empty?) { 0 } }.new
+  end
+
+  let :obj_not_empty do
+    Class.new { define_method(:empty?) { nil } }.new
+  end
+
+  describe '#blank?' do
+    it { expect(obj.blank?).to be false }
+
+    context "when object responds to #empty?" do
+      it "returns true when #empty? is truthy" do
+        expect(obj_empty.blank?).to be true
+      end
+
+      it "returns false when #empty? is falsy" do
+        expect(obj_not_empty.blank?).to be false
+      end
+    end
+  end
+
+  describe '#presence' do
+    it { expect(obj.presence).to be obj }
+
+    context "when object responds to #empty?" do
+      it "returns nil when #empty? is truthy" do
+        expect(obj_empty.presence).to be nil
+      end
+
+      it "returns caller when #empty? is falsy" do
+        expect(obj_not_empty.presence).to be obj_not_empty
+      end
+    end
+  end
+end
+
+describe NilClass do
+  describe '#blank?' do
+    it { expect(nil.blank?).to be true }
+  end
+
+  describe '#presence' do
+    it { expect(nil.presence).to be_nil }
+  end
+end
+
+describe FalseClass do
+  describe '#blank?' do
+    it { expect(false.blank?).to be true }
+  end
+
+  describe '#presence' do
+    it { expect(false.presence).to be_nil }
+  end
+end
+
+describe TrueClass do
+  describe '#blank?' do
+    it { expect(true.blank?).to be false }
+  end
+
+  describe '#presence' do
+    it { expect(true.presence).to be true }
+  end
+end
+
+describe Array do
+  describe '#blank?' do
+    it { expect([].blank?).to be true }
+    it { expect([1].blank?).to be false }
+  end
+
+  describe '#presence' do
+    it { expect([].presence).to be_nil }
+    it { expect([1].presence).to eq [1] }
+  end
+end
+
+describe Hash do
+  describe '#blank?' do
+    it { expect({}.blank?).to be true }
+    it { expect({x: 0}.blank?).to be false }
+  end
+
+  describe '#presence' do
+    it { expect({}.presence).to be_nil }
+    it { expect({x: 0}.presence).to eq({x: 0}) }
+  end
+end
+
+describe Numeric do
+  [ 0, 1, 1.1 ].each do |val|
+    describe '#blank?' do
+      it { expect(val.blank?).to be false }
+    end
+
+    describe '#presence' do
+      it { expect(val.presence).to be val }
+    end
+  end
+end
+
+describe String do
+  [ '', ' ', " \n\t \r ", '　', "\u00a0" ].each do |val|
+    describe '#blank?' do
+      it { expect(val.blank?).to be true }
+    end
+
+    describe '#presence' do
+      it { expect(val.presence).to be_nil }
+    end
+  end
+
+  describe '#blank?' do
+    it { expect('x'.blank?).to be false }
+  end
+
+  describe '#presence' do
+    it { expect('x'.presence).to eq 'x' }
+  end
+end