ensure_it 0.1.1 → 0.1.2

data/lib/tasks/ensure_it_benchmark.thor

@@ -0,0 +1,243 @@
+require 'benchmark'
+
+if ENV['USE_REFINES'] == 'true'
+  ENSURE_IT_REFINED = true
+end
+
+module EnsureIt
+  class Benchmark < Thor
+    OBJECTS = [
+      nil, true, false, 0, 0.1, '1/3'.to_r, 'test', :test, Object, Class, ->{}
+    ]
+
+    class_option :smart, aliases: '-s', desc: 'use smart errors'
+    class_option :count, aliases: '-n', desc: 'number of tests', default: 10000
+    class_option :profile, aliases: '-p', desc: 'profile'
+
+    desc 'symbol', 'runs benchmarks for ensure_symbol'
+    def symbol
+      run_benchmark :symbol, ensure_proc: ->(x) { x.ensure_symbol } do |x|
+        x = x.to_sym if x.is_a?(String)
+        x.is_a?(Symbol) ? x : nil
+      end
+    end
+
+    desc 'symbol!', 'runs benchmarks for ensure_symbol!'
+    def symbol!
+      run_benchmark :symbol!, ensure_proc: ->(x) { x.ensure_symbol! } do |x|
+        x = x.to_sym if x.is_a?(String)
+        raise ArgumentError unless x.is_a?(Symbol)
+      end
+    end
+
+    desc 'string', 'runs benchmarks for ensure_string'
+    def string
+      run_benchmark :string, ensure_proc: ->(x) { x.ensure_string } do |x|
+        x = x.to_s if x.is_a?(Symbol)
+        x.is_a?(String) ? x : nil
+      end
+    end
+
+    desc 'string!', 'runs benchmarks for ensure_string!'
+    def string!
+      run_benchmark :string!, ensure_proc: ->(x) { x.ensure_string! } do |x|
+        x = x.to_s if x.is_a?(Symbol)
+        raise ArgumentError unless x.is_a?(String)
+      end
+    end
+
+    desc 'integer', 'runs benchmarks for ensure_integer'
+    def integer
+      run_benchmark :integer, ensure_proc: ->(x) { x.ensure_integer } do |x|
+        if x.is_a?(Integer)
+          x
+        elsif x.is_a?(Float) || x.is_a?(Rational)
+          x.round
+        elsif x.is_a?(String)
+          case x
+          when ::EnsureIt::INT_REGEXP then x.to_i
+          when ::EnsureIt::HEX_REGEXP then x[2..-1].to_i(16)
+          when ::EnsureIt::BIN_REGEXP then x[2..-1].to_i(2)
+          else nil
+          end
+        else
+          nil
+        end
+      end
+    end
+
+    desc 'integer!', 'runs benchmarks for ensure_integer!'
+    def integer!
+      run_benchmark :integer!, ensure_proc: ->(x) { x.ensure_integer! } do |x|
+        if x.is_a?(Integer)
+          x
+        elsif x.is_a?(Float) || x.is_a?(Rational)
+          x.round
+        elsif x.is_a?(String)
+          case x
+          when ::EnsureIt::INT_REGEXP then x.to_i
+          when ::EnsureIt::HEX_REGEXP then x[2..-1].to_i(16)
+          when ::EnsureIt::BIN_REGEXP then x[2..-1].to_i(2)
+          else raise ArgumentError
+          end
+        else
+          raise ArgumentError
+        end
+      end
+    end
+
+    desc 'float', 'runs benchmarks for ensure_float'
+    def float
+      run_benchmark :float, ensure_proc: ->(x) { x.ensure_float } do |x|
+        if x.is_a?(Float)
+          x
+        elsif x.is_a?(Numeric) ||
+              x.is_a?(String) && ::EnsureIt::FLOAT_REGEXP =~ x
+          x.to_f
+        else
+          nil
+        end
+      end
+    end
+
+    desc 'float!', 'runs benchmarks for ensure_float!'
+    def float!
+      run_benchmark :float!, ensure_proc: ->(x) { x.ensure_float! } do |x|
+        if x.is_a?(Float)
+          x
+        elsif x.is_a?(Numeric) ||
+              x.is_a?(String) && ::EnsureIt::FLOAT_REGEXP =~ x
+          x.to_f
+        else
+          raise ArgumentError
+        end
+      end
+    end
+
+    desc 'non_bang', 'runs all non-bang benchmarks'
+    def non_bang
+      invoke(:symbol)
+      invoke(:string)
+      invoke(:integer)
+      invoke(:float)
+    end
+
+    desc 'bang', 'runs all bang benchmarks'
+    def bang
+      invoke(:symbol!)
+      invoke(:string!)
+      invoke(:integer!)
+      invoke(:float!)
+    end
+
+    desc 'all', 'runs all benchmarks'
+    def all
+      invoke(:non_bang)
+      invoke(:bang)
+    end
+
+    no_commands do
+      protected
+
+      def run_benchmark(task_name, ensure_proc: proc {}, &standard_proc)
+        load_ensure_it
+        ensure_it, standard = [], []
+        start_task(task_name)
+        ::Benchmark.benchmark do |x|
+          start_profile(task_name)
+          ensure_it = x.report('ensure_it:    ') do
+            OBJECTS.each do |obj|
+              count.times { ensure_proc.call(obj) rescue ::EnsureIt::Error }
+            end
+          end
+          standard = x.report('standard way: ') do
+            OBJECTS.each do |obj|
+              count.times { standard_proc.call(obj) rescue ArgumentError }
+            end
+          end
+          end_profile(task_name)
+        end
+        end_task(task_name)
+        [ensure_it, standard]
+      end
+
+      def start_task(task_name)
+        text = "Starting benchmarks for #ensure_#{task_name} "
+        if ENSURE_IT_REFINED == true
+          text << ' with refined version of EnsureIt.'
+        else
+          text << ' with monkey-patched version of EnsureIt.'
+        end
+        text << " Errors: #{::EnsureIt.config.errors}."
+        text << " Ruby version: #{RUBY_VERSION}"
+        say text, :green
+      end
+
+      def end_task(task_name); end
+
+      def start_profile(task_name)
+        RubyProf.start if profile?
+      end
+
+      def end_profile(task_name)
+        if profile?
+          result = RubyProf.stop
+          result.eliminate_methods!([
+            /\ABenchmark/,
+            /Thor::(?!Sandbox::EnsureIt::Benchmark#run_benchmark)/,
+            /Integer#times/, /Struct::Tms/, /<Module::Process>/,
+            /<Class::Time>/, /Time/
+          ])
+          file = File.join(profile_path, "ensure_#{task_name}.dot")
+          unless Dir.exist?(File.dirname(file))
+            FileUtils.mkpath File.dirname(file)
+          end
+          printer = RubyProf::DotPrinter.new(result)
+          File.open(file, 'w') { |f| printer.print(f, min_percent: 0) }
+          file = File.join(profile_path, "ensure_#{task_name}.txt")
+          printer = RubyProf::GraphPrinter.new(result)
+          File.open(file, 'w') { |f| printer.print(f, min_percent: 0) }
+        end
+      end
+
+      def count
+        n = options['count'].to_i
+        n <= 0 ? 10000 : n
+      end
+
+      def refined?
+        options['refined'] == 'refined' || options['refined'] == 'true'
+      end
+
+      def profile?
+        options.key?('profile')
+      end
+
+      def profile_path
+        if options['profile'] == 'profile' || options['profile'] == 'true'
+          File.join(Dir.pwd, 'tmp')
+        else
+          File.expand_path(File.join('..', 'tmp'), __FILE__)
+        end
+      end
+
+      def errors
+        if options['smart'] == 'smart' || options['smart'] == true
+          :smart
+        else
+          :standard
+        end
+      end
+
+      def load_ensure_it
+        lib = File.expand_path(File.join('..', '..'), __FILE__)
+        $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+        require(refined? ? 'ensure_it_refined' : 'ensure_it')
+        ::EnsureIt.configure do |config|
+          config.errors = errors
+        end
+        require 'ruby-prof' if profile?
+      end
+    end
+  end
+end

data/spec/integration/refines_spec.rb

@@ -2,35 +2,35 @@ require 'spec_helper'
 
 describe EnsureIt do
   describe 'refines requirement' do
-    before { @backup = ENSURE_IT_REFINES }
+    before { @backup = ENSURE_IT_REFINED }
 
     after do
-      if defined? ENSURE_IT_REFINES
-        Object.instance_eval { remove_const(:ENSURE_IT_REFINES) }
+      if defined? ENSURE_IT_REFINED
+        Object.instance_eval { remove_const(:ENSURE_IT_REFINED) }
       end
-      ENSURE_IT_REFINES = @backup
+      ENSURE_IT_REFINED = @backup
     end
 
     def load_refines
-      if defined? ENSURE_IT_REFINES
-        Object.instance_eval { remove_const(:ENSURE_IT_REFINES) }
+      if defined? ENSURE_IT_REFINED
+        Object.instance_eval { remove_const(:ENSURE_IT_REFINED) }
       end
       load(File.expand_path(
-        File.join(%w(.. .. .. lib ensure_it_refines.rb)), __FILE__
+        File.join(%w(.. .. .. lib ensure_it_refined.rb)), __FILE__
       ))
     end
 
     if RUBY_VERSION >= '2.1'
-      it 'defines ENSURE_IT_REFINES' do
+      it 'defines ENSURE_IT_REFINED' do
         load_refines
-        expect(ENSURE_IT_REFINES).to be_true
+        expect(ENSURE_IT_REFINED).to be_true
       end
     else
-      it %q{warns with ruby < 2.1 and doesn't defines ENSURE_IT_REFINES} do
+      it %q{warns with ruby < 2.1 and doesn't defines ENSURE_IT_REFINED} do
         expect {
           load_refines
         }.to warn('EsureIt: refines supported only for ruby >= 2.1')
-        expect(ENSURE_IT_REFINES).to be_false
+        expect(ENSURE_IT_REFINED).to be_false
       end
     end
   end

data/spec/lib/ensure_array_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 class Tester
-  using EnsureIt if ENSURE_IT_REFINES
+  using EnsureIt if ENSURE_IT_REFINED
 
   def ensure_array(*args)
     obj.ensure_array(*args)
@@ -59,9 +59,9 @@ describe EnsureIt do
     it_behaves_like 'array parser'
     it_behaves_like 'empty array creator for unmet objects', except: Array
 
-    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
+    it 'and returns nil with default: nil option' do
+      expect(call_for(true, default: nil)).to be_nil
+      expect(call_for(true, default: 1)).to eq 1
     end
   end
 

data/spec/lib/ensure_class_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 class Tester
-  using EnsureIt if ENSURE_IT_REFINES
+  using EnsureIt if ENSURE_IT_REFINED
 
   def ensure_class(*args)
     obj.ensure_class(*args)
@@ -25,14 +25,15 @@ describe EnsureIt do
 
   describe '#ensure_class' do
     it_behaves_like 'class selector'
+    it_behaves_like 'values checker', Array, Integer, values: [Array]
 
     it 'returns nil for wrong classes' do
       expect(call_for(10)).to be_nil
       expect(call_for(Float, Integer)).to be_nil
     end
 
-    it 'returns wrong option for wrong classs' do
-      expect(call_for(10, wrong: true)).to be_true
+    it 'returns default option for wrong classs' do
+      expect(call_for(10, default: true)).to be_true
     end
   end
 

data/spec/lib/ensure_float_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 class Tester
-  using EnsureIt if ENSURE_IT_REFINES
+  using EnsureIt if ENSURE_IT_REFINED
 
   def ensure_float(*args)
     obj.ensure_float(*args)
@@ -51,6 +51,8 @@ describe EnsureIt do
       '123test', :test123, :'0.1',
       except: [String, Integer, Float, Rational]
     )
+    it_behaves_like 'values checker', 10.0, 23.5, values: [10.0, 11.0, 12.0]
+    it_behaves_like 'values checker', 10, 23, values: [10.0, 11.0, 12.0]
   end
 
   describe '#ensure_float!' do

data/spec/lib/ensure_hash_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 class Tester
-  using EnsureIt if ENSURE_IT_REFINES
+  using EnsureIt if ENSURE_IT_REFINED
 
   def ensure_hash(*args)
     obj.ensure_hash(*args)
@@ -29,9 +29,9 @@ describe EnsureIt 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
+    it 'and returns nil with default: nil option' do
+      expect(call_for(true, default: nil)).to be_nil
+      expect(call_for(true, default: 1)).to eq 1
     end
   end
 

data/spec/lib/ensure_instance_of_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 class Tester
-  using EnsureIt if ENSURE_IT_REFINES
+  using EnsureIt if ENSURE_IT_REFINED
 
   def ensure_instance_of(*args)
     obj.ensure_instance_of(*args)
@@ -32,8 +32,8 @@ describe EnsureIt do
       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
+    it 'returns default option for wrong instances' do
+      expect(call_for(:test, String, default: 1)).to eq 1
     end
   end
 

data/spec/lib/ensure_integer_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 class Tester
-  using EnsureIt if ENSURE_IT_REFINES
+  using EnsureIt if ENSURE_IT_REFINED
 
   def ensure_integer(*args)
     obj.ensure_integer(*args)
@@ -75,6 +75,8 @@ describe EnsureIt do
       '123test', :test123, :'100',
       except: [String, Symbol, Integer, Float, Rational]
     )
+    it_behaves_like 'values checker', 10, 23, values: [10, 11, 12]
+    it_behaves_like 'values checker', 10.3, 12.6, values: [10, 11, 12]
   end
 
   describe '#ensure_integer!' do

data/spec/lib/ensure_string_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 class Tester
-  using EnsureIt if ENSURE_IT_REFINES
+  using EnsureIt if ENSURE_IT_REFINED
 
   def ensure_string(*args)
     obj.ensure_string(*args)
@@ -33,6 +33,8 @@ describe EnsureIt do
   describe '#ensure_string' do
     it_behaves_like 'stringifier'
     it_behaves_like 'niller for unmet objects', except: [String, Symbol]
+    it_behaves_like 'values checker', :one, :test, values: %w(one two)
+    it_behaves_like 'values checker', 'one', 'test', values: %w(one two)
   end
 
   describe '#ensure_string!' do

data/spec/lib/ensure_symbol_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 class Tester
-  using EnsureIt if ENSURE_IT_REFINES
+  using EnsureIt if ENSURE_IT_REFINED
 
   def ensure_symbol(*args)
     obj.ensure_symbol(*args)
@@ -21,11 +21,22 @@ describe EnsureIt do
     it 'and converts string to symbol' do
       expect(call_for('test')).to eq :test
     end
+
+    it 'and returns symbol if it in values' do
+      expect(call_for(:test, values: %i(test me))).to eq :test
+      expect(call_for('me', values: %i(test me))).to eq :me
+    end
   end
 
   describe '#ensure_symbol' do
     it_behaves_like 'symbolizer'
     it_behaves_like 'niller for unmet objects', except: [String, Symbol]
+    it_behaves_like 'values checker', :one, :test, values: %i(one two)
+    it_behaves_like 'values checker', 'one', 'test', values: %i(one two)
+
+    it 'returns nil if value not in values option' do
+      expect(call_for(:val, values: %i(test me))).to be_nil
+    end
   end
 
   describe '#ensure_symbol!' do
@@ -35,5 +46,11 @@ describe EnsureIt do
       except: [String, Symbol],
       message: /should be a Symbol or a String/
     )
