ensure_it 0.1.0

data/lib/ensure_it/ensure_integer.rb

@@ -0,0 +1,89 @@
+module EnsureIt
+  OCT_REGEXP = /\A0\d+\z/
+  INT_REGEXP = /\A[+\-]?\d[\d_]*\z/
+  HEX_REGEXP = /\A0x[0-9a-zA-Z]+\z/
+  BIN_REGEXP = /\A0b[01]+\z/
+
+  patch Object do
+    def ensure_integer(**opts)
+      opts.key?(:wrong) ? opts[:wrong] : nil
+    end
+
+    def ensure_integer!(**opts)
+      opts[:message] ||= '#{subject} should be an integer or be able' \
+                         ' to convert to it'
+      EnsureIt.raise_error(:ensure_integer!, **opts)
+    end
+  end
+
+  patch String do
+    using EnsureIt if ENSURE_IT_REFINES
+
+    def ensure_integer(**opts)
+      case self
+      when OCT_REGEXP then opts[:octal] == true ? self.to_i(8) : self.to_i
+      when INT_REGEXP then self.to_i
+      when HEX_REGEXP then self[2..-1].to_i(16)
+      when BIN_REGEXP then self[2..-1].to_i(2)
+      else nil
+      end
+    end
+
+    def ensure_integer!(**opts)
+      ensure_integer(**opts) || super(**opts)
+    end
+  end
+
+  patch Integer do
+    def ensure_integer(**opts)
+      self
+    end
+    alias_method :ensure_integer!, :ensure_integer
+  end
+
+  patch Float do
+    def ensure_integer(**opts)
+      round
+    end
+    alias_method :ensure_integer!, :ensure_integer
+  end
+
+  patch Rational do
+    def ensure_integer(**opts)
+      round
+    end
+    alias_method :ensure_integer!, :ensure_integer
+  end
+
+  patch TrueClass do
+    using EnsureIt if ENSURE_IT_REFINES
+
+    def ensure_integer(**opts)
+      if opts[:boolean] == true || opts[:boolean].is_a?(Integer)
+        opts[:boolean] == true ? 1 : opts[:boolean]
+      else
+        nil
+      end
+    end
+
+    def ensure_integer!(**opts)
+      if opts[:boolean] == true || opts[:boolean].is_a?(Integer)
+        opts[:boolean] == true ? 1 : opts[:boolean]
+      else
+        super(**opts)
+      end
+    end
+  end
+
+  patch FalseClass do
+    using EnsureIt if ENSURE_IT_REFINES
+
+    def ensure_integer(**opts)
+      opts[:boolean] == true || opts[:boolean].is_a?(Integer) ? 0 : nil
+    end
+
+    def ensure_integer!(**opts)
+      opts[:boolean] == true || opts[:boolean].is_a?(Integer) ? 0 : super(**opts)
+    end
+  end
+end

data/lib/ensure_it/ensure_string.rb

@@ -0,0 +1,43 @@
+module EnsureIt
+  patch Object do
+    def ensure_string(**opts)
+      opts.key?(:wrong) ? opts[:wrong] : nil
+    end
+
+    def ensure_string!(**opts)
+      opts[:message] ||=
+        if opts[:numbers] == true
+          '#{subject} should be a String, Symbol, Numeric or Rational'
+        else
+          '#{subject} should be a String or a Symbol'
+        end
+      EnsureIt.raise_error(:ensure_string!, **opts)
+    end
+  end
+
+  patch String do
+    def ensure_string(**opts)
+      self
+    end
+    alias_method :ensure_string!, :ensure_string
+  end
+
+  patch Symbol do
+    def ensure_string(**opts)
+      to_s
+    end
+    alias_method :ensure_string!, :ensure_string
+  end
+
+  patch Numeric do
+    using EnsureIt if ENSURE_IT_REFINES
+
+    def ensure_string(**opts)
+      opts[:numbers] == true ? to_s : nil
+    end
+
+    def ensure_string!(**opts)
+      opts[:numbers] == true ? to_s : super(**opts)
+    end
+  end
+end

data/lib/ensure_it/ensure_symbol.rb

@@ -0,0 +1,26 @@
+module EnsureIt
+  patch Object do
+    def ensure_symbol(**opts)
+      opts.key?(:wrong) ? opts[:wrong] : nil
+    end
+
+    def ensure_symbol!(**opts)
+      opts[:message] ||= '#{subject} should be a Symbol or a String'
+      EnsureIt.raise_error(:ensure_symbol!, **opts)
+    end
+  end
+
+  patch String do
+    def ensure_symbol(**opts)
+      to_sym
+    end
+    alias_method :ensure_symbol!, :ensure_symbol
+  end
+
+  patch Symbol do
+    def ensure_symbol(**opts)
+      self
+    end
+    alias_method :ensure_symbol!, :ensure_symbol
+  end
+end

