rlab-assert 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e6938e62081cbd09fc601ff5d7c00f66e68b1b61
+  data.tar.gz: 56a1a0c69cdd1de23185353b272159ea0b493d97
+SHA512:
+  metadata.gz: 3ed5a18f1393c4ed0610e37e13acf0e492f3357ac618f0ed66638a15e1afe0fbc490f9a90e868b9a72e487a1a23d91ca89365a52599b8c3ae69c194377876288
+  data.tar.gz: e3493df70e1ec449ffa61e2c2e9e7b84ed3fafd017c826748481351c33b701603451647e68310373d33976f6422cce110a09c41ceb735969994ec255b5541ec7

data/.bundle/config

@@ -0,0 +1,3 @@
+---
+BUNDLE_PATH: vendor
+BUNDLE_DISABLE_SHARED_GEMS: '1'

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.2

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in nassert.gemspec
+gemspec

data/README.md

@@ -0,0 +1,33 @@
+# RLab Assert
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/nassert`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "rlab-assert"
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rlab-assert
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/nassert/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/tests

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+
+$LOAD_PATH.<< File.expand_path "../../../../src", __FILE__
+$LOAD_PATH.<< File.expand_path "../../lib", __FILE__
+
+require "util"
+require "executor"
+require "executor/minitest"
+require "reporters"
+require "test"
+
+require "rlab/assert"
+
+module Picotest
+  class Test
+    singleton_class.send :attr, :subclasses
+    @subclasses = []
+
+    class << self
+      def extract_tests executor
+        subclasses.flat_map do |subclass|
+          RLab::Assert::Syntax.infect subclass, :observer => executor
+
+          test_methods = subclass.instance_methods.grep %r{^test_}
+          test_methods.map do |test_method|
+            RLab::Test.new executor, "#{subclass}##{test_method}", -> do
+              instance = subclass.new
+              instance.setup
+              instance.public_send test_method
+              instance.teardown
+            end
+          end
+        end
+      end
+
+      def inherited subclass
+        subclasses.push subclass
+      end
+    end
+
+    def setup; end
+    def teardown; end
+    def skip; throw :skip end
+  end
+end
+
+Dir["tests/**/*.rb"].each &method(:load)
+
+RLab::Executor::SingleThreaded.run(
+  Picotest::Test.method(:extract_tests),
+  RLab::Reporters::Classic.new(:color => true),
+)

data/lib/rlab/assert/assertion.rb

@@ -0,0 +1,116 @@
+require "observer"
+
+module RLab
+  module Assert
+    class Assertion
+      include Observable
+
+      attr :fails
+      attr :passes
+      attr_accessor :source
+
+      def initialize subject_proc, checks
+        @subject_proc = subject_proc
+        @checks = checks
+        @passes = []
+        @fails  = []
+        @trace = caller_locations
+      end
+
+      def assert
+        changed
+        perform_checks
+        freeze
+        raise to_error if failed?
+        subject
+      ensure
+        notify_observers self
+      end
+
+      def build_checks
+        @checks.map do |check_name, argument|
+          resolve_check check_name, argument
+        end
+      end
+
+      def failed?
+        fails.any?
+      end
+
+      def file
+        @trace[0].path
+      end
+
+      def freeze
+        passes.freeze
+        fails.freeze
+      end
+
+      def line
+        @trace[0].lineno
+      end
+
+      def passed?
+        not failed?
+      end
+
+      def perform_checks
+        build_checks.each do |check|
+          check.evaluate
+          ary = if check.passed? then passes else fails end
+          ary.push check
+        end
+      end
+
+      def resolve_check check_name, argument
+        check = Checks.resolve check_name do
+          check_name = :include if check_name == :includes
+          argument = [check_name, *argument]
+          Checks[:predicate]
+        end
+        check.new subject_thunk, argument
+      end
+
+      def subject
+        subject_thunk.call
+      end
+
+      def subject_thunk
+        @subject_thunk ||= SubjectThunk.new @subject_proc
+      end
+
+      def to_error
+        AssertionFailed.new self
+      end
+
+      def trace
+        Assert.filter_trace @trace
+      end
+
+      class SubjectThunk
+        def initialize block
+          @block = block
+        end
+
+        def call
+          return @subject if subject_resolved?
+          @subject = @block.call
+        end
+
+        def expect_error
+          raise "called after initially fetched" if subject_resolved?
+          @block.call
+          nothing_raised = true
+        rescue => error
+          @subject = error
+        ensure
+          raise NothingRaised.new if nothing_raised
+        end
+
+        def subject_resolved?
+          instance_variable_defined? :@subject
+        end
+      end
+    end
+  end
+end

data/lib/rlab/assert/check.rb

@@ -0,0 +1,53 @@
+module RLab
+  module Assert
+    class Check
+      singleton_class.send :attr_reader, :block, :name
+
+      attr :argument
+
+      def initialize subject_thunk, argument
+        @argument = argument
+        @subject_thunk = subject_thunk
+      end
+
+      def evaluate
+        self.class.block.call self, @argument
+        freeze
+      end
+
+      def expect_error
+        @subject_thunk.expect_error
+      end
+
+      def fail message
+        passed = negated? ^ yield
+        @fail_message = message unless passed
+      end
+
+      def fail_message
+        "expected #{Assert.inspect subject} to#{" not" if negated?} #{@fail_message}"
+      end
+
+      def failed?
+        @fail_message ? true : false
+      end
+
+      def negated?
+        @negated ? true : false
+      end
+
+      def negate
+        @negated = !@negated
+      end
+
+      def passed?
+        not failed?
+      end
+
+      def subject
+        @expected_error or @subject_thunk.call
+      end
+
+    end
+  end
+end

data/lib/rlab/assert/checks/registry.rb

@@ -0,0 +1,31 @@
+module RLab
+  module Assert
+    module Checks
+      module Registry
+        def self.extended base
+          base.instance_variable_set :@registry, {}
+        end
+
+        def self.define check_name, block
+          klass = Class.new Check
+          klass.instance_variable_set :@block, block
+          constant_name = RLab::Util.to_camel_case check_name
+          const_set constant_name, klass
+          klass
+        end
+
+        attr :registry
+
+        def register check_name, &block
+          registry[check_name] = Registry.define check_name, block
+        end
+
+        def resolve check_name, &block
+          block ||= -> * do raise MissingCheck.new check_name end
+          registry.fetch check_name, &block
+        end
+        alias_method :[], :resolve
+      end
+    end
+  end
+end

data/lib/rlab/assert/checks.rb

@@ -0,0 +1,75 @@
+module RLab
+  module Assert
+    module Checks
+      extend Registry
+
+      register :equals do |check, object|
+        obj_inspect = Assert.inspect object
+
+        if Assert.inspect(check.subject) == obj_inspect and not check.negated?
+          fail_message = "equal other object (no difference in #inspect output)"
+        else
+          fail_message = "equal #{obj_inspect}"
+        end
+
+        check.fail fail_message do check.subject == object end
+      end
+
+      register :included_in do |check, list|
+        check.fail "be included in #{Assert.inspect list}" do
+          list.include? check.subject
+        end
+      end
+
+      register :kind_of do |check, type|
+        check.fail "be a kind of #{type}" do
+          check.subject.kind_of? type
+        end
+      end
+
+      register :matches do |check, matcher|
+        check.fail "match #{Assert.inspect matcher}" do
+          check.subject.match matcher
+        end
+      end
+
+      register :predicate do |check, argument|
+        name, *args = argument
+        method_name =  "#{name}?"
+        method = check.subject.method method_name
+
+        if method.arity == 0
+          expect_truth = args.all?
+          message = "be #{name}"
+          result = check.subject.public_send method_name
+          result = result ^ !expect_truth
+        else
+          result = check.subject.public_send method_name, *args
+          args = args.map &Assert.method(:inspect)
+          message = "#{name} #{args * ', '}"
+        end
+
+        check.fail message do result end
+      end
+
+      register :raises do |check, error_type|
+        check.expect_error
+        check.fail "be a #{Assert.inspect error_type}" do
+          check.subject.is_a? error_type
+        end
+      end
+
+      register :responds_to do |check, method_name|
+        check.fail "respond to ##{method_name}" do
+          check.subject.respond_to? method_name
+        end
+      end
+
+      register :truthy do |check, arg|
+        check.fail "be #{arg ? "truthy" : "falsey"}" do
+          !arg ^ check.subject
+        end
+      end
+    end
+  end
+end

data/lib/rlab/assert/errors.rb

@@ -0,0 +1,46 @@
+module RLab
+  module Assert
+    Error = Class.new StandardError
+
+    class AssertionFailed < Error
+      attr :assertion
+
+      def initialize assertion
+        @assertion = assertion
+      end
+
+      def backtrace
+        assertion.trace.map &:to_s
+      end
+
+      def to_s
+        failures = assertion.fails.map do |failed_check|
+          failed_check.fail_message
+        end
+        if failures.size > 1
+          "Assertion failure:\n\n    * #{failures * "\n    * "}\n"
+        else
+          "Assertion failure: #{failures * ", "}"
+        end
+      end
+    end
+
+    class MissingCheck < Error
+      attr :check_name
+
+      def initialize check_name
+        @check_name = check_name
+      end
+
+      def to_s
+        "could not resolve check #{check_name.inspect}"
+      end
+    end
+
+    class NothingRaised < Error
+      def to_s
+        "expected subject block to raise an error"
+      end
+    end
+  end
+end

data/lib/rlab/assert/minitest_integration.rb

@@ -0,0 +1,35 @@
+module RLab
+  module Assert
+    class MinitestIntegration
+      def self.load mt_test
+        instance = new mt_test
+        instance.load
+      end
+
+      def initialize mt_test
+        @mt_test = mt_test
+      end
+
+      def load
+        @mt_test.class_eval do
+          instance_methods.map(&:to_s).each do |instance_method|
+            next unless instance_method.match /^(?:assert|refute)/
+            next if instance_method.match /^assertions/
+            undef_method instance_method
+          end
+        end
+        Syntax.infect @mt_test, :observer => Observer.new
+      end
+
+      class Observer
+        def update assertion
+          return unless assertion.failed?
+          error = assertion.to_error
+          raise Minitest::Assertion, error.message
+        end
+      end
+    end
+
+    MinitestIntegration.load Minitest::Test
+  end
+end

data/lib/rlab/assert/refutation.rb

@@ -0,0 +1,11 @@
+module RLab
+  module Assert
+    class Refutation < Assertion
+      private
+
+      def build_checks
+        super.each &:negate
+      end
+    end
+  end
+end

data/lib/rlab/assert/syntax.rb

@@ -0,0 +1,109 @@
+module RLab
+  module Assert
+    class Syntax < Module
+      MISSING = :__rlab_assert_arg_missing__
+
+      class << self
+        def infect target, params = {}
+          assert, refute, observer = RLab::Util.extract_key_args params,
+            :method => :assert, :refute => :refute, :observer => nil
+          instance = new assert, refute, observer
+          if target.is_a? Class
+            target.send :include, instance
+          else
+            target.extend instance
+          end
+        end
+
+        # Public: assert is designed to be called a number of different ways,
+        # from 0 to 2 positional arguments, and maybe a block. Note that this
+        # method is a big nested ball of conditionals because I want it to
+        # perform well.
+        #
+        # subject_or_checks - the first optional argument passed in
+        # checks - the second optional argument passed in
+        # block - the &block parameter
+        #
+        # Valid examples:
+        #
+        #   assert :raises => Error do ̡… end
+        #   assert "foo"
+        #   assert 3, :included_in => [6, 3]
+        #   assert [6, 3], :includes => 3
+        #   assert :equal => 4 do 2 + 2 end
+        #
+        # Invalid examples:
+        #
+        #   # Can't determine if the block or 2 is the subject
+        #   assert 2, :equals => 4 do ̒… end 
+        #   # There's no subject at all
+        #   assert :incuded_in => 4
+        #
+        # Returns two arguments, the subject, and a checks hash. If the checks
+        # would be empty, returns { :truthy => true }. The subject will always be
+        # a Proc that gets lazy evaluated when the assertion is checked.
+        def decode_assert_arguments subject_or_checks, checks, block
+          if checks == MISSING
+            if subject_or_checks == MISSING
+              missing_subject! unless block
+              subject_thunk = block
+              checks = { :truthy => true }
+            elsif block
+              ambiguous_subject! unless subject_or_checks.is_a? Hash
+              subject_thunk = block
+              checks = subject_or_checks
+            else
+              subject_thunk = -> do subject_or_checks end
+              checks = { :truthy => true }
+            end
+          else
+            ambiguous_subject! if block
+            subject_thunk = -> do subject_or_checks end
+          end
+          [subject_thunk, checks]
+        end
+
+        def ambiguous_subject!
+          raise ArgumentError, "cannot supply a block subject *and* a positional subject"
+        end
+
+        def missing_subject!
+          raise ArgumentError, "must supply either a positional subject *or* a block subject (but not both)"
+        end
+      end
+
+      def initialize assert, refute, observer
+        @assert = assert
+        @refute = refute
+        @observer = observer
+      end
+
+      def refute?
+        @refute ? true : false
+      end
+
+      def extended base
+        graft base.singleton_class
+      end
+
+      def included base
+        graft base
+      end
+
+      def graft base
+        method_body = -> method_name, assertion_class, syntax, observer do
+          define_method method_name do |arg1 = MISSING, arg2 = MISSING, &block|
+          subject_thunk, checks = syntax.decode_assert_arguments arg1, arg2, block
+          assertion = assertion_class.new subject_thunk, checks
+          assertion.add_observer observer if observer
+          assertion.source = self
+          assertion.assert
+          end
+        end
+
+        base.class_exec @assert, Assertion, self.class, @observer, &method_body
+        base.class_exec @refute, Refutation,self.class, @observer, &method_body if refute?
+      end
+    end
+  end
+end

data/lib/rlab/assert/version.rb

@@ -0,0 +1,5 @@
+module RLab
+  module Assert
+    VERSION = "0.1.0"
+  end
+end

data/lib/rlab/assert.rb

@@ -0,0 +1,26 @@
+require_relative "assert/assertion"
+require_relative "assert/check"
+require_relative "assert/checks/registry"
+require_relative "assert/checks"
+require_relative "assert/errors"
+require_relative "assert/refutation"
+require_relative "assert/syntax"
+require_relative "assert/version"
+
+module RLab
+  module Assert
+    def self.filter_trace trace
+      assert_root = __FILE__.chomp ".rb"
+      trace.drop_while do |location|
+        full_path = File.expand_path location.path
+        full_path.start_with? assert_root
+      end
+    end
+
+    def self.inspect object, truncate = 100
+      raw = object.inspect
+      return raw if raw.size <= truncate
+      "#{raw[0..truncate - 2]} …\""
+    end
+  end
+end

data/rlab-assert.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path "../lib", __FILE__
+$LOAD_PATH.unshift lib unless $LOAD_PATH.include? lib
+require "rlab/assert/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "rlab-assert"
+  spec.version       = RLab::Assert::VERSION
+  spec.authors       = ["ntl"]
+  spec.email         = ["nathanladd+github@gmail.com"]
+
+  spec.summary       = %q{An alternative assert implementation}
+  spec.description   = %q{An alternative assert implementation designed for straightforward syntax and better debugging}
+  spec.homepage      = "https://github.com/ntl/rlab-assert"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f| f.match %r{^tests} end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep %r{^exe/} do |f| File.basename f end
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,103 @@
+--- !ruby/object:Gem::Specification
+name: rlab-assert
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- ntl
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-05-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: An alternative assert implementation designed for straightforward syntax
+  and better debugging
+email:
+- nathanladd+github@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".bundle/config"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/tests
+- lib/rlab/assert.rb
+- lib/rlab/assert/assertion.rb
+- lib/rlab/assert/check.rb
+- lib/rlab/assert/checks.rb
+- lib/rlab/assert/checks/registry.rb
+- lib/rlab/assert/errors.rb
+- lib/rlab/assert/minitest_integration.rb
+- lib/rlab/assert/refutation.rb
+- lib/rlab/assert/syntax.rb
+- lib/rlab/assert/version.rb
+- rlab-assert.gemspec
+homepage: https://github.com/ntl/rlab-assert
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.7
+signing_key: 
+specification_version: 4
+summary: An alternative assert implementation
+test_files: []