ensure_it 0.1.0

data/spec/lib/ensure_hash_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+class Tester
+  using EnsureIt if ENSURE_IT_REFINES
+
+  def ensure_hash(*args)
+    obj.ensure_hash(*args)
+  end
+
+  def ensure_hash!(*args)
+    obj.ensure_hash!(*args)
+  end
+end
+
+describe EnsureIt do
+  shared_examples 'hash parser' do
+    it 'and returns self for array' do
+      obj = {some: 0, 'key' => 1}
+      expect(call_for(obj)).to eq obj
+    end
+
+    it 'symbolizes keys with symbolize_keys option' do
+      obj = {some: 0, 'key' => 1, Object => 'strange'}
+      expect(call_for(obj, symbolize_keys: true)).to eq(some: 0, key: 1)
+    end
+  end
+
+  describe '#ensure_hash' do
+    it_behaves_like 'hash parser'
+    it_behaves_like 'empty hash creator for unmet objects', except: Hash
+
+    it 'and returns nil with wrong: nil option' do
+      expect(call_for(true, wrong: nil)).to be_nil
+      expect(call_for(true, wrong: 1)).to eq 1
+    end
+  end
+
+  describe '#ensure_hash!' do
+    it_behaves_like 'hash parser'
+    it_behaves_like(
+      'banger for unmet objects', except: Hash,
+      message: /should be a Hash/
+    )
+  end
+end

data/spec/lib/ensure_instance_of_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+class Tester
+  using EnsureIt if ENSURE_IT_REFINES
+
+  def ensure_instance_of(*args)
+    obj.ensure_instance_of(*args)
+  end
+
+  def ensure_instance_of!(*args)
+    obj.ensure_instance_of!(*args)
+  end
+end
+
+describe EnsureIt do
+  shared_examples 'instance selector' do
+    it 'and returns self for right instances' do
+      expect(call_for(:test, Symbol)).to eq :test
+      expect(call_for('test', String)).to eq 'test'
+    end
+
+    it 'and raises ArgumentError for wrong class' do
+      expect { call_for(:test, 1) }.to raise_error ArgumentError
+    end
+  end
+
+  describe '#ensure_instance_of' do
+    it_behaves_like 'instance selector'
+
+    it 'returns nil for wrong instances' do
+      expect(call_for(:test, String)).to be_nil
+      expect(call_for('test', Symbol)).to be_nil
+    end
+
+    it 'returns wrong option for wrong instances' do
+      expect(call_for(:test, String, wrong: 1)).to eq 1
+    end
+  end
+
+  describe '#ensure_instance_of!' do
+    it_behaves_like 'instance selector'
+
+    it 'raises on wrong instances and classes' do
+      expect {
+        call_for(:test, String)
+      }.to raise_error EnsureIt::Error, /should be an instance of .* class/
+    end
+  end
+end

data/spec/lib/ensure_integer_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+class Tester
+  using EnsureIt if ENSURE_IT_REFINES
+
+  def ensure_integer(*args)
+    obj.ensure_integer(*args)
+  end
+
+  def ensure_integer!(*args)
+    obj.ensure_integer!(*args)
+  end
+end
+
+describe EnsureIt do
+  shared_examples 'numerizer' do
+    it 'and returns self for Fixnum' do
+      obj = 1000
+      expect(call_for(obj)).to eq obj
+    end
+
+    it 'and returns self for Bignum' do
+      obj = BIGNUM
+      expect(call_for(obj)).to eq obj
+    end
+
+    it 'and converts decimal strings' do
+      expect(call_for('-100')).to eq(-100)
+    end
+
+    it 'and converts decimal strings with delimiter' do
+      expect(call_for('1_200')).to eq(1200)
+    end
+
+    it 'and converts hex strings' do
+      expect(call_for('0x0a')).to eq(10)
+    end
+
+    it 'and converts binary strings' do
+      expect(call_for('0b100')).to eq(4)
+    end
+
+    it 'and converts octal strings as decimal' do
+      expect(call_for('010')).to eq(10)
+    end
+
+    it 'and converts octal strings as octal with octal: true' do
+      expect(call_for('010', octal: true)).to eq(8)
+    end
+
+    it 'and rounds floats' do
+      expect(call_for(10.1)).to eq(10)
+      expect(call_for(10.5)).to eq(11)
+    end
+
+    it 'and converts rationales' do
+      expect(call_for(Rational(5, 2).to_r)).to eq(3)
+    end
+
+    it 'and converts boolean with :boolean option' do
+      expect(call_for(true, boolean: true)).to eq 1
+      expect(call_for(false, boolean: true)).to eq 0
+    end
+
+    it 'and converts boolean with numeric :boolean option' do
+      expect(call_for(true, boolean: 100)).to eq 100
+      expect(call_for(false, boolean: 100)).to eq 0
+    end
+  end
+
+  describe '#ensure_integer' do
+    it_behaves_like 'numerizer'
+    it_behaves_like(
+      'niller for unmet objects',
+      '123test', :test123, :'100',
+      except: [String, Symbol, Integer, Float, Rational]
+    )
+  end
+
+  describe '#ensure_integer!' do
+    it_behaves_like 'numerizer'
+    it_behaves_like(
+      'banger for unmet objects',
+      '123test', :test123, :'100',
+      except: [String, Symbol, Integer, Float, Rational],
+      message: /should be an integer or be able to convert to it/
+    )
+  end
+end

