corefines 1.0.0

data/spec/object/deep_dup_spec.rb

@@ -0,0 +1,61 @@
+describe Object do
+  using Corefines::Object::deep_dup
+
+  describe '#deep_dup' do
+
+    it "duplicates array and its values" do
+      ary = ['foo', 'bar']
+      dup = ary.deep_dup
+      dup[1].prepend('x')
+
+      expect(dup).to_not be ary
+      expect(ary[1]).to eq 'bar'
+      expect(dup[1]).to eq 'xbar'
+    end
+
+    it "duplicates values inside a nested array" do
+      ary = ['foo', ['bar', 'baz']]
+      dup = ary.deep_dup
+      dup[1][0].prepend('x')
+
+      expect(ary[1][0]).to eq 'bar'
+      expect(dup[1][0]).to eq 'xbar'
+    end
+
+    it "duplicates a nested hash" do
+      hash = {a: {b: 'b'}}
+      dup = hash.deep_dup
+      dup[:a][:c] = 'c'
+
+      expect(hash[:a][:c]).to be_nil
+      expect(dup[:a][:c]).to eq 'c'
+    end
+
+    it "duplicates an object" do
+      obj = ::Object.new
+      dup = obj.deep_dup
+      dup.instance_variable_set(:@a, 1)
+
+      expect(obj.instance_variable_defined? :@a).to be_falsy
+      expect(dup.instance_variable_defined? :@a).to be_truthy
+    end
+
+    it "calls #deep_dup on nested object when it responds to it" do
+      obj = Object.new.instance_eval do
+        def deep_dup; 'foo' end
+        self
+      end
+      ary = [1, obj]
+      dup = ary.deep_dup
+
+      expect(ary[1]).to eql obj
+      expect(dup[1]).to eq 'foo'
+    end
+
+    it "doesn't raise error for non-duplicable object" do
+      [nil, false, true, :foo, 1.0, method(:to_s)].each do |obj|
+        expect { obj.deep_dup }.to_not raise_error
+      end
+    end
+  end
+end

data/spec/object/else_spec.rb

@@ -0,0 +1,24 @@
+describe Object do
+  using Corefines::Object::else
+
+  describe '#else' do
+
+    it "returns self without calling the block" do
+      obj = 'yay'
+      expect(obj.else { fail }).to eql obj
+    end
+
+    [ nil, false ].each do |val|
+      context "called on #{val.nil? ? 'nil' : val}" do
+
+        it "calls the block and returns result" do
+          expect(val.else { 42 }).to eq 42
+        end
+
+        it "passes self to the block" do
+          val.else { |x| expect(x).to eql val }
+        end
+      end
+    end
+  end
+end

data/spec/object/in_spec.rb

@@ -0,0 +1,21 @@
+describe Object do
+  using Corefines::Object::in?
+
+  describe '#in?' do
+    let(:other) { [] }
+
+    it "returns true when argument includes self" do
+      expect(other).to receive(:include?).with(42).and_return(true)
+      expect(42.in? other).to be true
+    end
+
+    it "returns false when argument doesn't include self" do
+      expect(other).to receive(:include?).with(66).and_return(false)
+      expect(66.in? other).to be false
+    end
+
+    it "raises ArgumentError when argument doesn't respond #include?" do
+      expect { 66.in? Object.new }.to raise_error ArgumentError
+    end
+  end
+end

data/spec/object/instance_values_spec.rb

@@ -0,0 +1,22 @@
+describe Object do
+  using Corefines::Object::instance_values
+
+  describe '#instance_values' do
+    let :obj do
+      Object.new.tap do |o|
+        o.instance_variable_set(:@foo, 'first')
+        o.instance_variable_set(:@bar, 'second')
+      end
+    end
+
+    it "returns hash that maps instance variables to their values" do
+      expect(obj.instance_values).to eq({foo: 'first', bar: 'second'})
+    end
+
+    context "no instance variables" do
+      it "returns an empty array" do
+        expect(''.instance_values).to be_empty
+      end
+    end
+  end
+end

data/spec/object/then_if_spec.rb

