iba 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa34cf98d021bff67ebed44e9b62e2445c34793422660c0e221b06ca641c722d
-  data.tar.gz: c23f48c6e815351c9181efb572c98e0849e87d3c35a8b922fad6581e87090157
+  metadata.gz: bc9ef58cc2d18bc4e74c789ebed62265cee83bfaf45ee7a7c5e21d2d73c216ca
+  data.tar.gz: cbae41b9fae66df4aa717008627d1478d54e4cc61a90d48371460a23357d4dee
 SHA512:
-  metadata.gz: 992248f06af84ad50da540697617ce9980acc400adbf8fe1df08965d54345bd335a98c8071ec8e32920fb1454ae0820dbe74b7b32322125b8769a3d611c93b82
-  data.tar.gz: 4ae83722fa833dd949a6b0ec254f395afbe2bed6fcd26d92cb919932f2c5f8bb101dcce3bcf9082df188a5019e97ceb7348dd4f956bc9e36076983e6970b43e6
+  metadata.gz: 7ba511885b585a67f8a8dec3b0792c2fd4bc63fd2e575580d22f9b1dab158b7f6e87ea32244ddb5461d2a36d3fcc8eb362c5944b28990728295e52f5ea192797
+  data.tar.gz: 9ef4e73638d5fe567b0ae77a0ac031b3772c71353287aa5fea8a6d3cfd960fb1a1d5b18ca36dd6d8547abeeeaf0b2037b1357b4556c2d55adf4329702910a295

data/lib/iba/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Iba
+  VERSION = "0.0.6"
+end

data/lib/iba.rb

@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "iba/version"
+
 module Iba
   class Combinator
-    def initialize &blk
+    def initialize(&blk)
       @block = blk
     end
 
@@ -17,38 +21,24 @@ module Iba
     end
 
     def analyse
-      str = "#{self} is #{call.inspect}"
-      if expression.class == MethodCallExpression && expression._method == :==
-        lft = expression._reciever
-        rgt = expression._args.first
-        exprs = [lft, rgt].map { |e| display_subexpression e }.compact
-        str << "\n"
-        str << exprs.join(', ')
-      end
+      str = +"#{self} is #{call.inspect}"
+      sub = expression._display_subexpressions(@block.binding)
+      str << "\n#{sub}" if sub
       str
     end
-
-    private
-
-    def display_subexpression expr
-      if expr.class == LiteralExpression
-        nil
-      else
-        str = expr._to_s
-        value = expr._evaluate(@block.binding).inspect
-        "#{str} is #{value}"
-      end
-    end
   end
 
   class BaseExpression
-    def method_missing method, *args
-      super if method.to_s =~ /^_/
+    def method_missing(method, *args)
+      # FIXME: Remove to_s once support for Ruby < 2.7 is dropped
+      super if method.to_s.start_with? "_"
       MethodCallExpression.new self, method, args
     end
 
-    def respond_to_missing? method
-      return false if method.to_s =~ /^_/
+    def respond_to_missing?(method)
+      # FIXME: Remove to_s once support for Ruby < 2.7 is dropped
+      return super if method.to_s.start_with? "_"
+
       true
     end
 
@@ -56,11 +46,15 @@ module Iba
       method_missing :to_s
     end
 
-    def == other
+    def ==(other)
       method_missing :==, other
     end
 
-    def _wrap arg
+    def !=(other)
+      method_missing :!=, other
+    end
+
+    def _wrap(arg)
       if arg.is_a? BaseExpression
         arg
       else
@@ -68,13 +62,22 @@ module Iba
       end
     end
 
-    def coerce other
+    def _display(_bnd)
+      nil
+    end
+
+    def _display_subexpressions(_bnd)
+      nil
+    end
+
+    # Handle numeric operator coersion
+    def coerce(other)
       [_wrap(other), self]
     end
   end
 
   class EmptyExpression < BaseExpression
