contraction 0.2.6 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e0f7aa54dcbe857b462c9f55a7b72e5462b25cec
+  data.tar.gz: 5b338f1f833a9434b61dfd0b423387398a6789ce
+SHA512:
+  metadata.gz: 4e31cc128163153debc169166fca37bb472473bfb55f24da2a629dbbe577e3b2080b001820c905cec99825b9942f74e2148c6d1905a5a289291bd724d175eebf
+  data.tar.gz: f73b4bb2677a13d62c56d935647d1775ab3480e7b5f68f1f18343f0f02010db443d20614a3e4e9b95f3691ef0ff92835d13420e7ad8b984bed163f13c5115cce

data/lib/parser.rb

@@ -1,6 +1,7 @@
 require 'string'
 require 'parser/type'
 require 'parser/lines'
+require 'parser/type_parser'
 require 'contract'
 
 module Contraction

data/lib/parser/type.rb

@@ -1,138 +1,24 @@
-# FIXME: Actually use the type parser in the actual parser... Duh.
 module Contraction
   module Parser
     class Type
-      attr_reader :legal_types, :method_requirements, :length, :key_types, :value_types
-
+      attr_reader :type
       def initialize(part)
-        @legal_types         = []
-        @method_requirements = []
-        @length              = -1
-        @key_types           = []
-        @value_types         = []
-
         parse(part)
       end
 
       # Checks weather or not thing is a given type.
-      # @param [String] thing A string containing a type definition. For example:
-      #    Array<String>
       def check(thing)
-        check_types(thing) &&
-        check_duck_typing(thing) &&
-        check_length(thing) &&
-        check_hash(thing)
+        return true unless type
+        type.check thing
       end
 
       private
 
       def parse(line)