@@ -0,0 +1,64 @@
+describe Object do
+  using Corefines::Object::then_if
+
+  describe '#then_if' do
+
+    shared_examples 'conditions evaluates to true' do |*conditions|
+      it "yields self to the block and returns that block's value" do
+        expect('yay'.then_if(*conditions) { |x| x + '!' }).to eq 'yay!'
+      end
+    end
+
+    shared_examples 'conditions evaluates to false' do |*conditions|
+      it "returns self without calling the block" do
+        obj = 'yay'
+        expect(obj.then_if(*conditions) { fail 'block should not be called' }).to eql obj
+      end
+    end
+
+
+    context "no conditions given" do
+
+      context "and self evaluates to true" do
+        it_behaves_like 'conditions evaluates to true'
+      end
+
+      context "and self evaluates to false" do
+        [ false, nil ].each do |val|
+          it "returns self without calling the block" do
+            expect(val.then_if { fail 'block should not be called' }).to eql val
+          end
+        end
+      end
+    end
+
+    [ :ascii_only?, [:start_with?, 'y'], ->(x) { x.start_with? 'y' },
+      :ascii_only?.to_proc, true, 'foo'
+    ].each do |condition|
+      context "with #{condition.class} condition" do
+        include_examples 'conditions evaluates to true', condition
+      end
+    end
+
+    [ :empty?, [:start_with?, 'x'], ->(x) { x.start_with? 'x' },
+      :empty?.to_proc, false, nil
+    ].each do |condition|
+      context "with #{condition.class} condition that evaluates to true" do
+        include_examples 'conditions evaluates to false', condition
+      end
+    end
+
+    context "with multiple conditions" do
+
+      context "all evaluates to true" do
+        conditions = [ true, [:start_with?, 'y'], :ascii_only? ]
+        include_examples 'conditions evaluates to true', *conditions
+      end
+
+      context "one evaluates to false" do
+        conditions = [ true, [:start_with?, 'y'], false, :ascii_only? ]
+        include_examples 'conditions evaluates to false', *conditions
+      end
+    end
+  end
+end

data/spec/object/then_spec.rb

@@ -0,0 +1,26 @@
+describe Object do
+  using Corefines::Object::then
+
+  describe '#then' do
+
+    it "calls the block and returns result" do
+      expect('yay'.then { 42 }).to eq 42
+    end
+
+    it "passes self to the block" do
+      'yay'.then { |x| expect(x).to eq 'yay' }
+    end
+
+    context "called on nil" do
+      it "returns nil without calling the block" do
+        expect(nil.then { fail }).to be_nil
+      end
+    end
+
+    context "called on false" do
+      it "returns false without calling the block" do
+        expect(false.then { fail }).to be false
+      end
+    end
+  end
+end

data/spec/object/try_spec.rb

@@ -0,0 +1,47 @@
+describe Object do
+  using Corefines::Object::try
+
+  let(:str) { "allons-y!" }
+
+  describe '#try' do
+    context "non-existing method" do
+      it "returns nil" do
+        expect(str.try(:non_existing_method)).to be_nil
+      end
+    end
+
+    context "valid method" do
+      it "calls and returns the result" do
+        expect(str.try(:upcase)).to eq "ALLONS-Y!"
+      end
+
+      it "forwards arguments" do
+        expect(str.try(:sub, '!', '?')).to eq "allons-y?"
+      end
+
+      it "forwards block" do
+        expect(str.try(:sub, '!') { |m| '?' }).to eq "allons-y?"
+      end
+    end
+
+    context "on nil" do
+      it "returns nil" do
+        expect(nil.try(:upcase)).to be_nil
+      end
+    end
+
+    context "on false" do
+      it "calls and returns the result" do
+        expect(false.try(:to_s)).to eq 'false'
+      end
+    end
+  end
+
+  describe '#try!' do
+    context "non-existing method" do
+      it "raises NoMethodError" do
+        expect { str.try!(:non_existing_method) }.to raise_error NoMethodError
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+require 'simplecov'
+require 'corefines'
+
+RSpec.configure do |config|
+
+  # rspec-expectations config
+  config.expect_with :rspec do |expects|
+
+    # This option disables deprecated 'should' syntax.
+    expects.syntax = :expect
+
+    # This option makes the +description+ and +failure_message+ of custom
+    # matchers include text for helper methods defined using +chain+, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expects.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config
+  config.mock_with :rspec do |mocks|
+
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object.
+    mocks.verify_partial_doubles = true
+  end
+
+  config.color = true
+end