-    def _parse &blk
+    def _parse(&blk)
       bnd = blk.binding
 
       vars = bnd.local_variables
@@ -92,35 +95,42 @@ module Iba
       result
     end
 
-    def _override_instance_variables vars
+    def _override_instance_variables(vars)
       vars.each do |v|
-        next if v =~ /^@_/
+        # FIXME: Remove to_s once support for Ruby < 2.7 is dropped
+        next if v.to_s.start_with? "@_"
+
         instance_variable_set v, Iba::InstanceVariableExpression.new(v.to_sym)
       end
     end
 
-    def _override_local_variables vars, bnd
+    def _override_local_variables(vars, bnd)
       vars.each do |v|
-        next if v =~ /^_/
+        # FIXME: Remove to_s once support for Ruby < 2.7 is dropped
+        next if v.to_s.start_with? "_"
+
         bnd.local_variable_set "_#{v}", bnd.local_variable_get(v)
         bnd.local_variable_set v, LocalVariableExpression.new(v.to_sym)
       end
     end
 
-    def _restore_local_variables vars, bnd
+    def _restore_local_variables(vars, bnd)
       vars.each do |v|
-        next if v =~ /^_/
+        # FIXME: Remove to_s once support for Ruby < 2.7 is dropped
+        next if v.to_s.start_with? "_"
+
         bnd.local_variable_set v, bnd.local_variable_get("_#{v}")
       end
     end
 
     def _to_s
-      ''
+      ""
     end
   end
 
   class LiteralExpression < BaseExpression
-    def initialize val
+    def initialize(val)
+      super()
       @value = val
     end
 
@@ -128,13 +138,22 @@ module Iba
       @value.inspect
     end
 
-    def _evaluate _bnd
+    def _evaluate(_bnd)
       @value
     end
   end
 
-  class InstanceVariableExpression < BaseExpression
-    def initialize ivar_name
+  class DisplayableExpression < BaseExpression
+    def _display(bnd)
+      str = _to_s
+      value = _evaluate(bnd).inspect
+      "#{str} is #{value}"
+    end
+  end
+
+  class InstanceVariableExpression < DisplayableExpression
+    def initialize(ivar_name)
+      super()
       @_ivar_name = ivar_name
     end
 
@@ -142,13 +161,14 @@ module Iba
       @_ivar_name.to_s
     end
 
-    def _evaluate bnd
+    def _evaluate(bnd)
       bnd.receiver.instance_variable_get @_ivar_name
     end
   end
 
-  class LocalVariableExpression < BaseExpression
-    def initialize lvar_name
+  class LocalVariableExpression < DisplayableExpression
+    def initialize(lvar_name)
+      super()
       @_lvar_name = lvar_name
     end
 
@@ -156,64 +176,89 @@ module Iba
       @_lvar_name.to_s
     end
 
-    def _evaluate bnd
+    def _evaluate(bnd)
       bnd.local_variable_get @_lvar_name
     end
   end
 
-  class MethodCallExpression < BaseExpression
+  class MethodCallExpression < DisplayableExpression
     attr_reader :_method, :_reciever, :_args
 
-    def initialize reciever, methodname, args
+    def initialize(reciever, methodname, args)
+      super()
       @_reciever = reciever
       @_method = methodname
       @_args = args.map { |a| _wrap(a) }
     end
 
     def _to_s
-      rcv = @_reciever._to_s
-      args = @_args.map { |a| a.respond_to?(:_to_s) ? a._to_s : a.to_s }
-
       if @_method == :[]
-        "#{rcv}[#{args[0]}]"
+        _index_to_s
       elsif _method_is_operator?
-        case @_args.length
-        when 0
-          "#{@_method.to_s.sub(/@$/, '')}#{rcv}"
-        when 1
-          "(#{rcv} #{@_method} #{args.first})"
-        else
-          raise NotImplementedError
-        end
+        _operator_to_s
       else
