taipo 1.0.0

data/lib/taipo/type_element.rb

@@ -0,0 +1,200 @@
+require 'taipo/exceptions'
+require 'taipo/type_element/child_type'
+require 'taipo/type_element/constraint'
+
+module Taipo
+
+  # An element representing a type (including children and constraints)
+  #
+  # @since 1.0.0
+  # @api private
+  class TypeElement
+
+    # The name of the element
+    #
+    # @since 1.0.0
+    # @api private
+    attr_accessor :name
+
+    # The child type collection for this element
+    #
+    # @since 1.0.0
+    # @api private
+    attr_accessor :child_type
+
+    # The constraint collection for this element
+    #
+    # @since 1.0.0
+    # @api private
+    attr_reader :constraints
+
+    # Initialize a new type element
+    #
+    # @param name [String] the name of this type
+    # @param child_type [Taipo::TypeElement::ChildType|NilClass] the child type
+    #   collection for this element
+    # @param constraints [Array<Taipo::TypeElement::Constraints>|NilClass] an
+    #   array of constraints for this element
+    #
+    # @raise [::TypeError] if +name+, +child_type+ or +constraints+ was of the
+    #   wrong type
+    # @raise [::ArgumentError] if +name+, +child_type+ or +constraints+ was
+    #   blank or empty, or +child_type+ or +constraints+ was non-nil and this
+    #   is a duck type (ie. a method the type responds to)
+    #
+    # @since 1.0.0
+    # @api private
+    def initialize(name:, child_type: nil, constraints: nil)
+      msg = 'Argument name was not a String.'
+      raise ::TypeError, msg unless name.is_a? String
+      msg = 'Argument name was an empty string.'
+      raise ::ArgumentError, msg if name.empty?
+      msg = 'Argument child_type was not Taipo::TypeElement::ChildType.'
+      raise ::TypeError, msg unless (
+                             child_type.nil? ||
+                             child_type.is_a?(Taipo::TypeElement::ChildType)
+                           )
+      msg = 'Argument child_type was empty.'
+      raise ::ArgumentError, msg if child_type&.empty?
+      msg = 'Argument constraints was not an Array.'
+      raise ::TypeError, msg unless (constraints.nil? || constraints.is_a?(Array))
+      msg = 'Argument constraints was empty.'
+      raise ::ArgumentError, msg if constraints&.empty?
+
+      if Taipo.instance_method? name
+        msg = 'Argument child_type should have been nil.'
+        raise ::ArgumentError, msg unless child_type.nil?
+        msg = 'Argument constraints should have been nil.'
+        raise ::ArgumentError, msg unless constraints.nil?
+
+        constraints = [
+          Taipo::TypeElement::Constraint.new(name: nil, value: name[1..-1])
+        ]
+        name = 'Object'
+      end
+      @name = name
+      @child_type = child_type
+      @constraints = constraints
+    end
+
+    # Compare the element with +comp+
+    #
+    # @param comp [Taipo::TypeElement] the comparison
+    #
+    # @return [Boolean] the result
+    #
+    # @raise [::TypeError] if +comp+ is of the wrong type
+    #
+    # @since 1.0.0
+    # @api private
+    def ==(comp)
+      msg = 'Object to be compared must be of type Taipo::TypeElement.'
+      raise ::TypeError, msg unless comp.is_a? Taipo::TypeElement
+
+      @name == comp.name && @child_type == comp.child_type
+    end
+
+    # Set the element's constraints to +csts+
+    #
+    # @param csts [Array<Taipo::TypeElement::Constraint] the constraints
+    #
+    # @raise [::TypeError] if +csts+ was not an Array
+    # @raise [Taipo::SyntaxError] if there are constraints with the same name
+    #
+    # @since 1.0.0
+    # @api private
+    def constraints=(csts)
+      msg = 'Argument csts was not an Array.'
+      raise ::TypeError, msg unless csts.is_a? Array
+
+      names = Hash.new
+      csts.each do |c|
+        msg = 'Contraints must have unique names.'
+        raise Taipo::SyntaxError, msg if names.key?(c.name)
+        if c.name == Taipo::TypeElement::Constraint::METHOD
+          names['#' + c.value] = true
+        else
+          names[c.name] = true
+        end
+      end
+      @constraints = csts
+    end
+
+    # Check if the argument matches the element
+    #
+    # @param arg [Object] the argument to compare
+    #
+    # @return [Boolean] the result
+    #
+    # @raise [Taipo::SyntaxError] if the element's +name+ is not defined (see
+    #   {#match_class?})
+    #
+    # @since 1.0.0
+    # @api private
+    def match?(arg)
+      match_class?(arg) && match_constraints?(arg) && match_child_type?(arg)
+    end
+
+    # Check if the class of the argument itself matches this element
+    #
+    # @param arg [Object] the argument to compare
+    #
+    # @return [Boolean] the result
+    #
+    # @raise [Taipo::SyntaxError] if the element's +name+ is not defined
+    #
+    # @since 1.0.0
+    # @api private
+    def match_class?(arg)
+      if @name == 'Boolean'
+        arg.is_a?(TrueClass) || arg.is_a?(FalseClass)
+      else
+        msg = "Class to match #{@name} is not defined"
+        raise Taipo::SyntaxError, msg unless Object.const_defined?(@name)
+        arg.is_a? Object.const_get(@name)
+      end
+    end
+
+    # Check if the class of the argument's child type matches
+    #
+    # @param arg [Object] the argument to compare
+    #
+    # @return [Boolean] the result
+    #
+    # @since 1.0.0
+    # @api private
+    def match_child_type?(arg)
+      self_childless = @child_type.nil?
+      arg_childless = !arg.is_a?(Enumerable) || arg.count == 0
+      return true if self_childless
+      return false if !self_childless && arg_childless
+
+      arg.all? do |a|
+        if a.is_a?(Array) # The elements of this collection have components
+          a.each.with_index.reduce(nil) do |memo,(component,index)|
+            result = @child_type[index].any? { |c| c.match? component }
+            (memo.nil?) ? result : memo && result
+          end
+        else # The elements of this collection have no components
+          @child_type.first.any? { |c| c.match? a }
+        end
+      end
+    end
+
+    # Check if the argument fits within the constraints
+    #
+    # @param arg [Object] the argument to compare
+    #
+    # @return [Boolean] the result
+    #
+    # @since 1.0.0
+    # @api private
+    def match_constraints?(arg)
+      return true if @constraints.nil?
+
+      @constraints.all? do |c|
+        c.constrain?(arg)
+      end
+    end
+  end
+end

