assert_type 0.0.5 → 0.1.0

data/README.md

@@ -0,0 +1,72 @@
+assert_type
+===========
+
+Provides a simple method to make assertions about the type of a value,
+including nested types.
+
+## Installation
+
+    gem install assert_type
+
+## Example
+
+### Set-up
+
+#### In development
+
+Include the AssertType::AssertMethods module in Object,
+which will make the assert_type method available anywhere.
+
+It doesn't need to live in Object if you're not comfortable having it there.
+
+```ruby
+require 'assert_type'
+class Object
+  include AssertType::AssertMethods
+end
+```
+
+#### In production
+
+Include the AssertType::NoOpMethods module instead of AssertType::AssertMethods
+to include an assert_type method with the same signature that does nothing.
+
+```ruby
+require 'assert_type'
+class Object
+  include AssertType::NoOpMethods
+end
+```
+
+### Making assertions
+
+The first argument is the type string. It's based on YARD types. The entire YARD type syntax is not supported.
+
+```ruby
+assert_type "Array", []                                  # wont raise
+assert_type "Array", {}                                  # will raise AssertType::AssertionError
+
+assert_type "Array<Fixnum>", [1,2,3]                     # wont raise
+assert_type "Array<Fixnum>", []                          # wont raise
+assert_type "Array<Fixnum>", [1.1,2.2,3.3]               # will raise AssertType::AssertionError
+assert_type "Array<Fixnum>", nil                         # will raise AssertType::AssertionError
+
+assert_type "Array<Fixnum>, nil", [1,2,3]                # wont raise
+assert_type "Array<Fixnum>, nil", nil                    # wont raise
+
+assert_type "String, Symbol", "three"                    # wont raise
+assert_type "String, Symbol", :three                     # wont raise
+assert_type "String, Symbol", 3                          # will raise AssertType::AssertionError
+
+assert_type "Array<String, Symbol>", ["three"]           # wont raise
+assert_type "Array<String, Symbol>", [:three]            # wont raise
+assert_type "Array<String, Symbol>", []                  # wont raise
+assert_type "Array<String, Symbol>", [3]                 # will raise AssertType::AssertionError
+
+assert_type "Array<Set<Numeric>>", [Set.new([1,2])]      # wont raise
+assert_type "Array<Set<Numeric>>", [Set.new]             # wont raise
+assert_type "Array<Set<Numeric>>", []                    # wont raise
+assert_type "Array<Set<Numeric>>", [Set.new(["1","2"])]  # will raise AssertType::AssertionError
+assert_type "Array<Set<Numeric>>", [[1,2]]               # will raise AssertType::AssertionError
+assert_type "Array<Set<Numeric>>", [3]                   # will raise AssertType::AssertionError
+```

data/lib/assert_type.rb

@@ -9,29 +9,13 @@ require "assert_type/type_validator"
 module AssertType
 
   module AssertMethods
-    def at_assert truth
-      unless truth
-        raise AssertionError, "Expected truthy but was #{truth.inspect}"
-      end
-    end
-
-    def at_assert_equal expected, actual
-      unless expected == actual
-        raise AssertionError.new expected, actual
-      end
-    end
 
-    def at_assert_type expected_type, value
-      if expected_type.is_a? Class
-        unless expected_type === value
-          raise TypeAssertionError.new expected_type.to_s, value
-        end
-      elsif expected_type.is_a? Array
-        unless expected_type.any? {|t| t === value}
-          types = expected_type.join(' or ')
-          raise TypeAssertionError.new types, value
-        end
-      elsif expected_type.is_a? String
+    # @param expected_type [String] type string like "Array<Fixnum>"
+    # @param value [Object] value to check against type string
+    # @return [void]
+    # @raise [AssertType::AssertionError, AssertType::ParseError, AssertType::CallError]
+    def assert_type expected_type, value
+      if expected_type.is_a? String
         if node = AssertType::TypeStringParser.parse(expected_type)
           unless AssertType::TypeValidator.valid?(node, value)
             raise TypeAssertionError.new expected_type, value
@@ -43,17 +27,14 @@ module AssertType
         raise CallError.new
       end
     end
+
   end
 
   module NoOpMethods
-    def at_assert *args
-    end
 
-    def at_assert_equal *args
+    def assert_type *args
     end
 
-    def at_assert_type *args
-    end
   end
 
 end

data/lib/assert_type/type_string_parser.rb

@@ -1,5 +1,7 @@
 require File.expand_path('./type_string_tokeniser.rb', File.dirname(__FILE__))
 require File.expand_path('./type_node.rb', File.dirname(__FILE__))
+require File.expand_path('./parse_error.rb', File.dirname(__FILE__))
+
 
 module AssertType
   class TypeStringParser
@@ -14,6 +16,7 @@ module AssertType
     end
 
     def parse
+      quick_check_tokens
       root = TypeNode.root
       previous_word = root
       current_words = [root]
@@ -36,5 +39,33 @@ module AssertType
       @tokens ||= TypeStringTokeniser.tokenise @type_string
     end
 
