assert_type 0.0.2 → 0.0.3

data/lib/assert_type/assertion_error.rb

@@ -1,9 +1,13 @@
+require File.expand_path("./error.rb", File.dirname(__FILE__))
+
 module AssertType
-  class AssertionError < RuntimeError
+  class AssertionError < Error
+
+    attr_reader :expected, :actual
 
-    def initialize expected, actual, expected_is_nested_type
-      @expected = expected_is_nested_type ? expected.to_s : expected.inspect
-      @actual = expected_is_nested_type ? actual.to_s : actual.inspect
+    def initialize expected, actual
+      @expected = expected
+      @actual = actual
     end
 
     def message

data/lib/assert_type/call_error.rb

@@ -1,4 +1,6 @@
+require File.expand_path("./error.rb", File.dirname(__FILE__))
+
 module AssertType
-  class CallError < RuntimeError
+  class CallError < Error
   end
 end

data/lib/assert_type/error.rb

@@ -0,0 +1,4 @@
+module AssertType
+  class Error < RuntimeError
+  end
+end

data/lib/assert_type/parse_error.rb

@@ -0,0 +1,6 @@
+require File.expand_path("./error.rb", File.dirname(__FILE__))
+
+module AssertType
+  class ParseError < Error
+  end
+end

data/lib/assert_type/type_assertion_error.rb

@@ -0,0 +1,11 @@
+require File.expand_path("./assertion_error.rb", File.dirname(__FILE__))
+
+module AssertType
+  class TypeAssertionError < AssertionError
+
+    def message
+      "assertion failed - expected #{@expected} but was #{@actual.inspect}"
+    end
+
+  end
+end

data/lib/assert_type/type_node.rb

@@ -0,0 +1,12 @@
+module AssertType
+  class TypeNode
+
+    attr_reader :name, :children
+
+    def initialize name
+      @name = name
+      @children = []
+    end
+
+  end
+end

data/lib/assert_type/type_string_parser.rb

@@ -0,0 +1,42 @@
+require File.expand_path('./type_string_tokeniser.rb', File.dirname(__FILE__))
+require File.expand_path('./type_node.rb', File.dirname(__FILE__))
+
+module AssertType
+  class TypeStringParser
+
+    # @param type_string [String] like Array<Fixnum>
+    def self.parse type_string
+      new(type_string).parse
+    end
+
+    def initialize type_string
+      @type_string = type_string
+    end
+
+    def parse
+      first_token = tokens.shift
+      main_type = first_token.value
+      node = TypeNode.new main_type
+      previous_word = node
+      current_words = []
+      tokens.each do |token|
+        case token.name
+          when :open_angle
+            current_words.push previous_word
+          when :close_angle
+            current_words.pop
+          when :word
+            current_words.last.children << (previous_word = TypeNode.new(token.value))
+          when :comma
+            # ignore commas
+        end
+      end
+      node
+    end
+
+    def tokens
+      @tokens ||= TypeStringTokeniser.tokenise @type_string
+    end
+
+  end
+end

data/lib/assert_type/type_string_tokeniser.rb

@@ -0,0 +1,45 @@
+module AssertType
+  class TypeStringTokeniser
+
+    # @param type_string [String] like Array<Fixnum>
+    def self.tokenise type_string
+      new(type_string).tokens
+    end
+
+    def initialize type_string
+      @type_string = type_string.strip
+    end
+
+    def tokens
+      tokens = []
+      while (t = next_token) do
+        tokens << t
+      end
+      tokens
+    end
+
+    private
+
+    Token = Struct.new :name, :value
+
+    TOKEN_MATCHERS = [
+      {:token_name => :word, :matcher => /^\w+/},
+      {:token_name => :open_angle, :matcher => /^</},
+      {:token_name => :close_angle, :matcher => /^>/},
+      {:token_name => :comma, :matcher => /^,/}
+    ]
+
+    # @return [Token, nil]
+    def next_token
+      value = nil
+      matcher = TOKEN_MATCHERS.detect do |tm_hash|
+        value = @type_string.scan(tm_hash[:matcher])[0]
+        !value.nil?
+      end
+      matcher && (Token.new(matcher[:token_name], value).tap do |t|
+        @type_string = (@type_string.slice(value.length, @type_string.length) || '').strip
+      end)
+    end
+
+  end
+end