data/lib/taipo/type_element/child_type.rb

@@ -0,0 +1,21 @@
+module Taipo
+  class TypeElement
+
+    # A collection of Taipo::TypeElement
+    # @since 1.0.0
+    # @api private
+    class ChildType < Array
+
+      # Initialize a new collection
+      #
+      # @param components [Array<Taipo::TypeElement>] the components that will make up the ChildType
+      #
+      # @since 1.0.0
+      # @api private 
+      def initialize(components = nil)
+        components.each { |c| self.push c } unless components.nil?
+      end
+    end
+  end
+end
+

data/lib/taipo/type_element/constraint.rb

@@ -0,0 +1,152 @@
+module Taipo
+  class TypeElement
+
+    # A constraint on a type
+    #
+    # @since 1.0.0
+    # @api private
+    class Constraint
+    
+      # The identifier for an instance method
+      #
+      # @since 1.0.0
+      # @api private
+      METHOD = '#'
+
+      # The name of the constraint
+      #
+      # @since 1.0.0
+      # @api private
+      attr_accessor :name
+
+      # The value of the constraint
+      #
+      # @since 1.0.0
+      # @api private
+      attr_reader :value
+
+      # Initialize a new constraint
+      #
+      # @param name [String|NilClass] the name of the constraint (if nil, this 
+      #   is an instance method)
+      # @param value [String|NilClass] the value of the constraint (sometimes a
+      #   Constraint is initialized before the value is known)
+      #
+      # @raise [::TypeError] if +name+ or +value+ were of the wrong type, or 
+      #   +value+ was not of the correct type for the type of constraint 
+      # @raise [::ArgumentError] if +name+ was blank
+      #
+      # @since 1.0.0
+      # @api private 
+      def initialize(name: nil, value: nil)
+        msg = 'Argument name was not nil or a String.'
+        raise ::TypeError, msg unless name.nil? || name.is_a?(String)
+        msg = 'Argument name was an empty string.'
+        raise ::ArgumentError, msg if name&.empty?
+
+        @name = (name.nil?) ? Constraint::METHOD : name
+        @value = self.parse_value value
+      end
+
+      # Check if +arg+ is within this constraint
+      #
+      # @param arg [Object] the object to check
+      #
+      # @return [Boolean] the result
+      #
+      # @since 1.0.0
+      # @api private
+      def constrain?(arg)
+        case @name
+        when Constraint::METHOD
+          arg.respond_to? @value
+        when 'format'
+          arg.is_a?(String) && arg =~ @value
+        when 'len'
+          arg.respond_to?('size') && arg.size == @value
+        when 'max'
+          if arg.is_a? Numeric
+            arg <= @value
+          else
+            arg.respond_to?('size') && arg.size <= @value
+          end
+        when 'min'
+          if arg.is_a? Numeric
+            arg <= @value
+          else
+            arg.respond_to?('size') && arg.size >= @value
+          end
+        when 'val'
+          if @value[0] == '"' && @value[-1] == '"'
+            arg.to_s == @value.slice(1..-2)
+          else
+            arg.to_s == @value
+          end
+        end
+      end
+
+      # Parse +v+ and convert to the appropriate form if necessary
+      #
+      # @param v [Object] the value
+      #
+      # @raise [::TypeError] if the value is not appropriate for this type of
+      #   constraint
+      #
+      # @since 1.0.0
+      # @api private
+      def parse_value(v)
+        return nil if v == nil
+
+        case @name
+        when Constraint::METHOD
+          v
+        when 'format'
+          return v if v.is_a? Regexp
+          msg = 'The value cannot be cast to a regular expression.'
+          raise ::TypeError, msg unless v[0] == '/' && v[-1] == '/'
+          Regexp.new v[1, v.length-2]
+        when 'len', 'max', 'min'
+          return v if v.is_a? Integer
+          msg = 'The value cannot be cast to an Integer.'
+          raise ::TypeError, msg unless v == v.to_i.to_s
+          v.to_i
+        when 'val'
+          v
+        end
+      end
+
+      # Return the String representation of this constraint
+      #
+      # @return [String] the String representation
+      #
+      # @since 1.0.0
+      # @api private
+      def to_s
+        name_string = (@name == Constraint::METHOD) ? '#' : @name + ':'
+        value_string = case @name
+                       when Constraint::METHOD
+                         @value
+                       when 'format'
+                         @value.inspect
+                       when 'len', 'max', 'min', 'val'
+                         @value.to_s
+                       end
+        name_string + value_string
+      end
+
+      # Set +v+ to be the value for this constraint
+      #
+      # @param v [Object] the value to set (this will be parsed using 
+      #   {#parse_value})
+      #
+      # @raise [::TypeError] if the value is not appropriate for this type of
+      #   constraint
+      #
+      # @since 1.0.0
+      # @api private
+      def value=(v)
+        @value = self.parse_value v
+      end
+    end
+  end
+end