-        str = rcv == '' ? '' : "#{rcv}."
-        str << @_method.to_s
-        str << "(#{args.join(', ')})" unless @_args.empty?
-        str
+        _regular_method_to_s
       end
     end
 
-    def _evaluate bnd
+    def _evaluate(bnd)
       rcv = @_reciever._evaluate(bnd)
       args = @_args.map { |arg| arg._evaluate(bnd) }
       rcv.send @_method, *args
     end
 
+    def _display_subexpressions(bnd)
+      rcv = @_reciever._display(bnd)
+      args = @_args.map { |arg| arg._display(bnd) }
+      [rcv, *args].compact.join(", ")
+    end
+
     private
 
+    def _receiver_s
+      @_reciever._to_s
+    end
+
+    def _args_s
+      @_args.map { |a| a.respond_to?(:_to_s) ? a._to_s : a.to_s }
+    end
+
+    def _index_to_s
+      "#{_receiver_s}[#{_args_s[0]}]"
+    end
+
+    def _operator_to_s
+      case @_args.length
+      when 0
+        "#{@_method.to_s.sub(/@$/, '')}#{_receiver_s}"
+      when 1
+        "(#{_receiver_s} #{@_method} #{_args_s.first})"
+      else
+        raise NotImplementedError
+      end
+    end
+
+    def _regular_method_to_s
+      rcv = _receiver_s
+      str = rcv == "" ? +"" : +"#{rcv}."
+      str << @_method.to_s
+      str << "(#{_args_s.join(', ')})" unless @_args.empty?
+      str
+    end
+
     def _method_is_operator?
       @_method.to_s !~ /^[a-z]/
     end
   end
 
   module BlockAssertion
-    def assert *args
-      if block_given?
+    def assert(*args, &block)
+      if block
         if yield
-          assert_block('true') { true }
+          assert_block("true") { true }
         else
-          msg = args.empty? ? '' : "#{args.first}.\n"
-          ana = Combinator.new(&Proc.new).analyse
+          msg = args.empty? ? "" : "#{args.first}.\n"
+          ana = Combinator.new(&block).analyse
           assert_block("#{msg}#{ana}.") { false }
         end
       else

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: iba
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Matijs van Zuijlen
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-03-25 00:00:00.000000000 Z
+date: 2022-01-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -16,14 +16,70 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '12.0'
+        version: '13.0'
+- !ruby/object:Gem::Dependency
+  name: rake-manifest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.25.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.25.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-packaging
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.13.0
 - !ruby/object:Gem::Dependency
   name: test-unit
   requirement: !ruby/object:Gem::Requirement
@@ -38,7 +94,9 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.1'
-description: Asserts blocks, prints introspective failure messages.
+description: 'Asserts blocks, prints introspective failure messages.
+
+  '
 email:
 - matijs@matijs.net
 executables: []
@@ -51,19 +109,16 @@ files:
 - COPYING.LESSER
 - LICENSE
 - README.rdoc
-- Rakefile
 - lib/iba.rb
-- test/.rubocop.yml
-- test/analyse_test.rb
-- test/assert_test.rb
-- test/call_test.rb
-- test/display_test.rb
-- test/test_helper.rb
+- lib/iba/version.rb
 homepage: http://www.github.com/mvz/iba
 licenses:
-- LGPL-3
-metadata: {}
-post_install_message: 
+- LGPL-3.0+
+metadata:
+  homepage_uri: http://www.github.com/mvz/iba
+  source_code_uri: https://github.com/mvz/iba
+  rubygems_mfa_required: 'true'
+post_install_message:
 rdoc_options:
 - "--main"
 - README.rdoc
@@ -73,22 +128,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.0
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.3.3
+signing_key:
 specification_version: 4
 summary: Introspective Block Assertions
-test_files:
-- test/.rubocop.yml
-- test/analyse_test.rb
-- test/assert_test.rb
-- test/call_test.rb
-- test/display_test.rb
-- test/test_helper.rb
+test_files: []

data/Rakefile