data/lib/assert_type/type_validator.rb

@@ -0,0 +1,32 @@
+module AssertType
+  class TypeValidator
+    class << self
+
+      # @param type_node [AssertType::TypeNode]
+      # @param value [Object]
+      def valid? type_node, value
+        type_node.name == value.class.to_s &&
+        children_valid?(type_node, value)
+      end
+
+      private
+
+      def children_valid? type_node, value
+        type_node.children.empty? ||
+        value_empty?(value) ||
+        type_node.children.any? do |node|
+          valid?(node, value_first_child(value))
+        end
+      end
+
+      def value_first_child value
+        value.first
+      end
+
+      def value_empty? value
+        value.empty?
+      end
+
+    end
+  end
+end

data/lib/assert_type/version.rb

@@ -1,3 +1,3 @@
 module AssertType
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/assert_type.rb

@@ -1,6 +1,8 @@
 require "assert_type/version"
 require "assert_type/assertion_error"
+require "assert_type/type_assertion_error"
 require "assert_type/call_error"
+require "assert_type/parse_error"
 
 module AssertType
 
@@ -13,37 +15,30 @@ module AssertType
 
     def at_assert_equal expected, actual
       unless expected == actual
-        raise AssertionError.new expected, actual, false
+        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 AssertionError.new expected_type, value, false
+          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.collect do |t|
-            "<#{t}>"
-          end.join(' or ')
-          raise AssertionError.new types, value, true
+          types = expected_type.join(' or ')
+          raise TypeAssertionError.new types, value
         end
-      else
-        if (matches = expected_type.match /([a-zA-Z0-9]+)\<([a-zA-Z0-9]+)\>/)
-          enumerable_type = matches[1]
-          child_type = matches[2]
-          e_type = Object.const_get(enumerable_type)
-          c_type = Object.const_get(child_type)
-          unless e_type === value
-            raise AssertionError.new e_type, value, false
-          end
-          unless value.first.nil? || c_type === value.first
-            raise AssertionError.new "#{e_type}<#{c_type}>", "#{e_type}<#{value.first.class}>", true
+      elsif expected_type.is_a? String
+        if node = AssertType::TypeStringParser.parse(expected_type)
+          unless AssertType::TypeValidator.valid?(node, value)
+            raise TypeAssertionError.new expected_type, value
           end
         else
-          raise CallError.new
+          raise ParseError.new
         end
+      else
+        raise CallError.new
       end
     end
   end

data/spec/assert_type_spec.rb

@@ -7,16 +7,17 @@ describe AssertType do
   it "quick and nasty tests" do
 
     at_assert_type Array, []
-    expect { at_assert_type "Array", [] }.to raise_error AssertType::CallError
+    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 Array<String>}
+      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}
+      error.message.should include %{expected Fixnum or String but was 1.1}
     }
 
   end