+
+    it 'raises error if value not in values option' do
+      expect {
+        call_for(:val, values: %i(test me))
+      }.to raise_error EnsureIt::Error
+    end
   end
 end

data/spec/lib/errors_spec.rb

@@ -6,17 +6,25 @@ describe EnsureIt::Error do
   end
 end
 
+
 describe EnsureIt do
-  describe '.raise_error' do
-    after { EnsureIt::Config.instance_variable_set(:@errors, nil) }
+  before do
+    @errors = EnsureIt.config.errors
+    EnsureIt::Config.instance_variable_set(:@errors, nil)
+  end
 
+  after do
+    EnsureIt::Config.instance_variable_set(:@errors, @errors)
+  end
+
+  describe '.raise_error' do
     it 'raises EnsureIt::Error by default' do
       expect {
         call_error(:test_method)
       }.to raise_error EnsureIt::Error
     end
 
-    it 'raisesspecified error and message' do
+    it 'raises specified error and message' do
       expect {
         call_error(:test_method, error: ArgumentError, message: 'test')
       }.to raise_error ArgumentError, 'test'
@@ -115,7 +123,12 @@ describe EnsureIt do
         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) }
+          error = nil
+          begin
+            m.call(*args)
+          rescue EnsureIt::Error => err
+            error = err
+          end
           expect(error.message).to eq message
         end
       end