data/lib/ensure_it/errors.rb

@@ -0,0 +1,173 @@
+module EnsureIt
+  class Error < StandardError; end
+
+  class ErrorMessage
+    attr_accessor :method_name, :subject, :subject_type, :inside, :backtrace
+    attr_writer :message
+
+    def initialize(method_name, message, backtrace)
+      method_name = method_name.to_sym if method_name.is_a?(String)
+      unless method_name.is_a?(Symbol)
+        raise ArgumentError, 'EnsureIt: Wrong method_name argument for Error'
+      end
+      @method_name, @message, @backtrace = method_name, message, backtrace
+    end
+
+    def subject_display_name
+      display_name =
+        if @subject.nil? && @subject_type != :unknown_method_result
+          "subject of '#{method_name}' method"
+        else
+          case @subject_type
+          when :local_variable then "local variable '#{@subject}'"
+          when :instance_variable then "instance variable '@#{@subject}'"
+          when :class_variable then "class variable '@@#{@subject}'"
+          when :method_result then "return value of '#{subject}' method"
+          when :unknown_method_result then 'return value of method'
+          when :req_argument then "argument '#{subject}'"
+          when :rest_argument then "argument '*#{subject}'"
+          when :opt_argument then "optional argument '#{subject}'"
+          when :key_argument then "key argument '#{subject}'"
+          when :keyrest_argument then "key argument '**#{subject}'"
+          when :block_argument then "block argument '&#{subject}'"
+          else "subject of '#{method_name}' method"
+          end
+        end
+      unless @inside.nil?
+        display_name +=
+          if !@subject_type.nil? && @subject_type.to_s =~ /_argument\z/
+            " of '#{@inside}' method"
+          else
+            " inside '#{@inside}' method"
+          end
+      end
+      display_name
+    end
+
+    def message
+      unless @message.is_a?(String)
+        @message =
+          if @subject.nil? && @subject_type != :unknown_method_result
+            '#{subject}'
+          else
+            '#{subject} of #{method_name}'
+          end
+      end
+      @message.gsub(/\#\{subject\}/, subject_display_name)
+              .gsub(/\#\{name\}/, @subject.to_s)
+              .gsub(/\#\{method_name\}/, @method_name.to_s)
+    end
+  end
+
+  def self.raise_error(method_name, message: nil, error: Error, **opts)
+    error = Error unless error <= Exception
+    error_msg = ErrorMessage.new(method_name, message, caller[1..-1])
+    if opts.key?(:smart) && opts[:smart] != true ||
+       EnsureIt.config.errors != :smart
+      raise error_class, error.message, error.backtrace
+    end
+    raise_smart_error(error_msg, error, **opts)
+  end
+
+  def self.raise_smart_error(error, error_class, **opts)
+    inspect_source(error, **opts)
+    tp_count = 0
+    error_obj = nil
+    error_message = error.message
+    error_backtrace = error.backtrace
+    #
+    # first trace point is to capture raise object before exitting
+    # from :ensure_* method
+    #
+    # after that with second trace point we try to return from :ensure_* method
+    # to caller and inspect code there for method name and arguments
+    TracePoint.trace(:return, :raise) do |first_tp|
+      if first_tp.event == :raise
+        # save error object for patching
+        error_obj = first_tp.raised_exception
+      else
+        # skip returns from :raise_smart_error and :raise_error
+        tp_count += 1
+        if tp_count > 1
+          # at this moment we are at end of 'ensure_' method
+          first_tp.disable
+          TracePoint.trace(:return) do |second_tp|
+            # skip return from :ensure_* method
+            tp_count += 1
+            if tp_count > 3
+              # now we are in caller context
+              second_tp.disable
+              unless error_obj.nil?
+                # inspect caller code
+                inspect_code(second_tp, error, **opts)
+                # patch error message
+                error_obj.extend(Module.new do
+                  @@ensure_it_message = error.message
+                  def message; @@ensure_it_message; end
+                end)
+              end
+            end
+          end
+        end
+      end
+    end
+    raise error_class, error_message, error_backtrace
+  end
+
+  def self.inspect_source(error, **opts)
+    file_name, line_no = error.backtrace.first.split(':', 2)
+    return unless File.exist?(file_name)
+    line_no = line_no.to_i
+    line = read_line_number(file_name, line_no)
+    return if line.nil?
+    m_name = error.method_name
+    m = /
+      (?:(?<method_access>\.)|(?<class_access>@{1,2}))?
+      (?<name>(?:[a-z_][a-zA-Z_0-9]*(?<modifier>[?!])?)|\))
+      (?:
+        (?<send>\.send\(\s*(?::#{m_name}|'#{m_name}'|"#{m_name}")\s*\))|
+        (?:\.#{m_name}(?:[^a-zA-Z_0-9]|\z))
+      )
+    /x.match(line)
+    return if m.nil? || m[:method_access].nil? && !m[:modifier].nil?
+    error.subject = m[:name]
+    error.subject_type = case
+      when m[:class_access] then
+        m[:class_access] == '@' ? :instance_variable : :class_variable
+      when m[:name] == ')' then
+        error.subject = nil
+        :unknown_method_result
+      when m[:method_access] then :method_result
+      else :local_variable
+      end
+  end
+
+  def self.inspect_code(tp, error, **opts)
+    return if tp.method_id.nil?
+    error.inside = tp.method_id
+    begin
+      method = eval("method(:#{tp.method_id})", tp.binding)
+    rescue NameError
+      return
+    end
+    param = method.parameters.find { |_, name| name.to_s == error.subject }
+    unless param.nil?
+      error.subject_type = "#{param[0]}_argument".to_sym
+    end
+  end
+
+  def self.read_line_number(file_name, number)
+    counter, line = 0, nil
+    File.foreach(file_name) do |l|
+      counter += 1
+      if counter == number
+        line = l.chomp!
+        break
+      end
+    end
+    line
+  end
+
+  private_class_method :raise_smart_error, :inspect_source, :inspect_code,
+                       :read_line_number
+end

data/lib/ensure_it/patch.rb

@@ -0,0 +1,17 @@
+module EnsureIt
+  if ENSURE_IT_REFINES
+    def self.patch(target, &block)
+      module_eval do
+        refine target do
+          class_eval(&block)
+        end
+      end
+    end
+  else
+    def self.patch(target, &block)
+      target.class_eval(&block)
+    end
+  end
+
+  private_class_method :patch
+end

data/lib/ensure_it/version.rb

@@ -0,0 +1,3 @@
+module EnsureIt
+  VERSION = '0.1.0'
+end

data/lib/ensure_it.rb

@@ -0,0 +1,18 @@
+if RUBY_VERSION < '2.0.0'
+  fail %q{EnsureIt: library doesn't support ruby < 2.0.0}
+end
+
+defined?(ENSURE_IT_REFINES) || ENSURE_IT_REFINES = false
+
+require File.join %w(ensure_it version)
+require File.join %w(ensure_it config)
+require File.join %w(ensure_it errors)
+require File.join %w(ensure_it patch)
+require File.join %w(ensure_it ensure_symbol)
+require File.join %w(ensure_it ensure_string)
+require File.join %w(ensure_it ensure_integer)
+require File.join %w(ensure_it ensure_float)
+require File.join %w(ensure_it ensure_array)
+require File.join %w(ensure_it ensure_hash)
+require File.join %w(ensure_it ensure_instance_of)
+require File.join %w(ensure_it ensure_class)

data/lib/ensure_it_refines.rb

@@ -0,0 +1,8 @@
+if RUBY_VERSION >= '2.1'
+  ENSURE_IT_REFINES = true
+else
+  ENSURE_IT_REFINES = false
+  warn 'EsureIt: refines supported only for ruby >= 2.1'
+end
+
+require 'ensure_it'

data/spec/integration/refines_spec.rb

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

data/spec/lib/config_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe EnsureIt::Config do
+  describe '::errors' do
+    after { described_class.instance_variable_set(:@errors, nil) }
+
+    it 'gives :smart by default' do
+      expect(described_class.errors).to eq :smart
+    end
+
+    it 'calls setter if value given' do
+      expect(described_class).to receive(:errors=).with(:standard)
+      described_class.errors :standard
+    end
+  end
+
+  describe '::errors=' do
+    after { described_class.instance_variable_set(:@errors, nil) }
+
+    it 'allows to change value' do
+      described_class.errors = :standard
+      expect(described_class.errors).to eq :standard
+    end
+
+    it 'sets to default for wrong values' do
+      described_class.errors = :bad_value
+      expect(described_class.errors).to eq :smart
+    end
+  end
+end
+
+describe EnsureIt do
+  describe '::config' do
+    it 'returns Config module' do
+      expect(described_class.config).to eq EnsureIt::Config
+    end
+  end
+
+  describe '::configure' do
+    it 'returns Config module' do
+      expect(described_class.config).to eq EnsureIt::Config
+    end
+
+    it 'yields block with Config module' do
+      expect { |b|
+        described_class.configure(&b)
+      }.to yield_with_args(EnsureIt::Config)
+    end
+  end
+end

data/spec/lib/ensure_array_spec.rb

@@ -0,0 +1,75 @@
+require 'spec_helper'
+
+class Tester
+  using EnsureIt if ENSURE_IT_REFINES
+
+  def ensure_array(*args)
+    obj.ensure_array(*args)
+  end
+
+  def ensure_array!(*args)
+    obj.ensure_array!(*args)
+  end
+end
+
+describe EnsureIt do
+  shared_examples 'array parser' do
+    it 'and returns self for array' do
+      obj = [1, nil, 2]
+      expect(call_for(obj)).to eq obj
+    end
+
+    it 'compacts array with compact option' do
+      expect(call_for([1, nil, 2], compact: true)).to eq [1, 2]
+    end
+
+    it 'flattens array with flatten option' do
+      expect(call_for([1, [2, 3], 4], flatten: true)).to eq [1, 2, 3, 4]
+    end
+
+    [:sorted, :ordered].each do |o|
+      it "flattens and then sorts array with flatten and #{o} options" do
+        expect(
+          call_for([1, [5, 6], 4], flatten: true, o => true)
+        ).to eq [1, 4, 5, 6]
+      end
+
+      it "sorts descending with #{o}: :desc option" do
+        expect(call_for([1, 5, 6, 4], o => :desc)).to eq [6, 5, 4, 1]
+      end
+    end
+
+    it 'calls :ensure_* for each element' do
+      arr = ['s', nil, :v]
+      expect(call_for(arr, :ensure_symbol, compact: true)).to eq [:s, :v]
+    end
+
+    it 'calls standard method for each element' do
+      arr = ['s', :v]
+      expect(call_for(arr, :to_s)).to eq ['s', 'v']
+    end
+
+    it 'chains methods for each element' do
+      arr = ['s', :v]
+      expect(call_for(arr, :ensure_string, :to_sym)).to eq [:s, :v]
+    end
+  end
+
+  describe '#ensure_array' 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
+    end
+  end
+
+  describe '#ensure_array!' do
+    it_behaves_like 'array parser'
+    it_behaves_like(
+      'banger for unmet objects', except: Array,
+      message: /should be an Array/
+    )
+  end
+end

data/spec/lib/ensure_class_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+class Tester
+  using EnsureIt if ENSURE_IT_REFINES
+
+  def ensure_class(*args)
+    obj.ensure_class(*args)
+  end
+
+  def ensure_class!(*args)
+    obj.ensure_class!(*args)
+  end
+end
+
+describe EnsureIt do
+  shared_examples 'class selector' do
+    it 'and returns self for right classes' do
+      expect(call_for(String)).to eq String
+    end
+
+    it 'and checks for ancestors' do
+      expect(call_for(Array, Enumerable, Array)).to eq Array
+    end
+  end
+
+  describe '#ensure_class' do
+    it_behaves_like 'class selector'
+
+    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
+    end
+  end
+
+  describe '#ensure_class!' do
+    it_behaves_like 'class selector'
+
+    it 'raises for non-classes' do
+      expect {
+        call_for(10)
+      }.to raise_error EnsureIt::Error, /should be a class\z/
+    end
+
+    it 'raises on wrong classes' do
+      expect {
+        call_for(Float, Integer)
+      }.to raise_error EnsureIt::Error, /should subclass or extend all of/
+    end
+  end
+end

data/spec/lib/ensure_float_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+class Tester
+  using EnsureIt if ENSURE_IT_REFINES
+
+  def ensure_float(*args)
+    obj.ensure_float(*args)
+  end
+
+  def ensure_float!(*args)
+    obj.ensure_float!(*args)
+  end
+end
+
+describe EnsureIt do
+  shared_examples 'float numerizer' do
+    it 'and returns self for Float' do
+      obj = 0.1
+      expect(call_for(obj)).to eq obj
+    end
+
+    it 'and converts Rational' do
+      expect(call_for(Rational(1, 2))).to eq 0.5
+    end
+
+    it 'and converts Integers' do
+      expect(call_for(100)).to eq 100.0
+      expect(call_for(100)).to be_kind_of(Float)
+    end
+
+    it 'and converts decimal strings' do
+      expect(call_for('100')).to eq(100.0)
+      expect(call_for('100')).to be_kind_of(Float)
+    end
+
+    it 'and converts strings with dot' do
+      expect(call_for('0.1')).to eq(0.1)
+    end
+
+    it 'and converts scientific strings' do
+      expect(call_for('1e3')).to eq(1000.0)
+      expect(call_for('1e-3')).to eq(0.001)
+      expect(call_for('-1.5e+3')).to eq(-1500.0)
+    end
+  end
+
+  describe '#ensure_float' do
+    it_behaves_like 'float numerizer'
+    it_behaves_like(
+      'niller for unmet objects',
+      '123test', :test123, :'0.1',
+      except: [String, Integer, Float, Rational]
+    )
+  end
+
+  describe '#ensure_float!' do
+    it_behaves_like 'float numerizer'
+    it_behaves_like(
+      'banger for unmet objects',
+      '123test', :test123, :'0.1',
+      except: [String, Integer, Float, Rational],
+      message: /should be a float or be able to convert to it/
+    )
+  end
+end