data/spec/lib/ensure_string_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+class Tester
+  using EnsureIt if ENSURE_IT_REFINES
+
+  def ensure_string(*args)
+    obj.ensure_string(*args)
+  end
+
+  def ensure_string!(*args)
+    obj.ensure_string!(*args)
+  end
+end
+
+describe EnsureIt do
+  shared_examples 'stringifier' do
+    it 'and returns self for string' do
+      obj = 'test'
+      expect(call_for(obj)).to eq obj
+    end
+
+    it 'and converts symbols to string' do
+      expect(call_for(:test)).to eq 'test'
+    end
+
+    it 'and converts numbers to string with :numbers option' do
+      expect(call_for(100, numbers: true)).to eq '100'
+      expect(call_for(0.5, numbers: true)).to eq '0.5'
+      expect(call_for(Rational(2, 3), numbers: true)).to eq '2/3'
+    end
+  end
+
+  describe '#ensure_string' do
+    it_behaves_like 'stringifier'
+    it_behaves_like 'niller for unmet objects', except: [String, Symbol]
+  end
+
+  describe '#ensure_string!' do
+    it_behaves_like 'stringifier'
+    it_behaves_like(
+      'banger for unmet objects',
+      except: [String, Symbol],
+      message: /should be a String or a Symbol/
+    )
+
+    it 'raises correct error message with :numbers option' do
+      expect { call_for(nil, numbers: true) }.to raise_error(
+        EnsureIt::Error,
+        /should be a String, Symbol, Numeric or Rational/
+      )
+    end
+  end
+end

data/spec/lib/ensure_symbol_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+class Tester
+  using EnsureIt if ENSURE_IT_REFINES
+
+  def ensure_symbol(*args)
+    obj.ensure_symbol(*args)
+  end
+
+  def ensure_symbol!(*args)
+    obj.ensure_symbol!(*args)
+  end
+end
+
+describe EnsureIt do
+  shared_examples 'symbolizer' do
+    it 'and returns self for symbol' do
+      expect(call_for(:test)).to eq :test
+    end
+
+    it 'and converts string to symbol' do
+      expect(call_for('test')).to eq :test
+    end
+  end
+
+  describe '#ensure_symbol' do
+    it_behaves_like 'symbolizer'
+    it_behaves_like 'niller for unmet objects', except: [String, Symbol]
+  end
+
+  describe '#ensure_symbol!' do
+    it_behaves_like 'symbolizer'
+    it_behaves_like(
+      'banger for unmet objects',
+      except: [String, Symbol],
+      message: /should be a Symbol or a String/
+    )
+  end
+end