data/spec/string/color_spec.rb

@@ -0,0 +1,82 @@
+describe String do
+  using Corefines::String::color
+
+  describe '#color' do
+
+    shared_examples :defaults do |opts|
+      it "returns text with the default mode, foreground and background colors" do
+        expect(text.color(opts)).to eq "\e[0;39;49m#{text}\e[0m"
+      end
+    end
+
+    subject(:text) { "This is\nsome text" }
+
+    context Symbol do
+      it "returns text with the specified foreground color" do
+        expect(text.color(:blue)).to eq "\e[0;34;49m#{text}\e[0m"
+      end
+
+      context "unknown color name" do
+        include_examples :defaults, :foo
+      end
+    end
+
+    context Fixnum do
+      it "returns text with the specified foreground color" do
+        expect(text.color(7)).to eq "\e[0;37;49m#{text}\e[0m"
+      end
+    end
+
+    context Hash do
+
+      context "empty" do
+        include_examples :defaults, {}
+      end
+
+      context "with unknown mode and color names" do
+        include_examples :defaults, {mode: :foo, text: :foo, background: :foo}
+      end
+
+      context "with valid options" do
+        it "returns text with the specified mode" do
+          [:bold, 1].each do |mode|
+            expect(text.color(mode: mode)).to eq "\e[1;39;49m#{text}\e[0m"
+          end
+        end
+
+        it "returns text with the specified foreground color" do
+          [:red, 1].each do |color|
+            expect(text.color(text: color)).to eq "\e[0;31;49m#{text}\e[0m"
+          end
+        end
+
+        it "returns text with the specified background color" do
+          [:green, 2].each do |color|
+            expect(text.color(background: color)).to eq "\e[0;39;42m#{text}\e[0m"
+          end
+        end
+
+        it "returns text with the specified mode, foreground and background colors" do
+          expect(text.color(mode: :bold, text: :blue, background: :yellow)).to eq "\e[1;34;43m#{text}\e[0m"
+          expect(text.color(mode: 1, text: 4, background: 3)).to eq "\e[1;34;43m#{text}\e[0m"
+        end
+      end
+    end
+
+    context "already colored text" do
+      it "changes specified and preserves unspecified attributes" do
+        expect("\e[1;34;42m#{text}\e[0m".color(text: :red)).to eq "\e[1;31;42m#{text}\e[0m"
+      end
+
+      it "doesn't change invalidly specified attributes" do
+        expect("\e[1;34;42m#{text}\e[0m".color(text: :foo)).to eq "\e[1;34;42m#{text}\e[0m"
+      end
+
+      it "changes multiple escape sequences" do
+        text = 'none' + 'red'.color(:red) + 'none' + 'blue'.color(:blue) + 'none'
+        expected = "\e[0;39;42mnone\e[0m\e[0;31;42mred\e[0m\e[0;39;42mnone\e[0m\e[0;34;42mblue\e[0m\e[0;39;42mnone\e[0m"
+        expect(text.color(background: :green)).to eq expected
+      end
+    end
+  end
+end

data/spec/string/concat_spec.rb

@@ -0,0 +1,36 @@
+describe String do
+  using Corefines::String::concat!
+
+  describe '#concat!' do
+
+    context "without separator" do
+      subject { 'foo' }
+
+      it "appends the given string to self" do
+        subject.concat! 'bar'
+        is_expected.to eq 'foobar'
+      end
+    end
+
+    context "with separator" do
+
+      context "when self is empty" do
+        subject { '' }
+
+        it "appends the given string to self" do
+          subject.concat! 'bar', "\n"
+          is_expected.to eq 'bar'
+        end
+      end
+
+      context "when self is not empty" do
+        subject { 'foo' }
+
+        it "appends the given separator and string to self" do
+          subject.concat! 'bar', "\n"
+          is_expected.to eq "foo\nbar"
+        end
+      end
+    end
+  end
+end