data/lib/taipo/version.rb

@@ -0,0 +1,3 @@
+module Taipo
+  VERSION = "1.0.0"
+end

data/taipo.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'taipo/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "taipo"
+  spec.version       = Taipo::VERSION
+  spec.authors       = ["Michael Camilleri"]
+  spec.email         = ["dev@inqk.net"]
+
+  spec.summary       = %q{A simple library for checking the types of variables.}
+  spec.description   = %q{Taipo provides a simple way to check your variables are what you think they are. With an easy to use syntax you can call a single method and pass expressive type definitions.}
+  spec.homepage      = "https://github.com/pyrmont/taipo/"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ["lib"]
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+
+  spec.add_development_dependency "bundler", "~> 1.12"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.10.3"
+  spec.add_development_dependency "minitest-reporters", "~> 1.1.19"
+  spec.add_development_dependency "shoulda-context", "~> 1.2.0"
+  spec.add_development_dependency "yard", "~> 0.9.12"
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: taipo
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Michael Camilleri
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.10.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.10.3
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.19
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.19
+- !ruby/object:Gem::Dependency
+  name: shoulda-context
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.12
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.12
+description: Taipo provides a simple way to check your variables are what you think
+  they are. With an easy to use syntax you can call a single method and pass expressive
+  type definitions.
+email:
+- dev@inqk.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/taipo.rb
+- lib/taipo/cache.rb
+- lib/taipo/check.rb
+- lib/taipo/exceptions.rb
+- lib/taipo/exceptions/name_error.rb
+- lib/taipo/exceptions/syntax_error.rb
+- lib/taipo/exceptions/type_error.rb
+- lib/taipo/parser.rb
+- lib/taipo/parser/syntax_state.rb
+- lib/taipo/parser/validater.rb
+- lib/taipo/type_element.rb
+- lib/taipo/type_element/child_type.rb
+- lib/taipo/type_element/constraint.rb
+- lib/taipo/version.rb
+- taipo.gemspec
+homepage: https://github.com/pyrmont/taipo/
+licenses: []
+metadata:
+  allowed_push_host: https://rubygems.org
+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.6.13
+signing_key: 
+specification_version: 4
+summary: A simple library for checking the types of variables.
+test_files: []