data/spec/type_string_parser_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require File.expand_path('../lib/assert_type/type_string_parser.rb', File.dirname(__FILE__))
+
+module AssertType
+  describe TypeStringParser do
+
+    context "converts string to node tree" do
+
+      it "example: Array" do
+        node = TypeStringParser.parse("Array")
+        node.name.should == "Array"
+        node.children.length.should == 0
+      end
+
+      it "example: Array<Fixnum>" do
+        node = TypeStringParser.parse("Array<Fixnum>")
+        node.name.should == "Array"
+        node.children.length.should == 1
+        node.children.first.name.should == "Fixnum"
+      end
+
+      it "example: Array<Fixnum, String>" do
+        node = TypeStringParser.parse("Array<Fixnum, String>")
+        node.name.should == "Array"
+        node.children.length.should == 2
+        node.children[0].name.should == "Fixnum"
+        node.children[1].name.should == "String"
+      end
+
+      it "example: Array<Array<Fixnum>, Array<String>>" do
+        node = TypeStringParser.parse("Array<Array<Fixnum>, Array<String>>")
+        node.name.should == "Array"
+        node.children.length.should == 2
+        node.children[0].name.should == "Array"
+        node.children[1].name.should == "Array"
+        node.children[0].children.length.should == 1
+        node.children[0].children[0].name.should == "Fixnum"
+        node.children[1].children.length.should == 1
+        node.children[1].children[0].name.should == "String"
+      end
+
+    end
+
+  end
+end

data/spec/type_string_tokeniser_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require File.expand_path('../lib/assert_type/type_string_tokeniser.rb', File.dirname(__FILE__))
+
+module AssertType
+  describe TypeStringTokeniser do
+
+    it "converts string to array of tokens" do
+
+      TypeStringTokeniser.tokenise("Array<Fixnum>").collect{|t|[t.name,t.value]}.should == [
+        [:word, "Array"], [:open_angle, "<"], [:word, "Fixnum"], [:close_angle, ">"]
+      ]
+
+      TypeStringTokeniser.tokenise("Array<Fixnum, String>").collect{|t|[t.name,t.value]}.should == [
+        [:word, "Array"], [:open_angle, "<"], [:word, "Fixnum"], [:comma, ","], [:word, "String"], [:close_angle, ">"]
+      ]
+
+    end
+
+  end
+end