data/spec/string/decolor_spec.rb

@@ -0,0 +1,27 @@
+describe String do
+  using Corefines::String::decolor
+
+  describe '#decolor' do
+
+    subject(:text) { "This is\nsome text" }
+
+    context "colored text" do
+      it "strips ANSI escape sequence" do
+        expect("\e[1;34;42m#{text}\e[0m".decolor).to eq text
+      end
+    end
+
+    context "concatenated colored texts" do
+      it "strips all ANSI escape sequences" do
+        text = "\e[0;39;42mSome\ncolored\e[0m\e[0;31;42m text\e[0m"
+        expect(text.decolor).to eq "Some\ncolored text"
+      end
+    end
+
+    context "plain string" do
+      it "passes without change" do
+        expect(text.decolor).to eq text
+      end
+    end
+  end
+end

data/spec/string/remove_spec.rb

@@ -0,0 +1,57 @@
+describe String do
+  using Corefines::String::remove
+
+  subject(:str) { "This is a good day to die" }
+  let!(:original) { str.dup }
+
+  describe '#remove' do
+
+    context "string" do
+      it "returns a new string with occurrences of the pattern removed" do
+        expect(str.remove(" to die")).to eq "This is a good day"
+        expect(str.remove("is")).to eq "Th  a good day to die"
+        expect(str).to eq original
+      end
+    end
+
+    context "regexp" do
+      it "returns a new string with occurrences of the pattern removed" do
+        expect(str.remove(/\s*to.*$/)).to eq "This is a good day"
+        expect(str.remove(/\s/)).to eq "Thisisagooddaytodie"
+        expect(str).to eq original
+      end
+    end
+
+    context "multiple patterns" do
+      it "returns a new string with occurrences of the patterns removed" do
+        expect(str.remove("to die", /\s*$/)).to eq "This is a good day"
+        expect(str.remove("to", "die", /\s*/)).to eq "Thisisagoodday"
+        expect(str).to eq original
+      end
+    end
+  end
+
+  describe '#remove!' do
+
+    context "string" do
+      it "removes occurrences of the pattern and returns self" do
+        expect(str.remove!(" to die")).to eq "This is a good day"
+        expect(str.remove!("is")).to eq "Th  a good day"
+      end
+    end
+
+    context "regexp" do
+      it "removes occurrences of the pattern and returns self" do
+        expect(str.remove!(/\s*to.*$/)).to eq "This is a good day"
+        expect(str.remove!(/\s/)).to eq "Thisisagoodday"
+      end
+    end
+
+    context "multiple patterns" do
+      it "removes occurrences of the patterns and returns self" do
+        expect(str.remove!("to die", /\s*$/)).to eq "This is a good day"
+        expect(str.remove!("to", "die", /\s*/)).to eq "Thisisagoodday"
+      end
+    end
+  end
+end

data/spec/string/unindent_spec.rb

@@ -0,0 +1,66 @@
+describe String do
+  using Corefines::String::unindent
+
+  describe '#unindent' do
+
+    context "single-line" do
+
+      it "removes space indentation" do
+        expect("  abc".unindent).to eq 'abc'
+      end
+
+      it "removes tab indentation" do
+        expect("\tabc".unindent).to eq 'abc'
+      end
+
+      it "removes mixed space and tab indentation" do
+        expect("\t\s\t\sabc".unindent).to eq 'abc'
+      end
+    end
+
+    context "multi-line" do
+
+      it "removes indentation" do
+        expect(" abc\n abc".unindent).to eq "abc\nabc"
+      end
+
+      it "keeps relative indentation" do
+        expect("  abc\n abc".unindent).to eq " abc\nabc"
+      end
+
+      it "ignores blank lines for indent calculation" do
+        expect("\n\tabc\n\n\t\tabc\n".unindent).to eq "\nabc\n\n\tabc\n"
+      end
+
+      it "unindents more complex input" do
+        input = <<-EOF
+          module WishScanner
+
+            def scan_for_a_wish
+              wish = self.read.detect do |thought|
+                thought.index('wish: ') == 0
+              end
+
+              wish.gsub('wish: ', '')
+            end
+          end
+        EOF
+
+        expected = <<-EOF
+module WishScanner
+
+  def scan_for_a_wish
+    wish = self.read.detect do |thought|
+      thought.index('wish: ') == 0
+    end
+
+    wish.gsub('wish: ', '')
+  end
+end
+        EOF
+
+        expect(input.unindent).to eq expected
+      end
+    end
+  end
+end