data/spec/lib/patch_spec.rb

@@ -17,7 +17,7 @@ describe EnsureIt do
         end
       end)
       result =
-        if ENSURE_IT_REFINES
+        if ENSURE_IT_REFINED
           PatchTestWrapper.module_eval do
             using EnsureIt
             PatchTestClass.new.test_method

data/spec/spec_helper.rb

@@ -1,21 +1,21 @@
 if ENV['USE_REFINES'] == 'true'
-  require 'ensure_it_refines'
+  require 'ensure_it_refined'
 else
   require 'ensure_it'
 end
 
-if ENV['USE_COVERALLS'] == 'true'
-  # coveralls.io gem breaks build with our smart errors due to TracePoint
-  # conflicts, so build it separetly
-  # TODO: find better way to resolve this issue
-
-  EnsureIt.configure do |config|
-    config.errors = :standard
-  end
-
-  require 'coveralls'
-  Coveralls.wear!
-end
+#if ENV['USE_COVERALLS'] == 'true'
+#  # coveralls.io gem breaks build with our smart errors due to TracePoint
+#  # conflicts, so build it separetly
+#  # TODO: find better way to resolve this issue
+#
+#  EnsureIt.configure do |config|
+#    config.errors = :standard
+#  end
+#
+require 'coveralls'
+Coveralls.wear!
+#end
 
 
 Dir[File.join(File.dirname(__FILE__), 'support', '**', '*.rb')].each do |file|