@@ -1,16 +0,0 @@
-require 'rake/clean'
-require 'bundler/gem_tasks'
-require 'rake/testtask'
-
-namespace :test do
-  Rake::TestTask.new(:run) do |t|
-    t.libs = ['lib']
-    t.test_files = FileList['test/**/*_test.rb']
-    t.ruby_opts += ['-w']
-  end
-end
-
-desc 'Alias to test:run'
-task test: 'test:run'
-
-task default: 'test:run'

data/test/.rubocop.yml

@@ -1,10 +0,0 @@
-inherit_from: ../.rubocop.yml
-
-# We need to rescue Exception to test exceptions thrown by assert
-# TODO: Remove once support for Ruby 1.8 is dropped.
-Lint/RescueException:
-  Enabled: false
-
-# Allow compact syntax when adding to Test::Unit::TestCase
-Style/ClassAndModuleChildren:
-  Enabled: false

data/test/analyse_test.rb

@@ -1,78 +0,0 @@
-require_relative 'test_helper'
-
-# Test how the combinator analyses the parsed block contents.
-class AnalyseTest < Test::Unit::TestCase
-  def test_empty_block
-    assert_equal 'nil is nil', combinator {}.analyse
-  end
-
-  def test_variable
-    foo = 23
-    assert_equal 'foo is 23', combinator { foo }.analyse
-  end
-
-  def test_operator_equals
-    foo = 42
-    bar = 23
-    result = combinator { foo == bar }.analyse
-    assert_equal "(foo == bar) is false\nfoo is 42, bar is 23", result
-  end
-
-  def test_operator_equals_literal
-    foo = 42
-    result = combinator { foo == 23 }.analyse
-    assert_equal "(foo == 23) is false\nfoo is 42", result
-  end
-
-  def test_operator_equals_array_literal
-    foo = [1, 'bar']
-    result = combinator { foo == [2, 'baz'] }.analyse
-    assert_equal "(foo == [2, \"baz\"]) is false\nfoo is [1, \"bar\"]", result
-  end
-
-  def test_string_variable
-    foo = 'blub'
-    assert_equal 'foo is "blub"', combinator { foo }.analyse
-  end
-
-  def test_array_variable
-    foo = [1, 2]
-    assert_equal 'foo is [1, 2]', combinator { foo }.analyse
-  end
-
-  def test_object_variable
-    foo = Object.new
-    insp = foo.inspect
-    assert_equal "foo is #{insp}", combinator { foo }.analyse
-  end
-
-  def test_literal
-    assert_equal '23 is 23', combinator { 23 }.analyse
-  end
-
-  def test_instance_variable
-    @foo = 23
-    assert_equal '@foo is 23', combinator { @foo }.analyse
-  end
-
-  def test_instance_variable_method_call
-    @foo = 23
-    assert_equal "(@foo == 23) is true\n@foo is 23", combinator { @foo == 23 }.analyse
-  end
-
-  def test_instance_variable_as_argument_of_operator
-    @foo = 23
-    assert_equal '(23 + @foo) is 46', combinator { 23 + @foo }.analyse
-  end
-
-  def test_complex_subexpressions
-    @foo = 23
-    bar = 42
-    baz = [42]
-    result = combinator { (@foo + baz.first) == (bar + 23) }.analyse
-    assert_equal \
-      "((@foo + baz.first) == (bar + 23)) is true\n" \
-      '(@foo + baz.first) is 65, (bar + 23) is 65',
-      result
-  end
-end

data/test/assert_test.rb