data/spec/support/alias_submodules_spec.rb

@@ -0,0 +1,83 @@
+describe Corefines::Support::AliasSubmodules do
+
+  before :context do
+    # Define dynamically to not pollute global context of other tests.
+    ModuleX = Module.new.tap do |m|
+      m.class_eval <<-CODE
+        Something = 66
+        module Indent end
+        module StripHeredoc end
+        module Blank end
+        include Corefines::Support::AliasSubmodules
+      CODE
+    end
+  end
+
+  after :context do
+    Object.send(:remove_const, :ModuleX)
+  end
+
+
+  describe '.included' do
+
+    subject(:target) { ModuleX }
+
+    it 'defines method-named "alias" for each submodule' do
+      expect(ModuleX.indent).to eql ModuleX::Indent
+      expect(ModuleX::strip_heredoc).to eql ModuleX::StripHeredoc
+    end
+
+    it "ignores constants that are not modules" do
+      is_expected.to_not respond_to :something
+    end
+
+    it "includes all submodules into the target" do
+      is_expected.to include ModuleX::Indent, ModuleX::StripHeredoc
+    end
+  end
+
+
+  describe '.[]' do
+    subject { ModuleX[:indent, :strip_heredoc] }
+
+    it "returns module that includes the named modules" do
+      is_expected.to be_instance_of ::Module
+      is_expected.to include ModuleX::Indent, ModuleX::StripHeredoc
+      is_expected.to_not include ModuleX::Blank
+    end
+
+    it "raises ArgumentError if any submodule alias doesn't exist" do
+      expect { ModuleX[:indent, :invalid] }.to raise_error ArgumentError
+    end
+  end
+
+
+  describe '.method_name' do
+
+    def method_name(str)
+      described_class.send(:method_name, str)
+    end
+
+    it "string without any uppercase returns untouched" do
+      str = 'allonsy!'
+      expect(method_name str).to eql str
+    end
+
+    {
+      'Unindent' => 'unindent',
+      'StripHeredoc' => 'strip_heredoc',
+      'ToJSON' => 'to_json',
+    }.merge(described_class.const_get(:OPERATORS_MAP)).each do |input, expected|
+
+      it "converts '#{input}' to '#{expected}'" do
+        input_clone = input.to_s.dup
+        expect(method_name input).to eq expected
+        expect(input.to_s).to eql input_clone
+      end
+
+      it "converts :#{input} to '#{expected}'" do
+        expect(method_name input.to_sym).to eq expected
+      end
+    end
+  end
+end

data/spec/support/classes_including_module_spec.rb

@@ -0,0 +1,35 @@
+require 'corefines/support/classes_including_module'
+require 'forwardable'
+
+describe Corefines::Support do
+
+  describe '.classes_including_module' do
+    extend Forwardable
+
+    def_delegator :described_class, :classes_including_module
+
+    before :context do
+      ModuleX, ModuleY = Module.new, Module.new
+      ClassA, ClassB = Class.new, Class.new(Array)
+      [ClassA, ClassB].each { |m| m.send(:include, ModuleX) }
+    end
+
+    after :context do
+      [:ModuleX, :ModuleY, :ClassA, :ClassB].each do |name|
+        Object.send(:remove_const, name)
+      end
+    end
+
+    it "yields classes that includes the module" do
+      actual = []
+      classes_including_module(ModuleX) { |c| actual << c }
+      expect(actual).to contain_exactly ClassA, ClassB
+    end
+
+    it "yields nothing for module that isn't included anywhere" do
+      actual = []
+      classes_including_module(ModuleY) { |c| actual << c }
+      expect(actual).to be_empty
+    end
+  end
+end