data/spec/type_validator_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+require File.expand_path('../lib/assert_type/type_validator.rb', File.dirname(__FILE__))
+
+module AssertType
+  describe TypeValidator do
+
+    it "example: Array" do
+      node = stub("TypeNode", :name => "Array", :children => [])
+      TypeValidator.valid?(node, []).should be_true
+      TypeValidator.valid?(node, [1,2,3]).should be_true
+      TypeValidator.valid?(node, ["one","two","three"]).should be_true
+      TypeValidator.valid?(node, {}).should be_false
+    end
+
+    it "example: Set" do
+      node = stub("TypeNode", :name => "Set", :children => [])
+      TypeValidator.valid?(node, Set.new).should be_true
+      TypeValidator.valid?(node, Set.new([1,2,3])).should be_true
+      TypeValidator.valid?(node, Set.new(["one","two","three"])).should be_true
+      TypeValidator.valid?(node, []).should be_false
+      TypeValidator.valid?(node, [1,2,3]).should be_false
+      TypeValidator.valid?(node, ["one","two","three"]).should be_false
+      TypeValidator.valid?(node, {}).should be_false
+    end
+
+    it "example: Hash" do
+      node = stub("TypeNode", :name => "Hash", :children => [])
+      TypeValidator.valid?(node, {}).should be_true
+      TypeValidator.valid?(node, {:one => 1, :two => 2}).should be_true
+      TypeValidator.valid?(node, []).should be_false
+      TypeValidator.valid?(node, [1,2,3]).should be_false
+      TypeValidator.valid?(node, ["one","two","three"]).should be_false
+    end
+
+    it "example: Array<Fixnum>" do
+      node = stub("TypeNode", :name => "Array", :children => [
+        stub("TypeNode", :name => "Fixnum", :children => [])
+      ])
+      TypeValidator.valid?(node, [1,2,3]).should be_true
+      TypeValidator.valid?(node, []).should be_true
+      TypeValidator.valid?(node, ["one", "two", "three"]).should be_false
+    end
+
+    it "example: Array<Fixnum, String>" do
+      node = stub("TypeNode", :name => "Array", :children => [
+        stub("TypeNode", :name => "Fixnum", :children => []),
+        stub("TypeNode", :name => "String", :children => [])
+      ])
+      TypeValidator.valid?(node, [1,2,3]).should be_true
+      TypeValidator.valid?(node, ["one", "two", "three"]).should be_true
+      TypeValidator.valid?(node, []).should be_true
+      TypeValidator.valid?(node, [1.1,2.2,3.3]).should be_false
+    end
+
+    it "example: Array<Array<Fixnum>>" do
+      node = stub("TypeNode", :name => "Array", :children => [
+        stub("TypeNode", :name => "Array", :children => [
+          stub("TypeNode", :name => "Fixnum", :children => [])
+        ])
+      ])
+      TypeValidator.valid?(node, [[1,2,3]]).should be_true
+      TypeValidator.valid?(node, [[]]).should be_true
+      TypeValidator.valid?(node, []).should be_true
+      TypeValidator.valid?(node, [1,2,3]).should be_false
+      TypeValidator.valid?(node, ["one", "two", "three"]).should be_false
+      TypeValidator.valid?(node, [["one", "two", "three"]]).should be_false
+
+    end
+
+    it "example: Array<Set<Fixnum>>" do
+      node = stub("TypeNode", :name => "Array", :children => [
+        stub("TypeNode", :name => "Set", :children => [
+          stub("TypeNode", :name => "Fixnum", :children => []),
+        ])
+      ])
+
+      TypeValidator.valid?(node, [Set.new([1,2,3])]).should be_true
+      TypeValidator.valid?(node, [Set.new]).should be_true
+      TypeValidator.valid?(node, []).should be_true
+      TypeValidator.valid?(node, [Set.new(["one", "two", "three"])]).should be_false
+      TypeValidator.valid?(node, [{}]).should be_false
+      TypeValidator.valid?(node, [[]]).should be_false
+    end
+
+    ## Note: we can't parse this yet
+    #xit "example: Hash{Symbol => Fixnum}" do
+    #  node = stub("TypeNode", :name => "Hash", :children => [
+    #    stub("TypeNode", :name => "_params", :children => [
+    #      stub("TypeNode", :name => "Symbol", :children => []),
+    #      stub("TypeNode", :name => "Fixnum", :children => [])
+    #    ])
+    #  ])
+    #  TypeValidator.valid?(node, {}).should be_true
+    #  TypeValidator.valid?(node, {:one => 1, :two => 2}).should be_true
+    #  TypeValidator.valid?(node, {:one => "1", :two => "2"}).should be_false
+    #  TypeValidator.valid?(node, []).should be_false
+    #  TypeValidator.valid?(node, [1,2,3]).should be_false
+    #  TypeValidator.valid?(node, ["one","two","three"]).should be_false
+    #end
+
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: assert_type
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 25
   prerelease: 
   segments: 
   - 0
   - 0
-  - 2
-  version: 0.0.2
+  - 3
+  version: 0.0.3
 platform: ruby
 authors: 
 - Joel Plane
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2013-01-14 00:00:00 Z
+date: 2013-01-15 00:00:00 Z
 dependencies: []
 
 description: A method for very basic nested type assertions
@@ -35,9 +35,19 @@ files:
 - lib/assert_type.rb
 - lib/assert_type/assertion_error.rb
 - lib/assert_type/call_error.rb
+- lib/assert_type/error.rb
+- lib/assert_type/parse_error.rb
+- lib/assert_type/type_assertion_error.rb
+- lib/assert_type/type_node.rb
+- lib/assert_type/type_string_parser.rb
+- lib/assert_type/type_string_tokeniser.rb
+- lib/assert_type/type_validator.rb
 - lib/assert_type/version.rb
 - spec/assert_type_spec.rb
 - spec/spec_helper.rb
+- spec/type_string_parser_spec.rb
+- spec/type_string_tokeniser_spec.rb
+- spec/type_validator_spec.rb
 homepage: ""
 licenses: []