@@ -1,51 +0,0 @@
-require_relative 'test_helper'
-
-# Test behavior of overridden assert method.
-class AssertTest < Test::Unit::TestCase
-  def test_simple_assert
-    assert { true }
-  end
-
-  def failing_block_assertion_test message, &block
-    assert(&block)
-  rescue Exception => e
-    assert_equal message, e.message
-  end
-
-  def test_simple_failing_assert
-    failing_block_assertion_test('false is false.') { false }
-  end
-
-  def test_operator_equals_assert
-    foo = 24
-    failing_block_assertion_test("(foo == 23) is false\nfoo is 24.") { foo == 23 }
-  end
-
-  def test_instance_variable_assert
-    @foo = 24
-    failing_block_assertion_test("(@foo == 23) is false\n@foo is 24.") { @foo == 23 }
-  end
-
-  # Special cases
-
-  def test_assert_with_custom_message
-    foo = false
-    begin
-      assert('We want foo') { foo }
-    rescue Exception => e
-      assert_equal "We want foo.\nfoo is false.", e.message
-    end
-  end
-
-  def test_blockless_assert
-    assert false
-  rescue Exception => e
-    assert_equal '<false> is not true.', e.message
-  end
-
-  def test_blockless_assert_with_custom_message
-    assert false, 'We want the truth'
-  rescue Exception => e
-    assert_equal "We want the truth.\n<false> is not true.", e.message
-  end
-end

data/test/call_test.rb

@@ -1,18 +0,0 @@
-require File.expand_path('test_helper.rb', File.dirname(__FILE__))
-
-# Test how the combinator calls the passed block.
-class CallTest < Test::Unit::TestCase
-  def test_empty_combinator
-    assert_equal nil, combinator {}.call
-  end
-
-  def test_variable
-    foo = 23
-    assert_equal 23, combinator { foo }.call
-  end
-
-  def test_operator_call
-    foo = 23
-    assert_equal true, combinator { foo == 23 }.call
-  end
-end

data/test/display_test.rb

@@ -1,57 +0,0 @@
-require_relative 'test_helper'
-
-# Test how the combinator displays the parsed block contents.
-class DisplayTest < Test::Unit::TestCase
-  def test_empty_combinator
-    assert_equal 'nil', combinator {}.to_s
-  end
-
-  def test_literal_number
-    assert_equal '23', combinator { 23 }.to_s
-  end
-
-  def test_literal_string
-    assert_equal '"aa"', combinator { 'aa' }.to_s
-  end
-
-  def test_method_calls
-    assert_equal 'foo', combinator { foo }.to_s
-    assert_equal 'foo.foo', combinator { foo.foo }.to_s
-    assert_equal 'foo.foo(1)', combinator { foo.foo 1 }.to_s
-    assert_equal 'foo(1)', combinator { foo 1 }.to_s
-    assert_equal 'foo(bar)', combinator { foo bar }.to_s
-    assert_equal 'foo(1).bar', combinator { foo(1).bar }.to_s
-    assert_equal 'foo.foo.foo', combinator { foo.foo.foo }.to_s
-    assert_equal 'foo(bar.baz)', combinator { foo bar.baz }.to_s
-  end
-
-  def test_operators
-    assert_equal '(foo + 1)', combinator { foo + 1 }.to_s
-    assert_equal '(foo - 1)', combinator { foo - 1 }.to_s
-  end
-
-  def test_operator_equals
-    assert_equal '(foo == 1)', combinator { foo == 1 }.to_s
-  end
-
-  def test_array_index
-    assert_equal 'foo[1]', combinator { foo[1] }.to_s
-  end
-
-  def test_to_s_method
-    assert_equal 'foo.to_s', combinator { foo.to_s }.to_s
-  end
-
-  def test_operator_unary_minus
-    assert_equal '-foo', combinator { -foo }.to_s
-  end
-
-  def test_operator_if_wont_work
-    assert_equal 'bar', combinator { foo ? bar : baz }.to_s
-  end
-
-  def test_defined_instance_variables
-    @foo = 1
-    assert_equal '@foo', combinator { @foo }.to_s
-  end
-end

data/test/test_helper.rb

@@ -1,10 +0,0 @@
-require 'test/unit'
-require 'iba'
-
-class Test::Unit::TestCase
-  include Iba::BlockAssertion
-
-  def combinator &blk
-    Iba::Combinator.new(&blk)
-  end
-end