data/spec/support/example_groups/ensure_it_example_group.rb

@@ -13,23 +13,12 @@ class Tester
 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
@@ -50,12 +39,6 @@ module EnsureItExampleGroup
     EnsureIt.raise_error(method_name, **opts)
   end
 
-  def get_error
-    yield
-  rescue EnsureIt::Error => e
-    e
-  end
-
   RSpec.configure do |config|
     config.include(
       self,

data/spec/support/shared_examples/unmet_objects.rb

@@ -1,5 +1,3 @@
-#using EnsureIt if ENSURE_IT_REFINES
-
 def fake_method; end
 
 FIXNUM_MAX = (2 ** (0.size * 8 - 2) - 1)
@@ -26,6 +24,14 @@ shared_examples 'niller for unmet objects' do |*add, except: []|
       compose_objects(add, except).map { |x| call_for(x) }.compact
     ).to be_empty
   end
+
+  it 'returns default value' do
+    objects = compose_objects(add, except)
+    default = Object.new
+    expect(
+      objects.map { |x| call_for(x, default: default) }
+    ).to match_array [default] * objects.size
+  end
 end
 
 shared_examples 'empty array creator for unmet objects' do |*add, except: []|
@@ -58,3 +64,15 @@ shared_examples 'banger for unmet objects' do |*add, except: [], **opts|
     end
   end
 end
+
+shared_examples 'values checker' do |obj, unmet, values: []|
+  it 'returns value if it in values option' do
+    default = Object.new
+    expect(call_for(obj, values: values, default: default)).to_not eq default
+  end
+
+  it 'returns default if it not in values option' do
+    default = Object.new
+    expect(call_for(unmet, values: values, default: default)).to eq default
+  end
+end