-        parse_typed_container(line) ||
-          parse_duck_type(line) ||
-          parse_fixed_list(line) ||
-          parse_hash(line) ||
-          parse_short_hash_or_reference(line) ||
-          parse_regular(line)
-      end
-
-      def parse_typed_container(line)
-        return unless line.include? '<'
-        # It's some kind of container that can only hold certain things
-        list = line.match(/\<(?<list>[^\>]+)\>/)['list']
-        list.split(',').each do |type|
-          @legal_types << Type.new(type.strip)
-        end
-        true
-      end
-
-      def parse_duck_type(line)
-        return unless line =~ /^#/
-        # It's a duck-typed object of some kind
-        methods = line.split(",").map { |p| p.strip.gsub(/^#/,'').to_sym }
-        @method_requirements += methods
-        true
-      end
-
-      def parse_fixed_list(line)
-        return unless line.include?('(')
-        # It's a fixed-length list
-        list = line.match(/\((?<list>[^\>]+)\)/)['list']
-        parts = list.split(',')
-        @length = parts.length
-        parts.each do |type|
-          @legal_types << Type.new(type.strip)
-        end
-        true
-      end
-
-      def parse_hash(line)
-        return unless line.include? 'Hash{'
-        # It's a hash with specific key-value pair types
-        parts = line.match(/\{(?<key_types>.+)\s*=\>\s*(?<value_types>[^\}]+)\}/)
-        @key_types = parts['key_types'].split(',').map { |t| t.include?('#') ? t.strip.gsub(/^#/, '').to_sym : t.strip.constantize }
-        @value_types = parts['value_types'].split(',').map { |t| t.include?('#') ? t.strip.gsub(/^#/, '').to_sym : t.strip.constantize }
-      end
-
-      def parse_short_hash_or_reference(line)
-        return unless line.include? '{'
-        if parts = line.match(/\{(?<key_types>.+)\s*=\>\s*(?<value_types>[^\}]+)\}/)
-          @key_types = parts['key_types'].split(',').map { |t| t.include?('#') ? t.strip.gsub(/^#/, '').to_sym : t.strip.constantize }
-          @value_types = parts['value_types'].split(',').map { |t| t.include?('#') ? t.strip.gsub(/^#/, '').to_sym : t.strip.constantize }
-        else
-          # It's a reference to another documented type defined someplace in
-          # the codebase. We can ignore the reference, and treat it like a
-          # normal type.
-          @legal_types << line.gsub(/\{|\}/, '').constantize
-        end
-        true
-      end
-
-      def parse_regular(line)
-        # It's a regular-ass type.
-        @legal_types << line.constantize
-      end
-
-      def check_hash(thing)
-        return true if @key_types.empty? or @value_types.empty?
-        return false unless thing.is_a?(Hash)
-        thing.keys.all? do |k|
-          @key_types.any? { |kt| kt.is_a?(Symbol) ? k.respond_to?(kt) : k.is_a?(kt) }
-        end &&
-        thing.values.all? do |v|
-          @value_types.any? { |vt| vt.is_a?(Symbol) ? v.respond_to?(vt) : v.is_a?(vt) }
-        end
-      end
-
-      def check_length(thing)
-        return true if @length == -1
-        thing.length == @length
-      end
-
-      def check_duck_typing(thing)
-        return true if @method_requirements.empty?
-        @method_requirements.all? do |m|
-          thing.respond_to? m
-        end
-      end
-
-      def check_types(thing)
-        return true if @legal_types.empty?
-        if thing.is_a? Enumerable
-          types = @legal_types.map { |t| t.respond_to?(:legal_types) ? t.legal_types : t }.flatten
-          return thing.all? { |th| types.include?(th.class) }
-        else
-          @legal_types.any? do |t|
-            if t.is_a?(Contraction::Parser::Type)
-              #  Given the fact that we check enumerables above, we should never be here.
-              next false
-            end
-            if thing.is_a?(Enumerable)
-              thing.all? { |th| th.is_a?(t) }
-            else
-              thing.is_a?(t)
-            end
-          end
-        end
+        @type = Contraction::TypeParser.parse(line).first
+      rescue => e
+        puts e
+        @type = nil
       end
     end
   end

data/lib/parser/type_parser.rb

@@ -0,0 +1,374 @@
+module Contraction
+  # The lexer scans the input, creating a stack of tokens that can be used
+  # to then figure out our parse tree.
+  class TypeLexer
+    TOKENS = [
+      /^Hash/,
+      /^=>/,
+      /^\{/, /^\}/,
+      /^\[/, /^\]/,
+      /^\(/, /^\)/,
+      /^</, /^>/,
+      /^,/,
+      /^#/,
+      /([a-z_]+[a-z0-9_]*|(H(?!ash)))?[^=\{\[\(<>\)\]\},#]+/
+    ]
+
+    def self.lex(text)
+      stack = []
+      while text.length > 0
+        changed = false
+
+        TOKENS.each do |r|
+          if m = text.match(r)
+            if m[0].strip != ''
+              stack << m[0].strip
+            end
+            text.sub! r, ''
+            changed = true
+            break
+          end
+        end
+
+        raise "Unknown token found at #{text}" unless changed
+      end
+
+      stack.reverse
+    end
+  end
+
+  class Type
+    attr_reader :klass
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def works_as_a?(thing)
+      thing == klass || thing.is_a?(klass)
+    end
+
+    def check(thing)
+      works_as_a?(thing)
+    end
+  end
+
+  class DuckType
+    attr_reader :method
+    def initialize(method)
+      @method = method
+    end
+
+    def check(thing)
+      thing.respond_to? method.to_sym
+    end
+  end
+
+  class TypeList
+    attr_reader :types
+    def initialize(things)
+      @types = things.flatten
+    end
+
+    def works_as_a?(thing)
+      types.any? { |t| t.works_as_a? thing }
+    end
+
+    def check(thing)
+      # The only time that we need to match all instead of any is with
+      # duck-typing, so we just special-case it here.
+      if types.all? { |t| t.is_a? Contraction::DuckType }
+        return types.all? { |t| t.check(thing) }
+      else
+        return types.any? { |t| t.check(thing) }
+      end
+    end
+
+    def size
+      types.size
+    end
+  end
+
+  class HashType
+    attr_reader :key_type, :value_type
+    def initialize(key_type, value_type)
+      @key_type = key_type
+      @value_type = value_type
+    end
+
+    def check(thing)
+      thing.is_a?(Hash) &&
+        thing.keys.all? { |k| key_type.check(k) } &&
+        thing.values.all? { |v| value_type.check(v) }
+    end
+  end
+
+  class TypedContainer
+    attr_reader :type_list, :class_name
+
+    def initialize(class_type, type_list)
+      @type_list  = type_list
+      @class_name = class_type
+    end
+
+    def works_as_a?(thing)
+      type_list.works_as_a? thing
+    end
+
+    def check(thing)
+      return false if !class_name.nil? && !class_name.check(thing)
+      thing.all? { |v| type_list.works_as_a? v }
+    end
+  end
+
+  class SizedContainer < TypedContainer
+    def check(thing)
+      super && thing.size == type_list.size
+    end
+  end
+
+  class ReferenceType
+    attr_reader :klass
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def check(thing)
+      thing.is_a? klass
+    end
+  end
+
+  class TypeParser
+    def self.parse(string)
+      @stack = TypeLexer.lex(string)
+
+      # We are going to walk though this one at a time, popping off the
+      # end, and seeing if the list of thing we have so far matches any
+      # known rules, being as greedy as possible.
+      things = [:typed_container, :sized_container, :type_list, :reference, :hash, :duck_type]
+      something_happened = false
+      data = []
+      begin
+        something_happened = false
+        things.each do |t|
+          thing = send(t)
+          if thing
+            data << thing
+            something_happened = true
+          end
+        end
+      end while something_happened
+
+      raise "Type parse error #{@stack.reverse.join ' '}" unless @stack.compact.empty?
+      data.flatten
+    end
+
+    # A class name is anything that has a capitol first-letter
+    def self.class_name
+      thing = @stack.pop
+      return nil if thing.nil?
+      if thing[0] =~ /^[A-Z]/
+        return Type.new(thing.constantize)
+      else
+        @stack.push thing
+        return nil
+      end
+    end
+
+    # A duck-type is a thing prefaced with '#', indicating that it must have
+    # that method.
+    def self.duck_type
+      thing = @stack.pop
+      return nil if thing.nil?
+      if thing != '#'
+        @stack.push thing
+        return nil
+      end
+
+      DuckType.new @stack.pop
+    end
+
+    # A type is either hash, or any class-name like thing
+    def self.type
+      reference || hash || typed_container || sized_container || class_name || duck_type
+    end
+
+    # A type-list is a Type, optionally followed by a comma and another
+    # type-list
+    def self.type_list
+      things = []
+      things << type
+      return nil if things.first.nil?
+
+      things << @stack.pop
+      if things.last != ','
+        @stack.push things.pop
+        return TypeList.new things
+      end
+      things.pop # Remove the ',' from the list
+
+      things << type_list.types
+      TypeList.new(things.flatten)
+    end
+
+    # A hash starts with an optional "Hash", and this then followed by an
+    # opening {, followed by a type-list, followed by a fat arrow ("=>"),
+    # followed by another type-list, followed by a closing curly brace
+    # ("}")
+    def self.hash
+      things = []
+      things << @stack.pop
+      if things.first != 'Hash' && things.first != '{'
+        things.size.times { @stack.push things.pop }
+        return nil
+      end
+
+      if things.first == 'Hash'
+        things << @stack.pop
+      end
+
+      if things.last != '{'
+        things.size.times { @stack.push things.pop }
+        return nil
+      end
+
+      # Get the first type
+      key_type = type_list
+      if !key_type
+        things.size.times { @stack.push things.pop }
+        return nil
+      else
+        things << key_type
+      end
+
+      # And the arrow
+      things <<  @stack.pop
+      if things.last != '=>'
+        things.size.times { @stack.push things.pop }
+        return nil
+      end
+
+      # And the value type
+      value_type = type_list
+      if !value_type
+        things.size.times { @stack.push things.pop }
+        return nil
+      end
+
+      # Finally, the colosing brace
+      things << @stack.pop
+      if things.last != '}'
+        things.size.times { @stack.push things.pop }
+        return nil
+      end
+
+      HashType.new(key_type, value_type)
+    end
+
+    # A typed container is an optional class type, followed by a '<', followed
+    # by a type list, followed by a '>'
+    def self.typed_container
+      class_type = class_name
+
+      bracket = @stack.pop
+      if bracket.nil?
+        if class_type
+          @stack.push class_type.klass.to_s
+        end
+        return nil
+      end
+      if bracket != '<'
+        @stack.push bracket
+
+        if class_type
+          @stack.push class_type.klass.to_s
+        end
+        return nil
+      end
+
+      types = type_list
+      if !types
+        @stack.push bracket
+
+        if class_type
+          @stack.push class_type.klass.to_s
+        end
+        return nil
+      end
+
+      bracket2 = @stack.pop
+      if bracket2.nil? || bracket2 != '>'
+        raise "Expected '>', got #{bracket2}: #{@stack.inspect}"
+      end
+
+      TypedContainer.new(class_type, types)
+    end
+
+    # A reference is a "{" followed by a type, followed by a "}"
+    def self.reference
+      b = @stack.pop
+      return nil if b.nil?
+      if b != '{'
+        @stack.push b
+        return nil
+      end
+
+      t = class_name
+      if !t
+        @stack.push b
+        return nil
+      end
+
+      b2 = @stack.pop
+      if b2.nil? || b2 != '}'
+        @stack.push b2 if b2
+        @stack.push t.klass.to_s
+        @stack.push b
+        return nil
+      end
+
+      return ReferenceType.new t
+    end
+
+    # A sized container is like a typed container, except it has a type for
+    # every member of the set. So if there are 3 types in the type list, the
+    # final type must be a container with exactly three members, conforming to
+    # their respective types. An example would be a Vector3 class, with the
+    # initializer defined as either 3 floats, or a Array[Float, Float, Float]
+    def self.sized_container
+      class_type = class_name
+
+      bracket = @stack.pop
+      if bracket.nil?
+        if class_type
+          @stack.push class_type.klass.to_s
+        end
+        return nil
+      end
+      if bracket != '('
+        @stack.push bracket
+
+        if class_type
+          @stack.push class_type.klass.to_s
+        end
+        return nil
+      end
+
+      types = type_list
+      if !types
+        @stack.push bracket
+
+        if class_type
+          @stack.push class_type.klass.to_s
+        end
+        return nil
+      end
+
+      bracket2 = @stack.pop
+      if bracket2.nil? || bracket2 != ')'
+        raise "Expected ']', got #{bracket2}: #{@stack.inspect}"
+      end
+
+      SizedContainer.new(class_type, types)
+    end
+  end
+end

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: contraction
 version: !ruby/object:Gem::Version
-  version: 0.2.6
-  prerelease: 
+  version: 0.3.0
 platform: ruby
 authors:
 - Thomas Luce
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-19 00:00:00.000000000 Z
+date: 2014-07-22 00:00:00.000000000 Z
 dependencies: []
 description: Using RDoc documentation as your contract definition, you get solid code,
   and good docs. Win-win!
@@ -26,32 +25,29 @@ files:
 - lib/parser.rb
 - lib/parser/lines.rb
 - lib/parser/type.rb
+- lib/parser/type_parser.rb
 - lib/string.rb
 homepage: https://github.com/thomasluce/contraction
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: -2650941166078552798
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.2.2
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: A simple desgin-by-contract library
 test_files: []