data/spec/lib/errors_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe EnsureIt::Error do
+  it 'is StandardError' do
+    expect(described_class < StandardError).to be_true
+  end
+end
+
+describe EnsureIt do
+  describe '.raise_error' do
+    after { EnsureIt::Config.instance_variable_set(:@errors, nil) }
+
+    it 'raises EnsureIt::Error by default' do
+      expect {
+        call_error(:test_method)
+      }.to raise_error EnsureIt::Error
+    end
+
+    it 'raisesspecified error and message' do
+      expect {
+        call_error(:test_method, error: ArgumentError, message: 'test')
+      }.to raise_error ArgumentError, 'test'
+    end
+
+    it 'raises error with callers backtrace' do
+      backtrace = nil
+      begin
+        call_error(:test_method)
+      rescue EnsureIt::Error => e
+        backtrace = e.backtrace
+      end
+      expect(backtrace.first).to match(/\A#{__FILE__}:#{__LINE__ - 4}:/)
+    end
+
+    context 'standard errors' do
+      before { EnsureIt.config.errors :standard }
+    end
+
+    context 'smart errors' do
+      before { EnsureIt.config.errors :smart }
+
+      def test_unknown_caller
+        local = ''
+        local
+          .to_s; call_error(:to_s, message: '#{subject}')
+      end
+
+      def test_local_caller
+        local = ''
+        local.to_s; call_error(:to_s, message: '#{subject}')
+      end
+
+      def test_instance_caller
+        @instance = ''
+        @instance.to_s; call_error(:to_s, message: '#{subject}')
+      end
+
+      def test_class_caller
+        backup = $VERBOSE
+        $VERBOSE = nil
+        @@class = ''
+        @@class.to_s; call_error(:to_s, message: '#{subject}')
+      ensure
+        $VERBOSE = backup
+      end
+
+      def test_method_1_caller
+        local = ''
+        local.to_sym.to_s; call_error(:to_s, message: '#{subject}')
+      end
+
+      def test_method_2_caller
+        local = ''
+        local.to_sym().to_s; call_error(:to_s, message: '#{subject}')
+      end
+
+      def test_argument_1_caller(arg_1)
+        arg_1.to_s; call_error(:to_s, message: '#{subject}')
+      end
+
+      def test_argument_2_caller(*args)
+        args.to_s; call_error(:to_s, message: '#{subject}')
+      end
+
+      def test_argument_3_caller(arg_1 = 'test')
+        arg_1.to_s; call_error(:to_s, message: '#{subject}')
+      end
+
+      def test_argument_4_caller(arg_1: 'test')
+        arg_1.to_s; call_error(:to_s, message: '#{subject}')
+      end
+
+      def test_argument_5_caller(**opts)
+        opts.to_s; call_error(:to_s, message: '#{subject}')
+      end
+
+      def test_argument_6_caller(&block)
+        block.to_s; call_error(:to_s, message: '#{subject}')
+      end
+
+      {
+        unknown: %q{subject of 'to_s' method inside 'test_unknown_caller' method},
+        local: %q{local variable 'local' inside 'test_local_caller' method},
+        instance: %q{instance variable '@instance' inside 'test_instance_caller' method},
+        class: %q{class variable '@@class' inside 'test_class_caller' method},
+        method_1: %q{return value of 'to_sym' method inside 'test_method_1_caller' method},
+        method_2: %q{return value of method inside 'test_method_2_caller' method},
+        argument_1:  %q{argument 'arg_1' of 'test_argument_1_caller' method},
+        argument_2:  %q{argument '*args' of 'test_argument_2_caller' method},
+        argument_3:  %q{optional argument 'arg_1' of 'test_argument_3_caller' method},
+        argument_4:  %q{key argument 'arg_1' of 'test_argument_4_caller' method},
+        argument_5:  %q{key argument '**opts' of 'test_argument_5_caller' method},
+        argument_6:  %q{block argument '&block' of 'test_argument_6_caller' method},
+      }.each do |var, message|
+        it "finds #{var} name" do
+          m = method("test_#{var}_caller")
+          args = [true] * (m.arity < 0 ? -m.arity - 1 : m.arity)
+          error = get_error { m.call(*args) }
+          expect(error.message).to eq message
+        end
+      end
+    end
+  end
+end

data/spec/lib/patch_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+class PatchTestClass; end
+module PatchTestWrapper; end
+
+describe EnsureIt do
+  describe '::patch' do
+    it 'is private' do
+      expect { EnsureIt.patch(PatchTestClass) {} }.to raise_error NoMethodError
+    end
+
+    it 'includes methods to object' do
+      expect { PatchTestWrapper.obj.test_method }.to raise_error NoMethodError
+      EnsureIt.send(:patch, PatchTestClass, &proc do
+        def test_method
+          'test result'
+        end
+      end)
+      result =
+        if ENSURE_IT_REFINES
+          PatchTestWrapper.module_eval do
+            using EnsureIt
+            PatchTestClass.new.test_method
+          end
+        else
+          PatchTestClass.new.test_method
+        end
+      expect(result).to eq 'test result'
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+#require 'coveralls'
+#Coveralls.wear!
+
+if ENV['USE_REFINES'] == 'true'
+  require 'ensure_it_refines'
+else
+  require 'ensure_it'
+end
+
+Dir[File.join(File.dirname(__FILE__), 'support', '**', '*.rb')].each do |file|
+  require file
+end
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.order = 'random'
+end

data/spec/support/example_groups/ensure_it_example_group.rb

@@ -0,0 +1,66 @@
+#
+# Helpers for ensure_it testing
+#
+# @author Alexey Ovchinnikov <alexiss@cybernetlab.ru>
+#
+
+class Tester
+  attr_reader :obj
+
+  def initialize(obj)
+    @obj = obj
+  end
+end
+
+module EnsureItExampleGroup
+  def self.fake_method; end
+
+  def self.included(base)
+    base.instance_eval do
+      metadata[:type] = :ensure_it
+    end
+  end
+
+  def general_objects(&block)
+    enum = GENERAL_OBJECTS.each
+    enum.define_singleton_method :except do |*classes|
+      classes = classes.flatten.select { |x| x.is_a?(Class) }
+      reject { |obj| classes.any? { |c| obj.is_a?(c) } }
+    end
+    block_given? ? enum.each(&block) : enum
+  end
+
+  def described_method
+    group = example.metadata[:example_group]
+    while group do
+      break if group[:description][0] == '#'
+      group = group[:example_group]
+    end
+    if group.nil?
+      raise RuntimeError, 'No description, containing method name founded'
+    end
+    group[:description][1..-1].to_sym
+  end
+
+  def call_for(obj, *args)
+    Tester.new(obj).send(described_method, *args)
+  end
+
+  def call_error(method_name, **opts)
+    EnsureIt.raise_error(method_name, **opts)
+  end
+
+  def get_error
+    yield
+  rescue EnsureIt::Error => e
+    e
+  end
+
+  RSpec.configure do |config|
+    config.include(
+      self,
+      type: :ensure_it,
+      example_group: { file_path: /spec\/lib/ }
+    )
+  end
+end

data/spec/support/matchers/warn_matcher.rb

@@ -0,0 +1,30 @@
+RSpec::Matchers.define :warn do |message|
+  match do |block|
+    output = capture_stderr(&block)
+    message.is_a?(Regexp) ? message.match(output) : output.include?(message)
+  end
+
+  description do
+    "warn with message \"#{message}\""
+  end
+
+  failure_message_for_should do
+    "expected to #{description}"
+  end
+
+  failure_message_for_should_not do
+    "expected to not #{description}"
+  end
+
+  # Fake STDERR and return a string written to it.
+  def capture_stderr(&block)
+    original_stderr = $stderr
+    $stderr = fake = StringIO.new
+    begin
+      yield
+    ensure
+      $stderr = original_stderr
+    end
+    fake.string
+  end
+end

data/spec/support/shared_examples/unmet_objects.rb

@@ -0,0 +1,60 @@
+#using EnsureIt if ENSURE_IT_REFINES
+
+def fake_method; end
+
+FIXNUM_MAX = (2 ** (0.size * 8 - 2) - 1)
+BIGNUM = FIXNUM_MAX + 100
+FIXNUM = FIXNUM_MAX - 100
+GENERAL_OBJECTS = [
+  [], {}, FIXNUM, BIGNUM, 0.1, true, false, nil, 0..5,
+  '2/3'.to_r, /regexp/, 'string', :symbol,
+  ->{}, proc {}, method(:fake_method),
+  Object.new, Class.new, Module.new, Struct.new(:field), Time.new
+]
+
+def compose_objects(add, except)
+  except = [except] unless except.is_a?(Array)
+  add = [add] unless add.is_a?(Array)
+  except = except.flatten.select { |x| x.is_a?(Class) }
+  objects = GENERAL_OBJECTS.reject { |obj| except.any? { |c| obj.is_a?(c) } }
+  objects.concat(add)
+end
+
+shared_examples 'niller for unmet objects' do |*add, except: []|
+  it 'returns nil' do
+    expect(
+      compose_objects(add, except).map { |x| call_for(x) }.compact
+    ).to be_empty
+  end
+end
+
+shared_examples 'empty array creator for unmet objects' do |*add, except: []|
+  it 'returns empty array' do
+    compose_objects(add, except).each do |obj|
+      expect(call_for(obj)).to eq []
+    end
+  end
+end
+
+shared_examples 'empty hash creator for unmet objects' do |*add, except: []|
+  it 'returns empty array' do
+    compose_objects(add, except).each do |obj|
+      expect(call_for(obj)).to eq({})
+    end
+  end
+end
+
+shared_examples 'banger for unmet objects' do |*add, except: [], **opts|
+  it 'raises error' do
+    objects = compose_objects(add, except)
+    expect(EnsureIt).to receive(:raise_error)
+      .exactly(objects.size).times.and_call_original
+    err = [opts[:error] || EnsureIt::Error]
+    err << opts[:message] if opts.key?(:message)
+    objects.each do |obj|
+      expect {
+        call_for(obj)
+      }.to raise_error(*err)
+    end
+  end
+end