+    def quick_check_tokens
+      unless check_angle_brackets_matched && check_angle_brackets_enclose_type
+        raise ParseError.new
+      end
+    end
+
+    def check_angle_brackets_matched
+      open_angle_brackets = 0
+      tokens.each do |token|
+        if token.name == :open_angle
+          open_angle_brackets += 1
+        elsif token.name == :close_angle
+          open_angle_brackets -= 1
+        end
+        return false if open_angle_brackets < 0
+      end
+      open_angle_brackets == 0
+    end
+
+    def check_angle_brackets_enclose_type
+      previous_name = nil
+      tokens.each do |token|
+        return false if previous_name == :open_angle && token.name != :word
+        previous_name = token.name
+      end
+      true
+    end
+
   end
 end

data/lib/assert_type/type_string_tokeniser.rb

@@ -1,3 +1,5 @@
+require File.expand_path('./parse_error.rb', File.dirname(__FILE__))
+
 module AssertType
   class TypeStringTokeniser
 
@@ -15,6 +17,7 @@ module AssertType
       while (t = next_token) do
         tokens << t
       end
+      raise ParseError.new unless @type_string.strip == ""
       tokens
     end
 

data/lib/assert_type/version.rb

@@ -1,3 +1,3 @@
 module AssertType
-  VERSION = "0.0.5"
+  VERSION = "0.1.0"
 end

data/spec/assert_type_spec.rb

@@ -4,32 +4,54 @@ include AssertType::AssertMethods
 
 describe AssertType do
 
-  it "quick and nasty tests" do
-
-    at_assert_type Array, []
-    at_assert_type "Array", []
-    at_assert_type "Array", [1,2,3]
-    at_assert_type "Array<Fixnum>", [1,2,3]
-    at_assert_type "Array<Fixnum>", []
-    expect { at_assert_type "Array<Fixnum>", ["one", "two", "three"] }.to raise_error(AssertType::AssertionError) { |error|
-      error.message.should include %{expected Array<Fixnum> but was}
-    }
-    at_assert_type [Fixnum, String], 1
-    at_assert_type [Fixnum, String], "1"
-    expect { at_assert_type [Fixnum, String], 1.1 }.to raise_error(AssertType::AssertionError) { |error|
-      error.message.should include %{expected Fixnum or String but was 1.1}
-    }
-    at_assert_type "Array<Fixnum>, nil", [1,2,3]
-    at_assert_type "Array<Fixnum>, nil", []
-    at_assert_type "Array<Fixnum>, nil", nil
-    at_assert_type "String, Symbol", "hello"
-    expect { at_assert_type "Array<Fixnum>, nil", false }.to raise_error(AssertType::AssertionError)
-    expect { at_assert_type "Array<Fixnum>, nil", [nil] }.to raise_error(AssertType::AssertionError)
-
-    at_assert_type "String, Symbol", "hello"
-    at_assert_type "String, Symbol", :Symbol
-    expect { at_assert_type "String, Symbol", 42 }.to raise_error(AssertType::AssertionError)
+  def self.example_valid expected_type, value
+    it "should not raise when asserting #{value.inspect} is a #{expected_type}" do
+      assert_type expected_type, value
+    end
+  end
+
+  def self.example_invalid expected_type, value
+    it "should raise assertion error when asserting #{value.inspect} is a #{expected_type}" do
+      expect { assert_type expected_type, value }.to raise_error(AssertType::AssertionError)
+    end
+  end
 
+  def self.example_call_error expected_type, value
+    it "should raise call error when asserting #{value.inspect} is a #{expected_type}" do
+      expect { assert_type expected_type, value }.to raise_error(AssertType::CallError)
+    end
   end
 
+  def self.example_parse_error expected_type, value
+    it "should raise parse error when asserting #{value.inspect} is a #{expected_type}" do
+      expect { assert_type expected_type, value }.to raise_error(AssertType::ParseError)
+    end
+  end
+
+  example_valid   "Array", []
+  example_valid   "Array", [1,2,3]
+
+  example_valid   "Array<Fixnum>", [1,2,3]
+  example_valid   "Array<Fixnum>", []
+  example_invalid "Array<Fixnum>", ["one", "two", "three"]
+
+  example_valid   "Array<Fixnum>, nil", [1,2,3]
+  example_valid   "Array<Fixnum>, nil", []
+  example_valid   "Array<Fixnum>, nil", nil
+  example_invalid "Array<Fixnum>, nil", false
+  example_invalid "Array<Fixnum>, nil", [nil]
+
+  example_valid   "String, Symbol", "hello"
+  example_valid   "String, Symbol", :Symbol
+  example_invalid "String, Symbol", 42
+
+  example_call_error Array, []
+  example_call_error [Fixnum, String], 1
+  example_call_error [1,2,3], "Array<Fixnum>"
+
+  example_parse_error "Array<", []
+  example_parse_error "Array<>", []
+  example_parse_error "Array>", []
+  example_parse_error "A{B => C}", []
+
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: assert_type
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 27
   prerelease: 
   segments: 
   - 0
+  - 1
   - 0
-  - 5
-  version: 0.0.5
+  version: 0.1.0
 platform: ruby
 authors: 
 - Joel Plane
@@ -30,6 +30,7 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - Gemfile
+- README.md
 - Rakefile
 - assert_type.gemspec
 - lib/assert_type.rb