nrser 0.0.15 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 87e8fd49793cd5ab294a3228fef5d7745aac398b
-  data.tar.gz: e6caa34bb3336e50e689d1142680ed7796e512f7
+  metadata.gz: 4bdcf46a3991ba3ea386aa2599d03dd3f9bbbfff
+  data.tar.gz: d59e2df7bcead37764dbe4d167eeed44f2e0e22f
 SHA512:
-  metadata.gz: c81efda7e8c7d3a01cd2dc5220225ea6cb7edd8d043aaccb3cbd03bfaa23bf4ffb7566cce9dbde92869c3a230f7561b95d9f4c1760933b45a8731abaefd3ef6b
-  data.tar.gz: 7380a8705ee19f7cb6d8b5d602b6a852c7b2b6c84a47b0ba8bdd20999e6720c4cb2551d3d26ad0bf346e3da04ca16beb80d437b319dc80ff496221ac31136f7b
+  metadata.gz: 1c4985fc5450eaa3c2989b813b83d477e28b3a07dedecb2c0158ca182f484a9106edfe26d56957188829d642dba614ad75510851125be124732b280ebb0ba66e
+  data.tar.gz: 4898d4bd6023429747b7e657fbecb9dc614daa1ba7a7dfe39c419b36f9714c75ce44d18a4f6144e51f02592b6e11d6bb20619d916b3b684a22b7c1a86addecf1

data/.gitignore

@@ -21,3 +21,14 @@ tmp
 *.a
 mkmf.log
 tmp/
+##############################################################################
+# BEGIN Qb.gitingore
+#
+# generated qb playbooks
+.qb-playbook.yml
+
+# ansible retry files
+.qb-playbook.retry
+#
+# END Qb.gitingore
+##############################################################################

data/lib/nrser.rb

@@ -114,3 +114,5 @@ module NRSER
 
   end # class << self
 end
+
+require "nrser/types"

data/lib/nrser/refinements.rb

@@ -1,3 +1,5 @@
+require 'pathname'
+
 module NRSER
   refine Object do
     def pipe
@@ -38,4 +40,38 @@ module NRSER
       NRSER.template self, str
     end
   end
+  
+  refine Pathname do
+    # override to accept Pathname instances.
+    # 
+    # @param [String] *prefixes
+    #   the prefixes to see if the Pathname starts with.
+    # 
+    # @return [Boolean]
+    #   true if the Pathname starts with any of the prefixes.
+    # 
+    def start_with? *prefixes
+      to_s.start_with? *prefixes.map(&:to_s)
+    end
+    
+    # override sub to support Pathname instances as patterns.
+    # 
+    # @param [String | Regexp | Pathname] pattern
+    #   thing to replace.
+    # 
+    # @param [String | Hash] replacement
+    #   thing to replace it with.
+    # 
+    # @return [Pathname]
+    #   new Pathname.
+    # 
+    def sub pattern, replacement
+      case pattern
+      when Pathname
+        super pattern.to_s, replacement
+      else
+        super pattern, replacement
+      end
+    end
+  end # Pathname
 end # NRSER

data/lib/nrser/types.rb

@@ -0,0 +1,75 @@
+require 'pp'
+
+require 'nrser/refinements'
+require 'nrser/types/type'
+require 'nrser/types/is'
+require 'nrser/types/is_a'
+require 'nrser/types/where'
+require 'nrser/types/combinators'
+require 'nrser/types/maybe'
+require 'nrser/types/attrs'
+
+using NRSER
+  
+module NRSER::Types
+  # make a type.
+  def self.make value
+    if value.is_a? NRSER::Types::Type
+      value
+    elsif value.is_a? ::Class
+      IsA.new value
+    else
+      Is.new value
+    end
+  end
+  
+  # raise an error if value doesn't match type.
+  def self.check value, type
+    make(type).check value
+  end
+  
+  def self.test value, type
+    make(type).test value
+  end
+  
+  def self.match value, type_map
+    type_map.each {|type, block|
+      if test value, type
+        return block.call value
+      end
+    }
+    
+    raise TypeError, <<-END.dedent
+      could not match value
+      
+        #{ value.inspect }
+      
+      to any of types
+      
+          #{ type_map.keys.map {|type| "\n    #{ type.inspect }"} }
+      
+    END
+  end
+  
+  # make a type instance from a object representation that can come from 
+  # a YAML or JSON declaration.
+  def self.from_repr repr
+    match repr, {
+      str => ->(string) {
+        NRSER::Types.method(string.downcase).call
+      },
+      
+      Hash => ->(hash) {
+        
+      },
+    }
+  end
+end # NRSER::Types
+
+# things that define values, which may need to call the functions defined
+# above
+require 'nrser/types/any'
+require 'nrser/types/booleans'
+require 'nrser/types/numbers'
+require 'nrser/types/strings'
+require 'nrser/types/array'

data/lib/nrser/types/any.rb

@@ -0,0 +1,13 @@
+require 'nrser/refinements'
+require 'nrser/types/where'
+
+using NRSER
+  
+module NRSER::Types
+  ANY = where(name: 'Any', from_s: ->(s) { s }) { true }
+  
+  # anything
+  def self.any
+    ANY
+  end
+end # NRSER::Types

data/lib/nrser/types/array.rb

@@ -0,0 +1,61 @@
+require 'nrser/refinements'
+require 'nrser/types/type'
+require 'nrser/types/is_a'
+
+using NRSER
+  
+module NRSER::Types
+  class Array < IsA
+    SEP = /\,\s+/
+    
+    attr_reader :item_type
+    
+    def initialize item_type = NRSER::Types.any, **options
+      super ::Array, **options
+      @item_type = NRSER::Types.make item_type
+    end
+    
+    def test value
+      super(value) && if @item_type == NRSER::Types.any
+        true
+      else
+        value.all? {|v| @item_type.test v}
+      end
+    end
+    
+    def default_name
+      "#{ self.class.short_name }<#{ @item_type }>"
+    end
+    
+    def has_from_s?
+      @item_class.has_from_s?
+    end
+    
+    def from_s s
+      # does it looks like json?
+      if s.start_with? '['
+        begin
+          return JSON.load s
+        rescue
+        end
+      end
+      
+      s.split SEP
+    end
+    
+    def == other
+      equal?(other) || (
+        other.class == self.class && @item_type == other.item_type
+      )
+    end
+  end # Array
+  
+  # array
+  def self.array *args
+    Array.new *args
+  end
+  
+  def self.list
+    array
+  end
+end # NRSER::Types

data/lib/nrser/types/attrs.rb

@@ -0,0 +1,69 @@
+require 'nrser/refinements'
+require 'nrser/types/type'
+require 'nrser/types/combinators'
+
+using NRSER
+  
+module NRSER::Types
+  class Attrs < NRSER::Types::Type
+    def initialize attrs, **options
+      super **options
+      @attrs = attrs
+    end
+    
+    def default_name
+      attrs_str = @attrs.map {|name, type|
+        "#{ name }=#{ type.name }"
+      }.join(', ')
+      
+      "#{ self.class.short_name }(#{ attrs_str })"
+    end
+    
+    def test value
+      @attrs.all? {|name, type|
+        value.respond_to?(name) && type.test(value.method(name).call)
+      }
+    end
+  end # Attrs
+  
+  def self.attrs attrs, options = {}
+    Attrs.new attrs, **options
+  end
+  
+  def self.length *args
+    bounds = {}
+    options = {}
+    
+    case args.length
+    when 1
+      case args[0]
+      when ::Integer
+        bounds[:min] = bounds[:max] = non_neg_int.check(args[0])
+        
+      when ::Hash
+        options = args[0].reject {|k, v|
+          if k == :min || k == :max
+            bounds[k] = non_neg_int.check(v)
+          end
+        }
+        
+      else        
+        raise ArgumentError, <<-END.squish
+          arg must be positive integer or option hash, found:
+          #{ args[0].inspect } of type #{ args[0].class }
+        END
+      end
+      
+    when 2
+      bounds[:min] = bounds[:max] = non_neg_int.check(args[0])
+      options = args[1]
+      
+    else
+      raise ArgumentError, <<-END.squish
+        must provided 1 or 2 args.
+      END
+    end
+    
+    attrs({length: intersection(non_neg_int, bounded(bounds))}, options)
+  end
+end # NRSER::Types

data/lib/nrser/types/booleans.rb

@@ -0,0 +1,47 @@
+require 'nrser/refinements'
+require 'nrser/types/type'
+require 'nrser/types/is'
+require 'nrser/types/combinators'
+
+using NRSER
+  
+module NRSER::Types
+  # booleans
+  # ========
+  
+  TRUE = is true, name: 'true', from_s: ->(string) {
+    if ['true', 't', '1', 'yes', 'y', 'on'].include? string.downcase
+      true
+    else
+      raise TypeError, "can not convert to true: #{ string.inspect }"
+    end
+  }
+  
+  def self.true
+    TRUE
+  end
+  
+  FALSE = is false, name: 'false', from_s: ->(string) {
+    if ['false', 'f', '0', 'no', 'n', 'off'].include? string.downcase
+      false
+    else
+      raise TypeError, "can not convert to true: #{ string.inspect }"
+    end
+  }
+  
+  def self.false
+    FALSE
+  end
+  
+  BOOL = union TRUE, FALSE
+  
+  # true or false
+  def self.bool
+    BOOL
+  end
+  
+  def self.boolean
+    bool
+  end
+  
+end # NRSER::Types

data/lib/nrser/types/bounded.rb

@@ -0,0 +1,36 @@
+require 'nrser/refinements'
+require 'nrser/types/type'
+
+using NRSER
+  
+module NRSER::Types  
+  class Bounded < NRSER::Types::Type
+    def initialize **options
+      @min = options[:min]
+      @max = options[:max]
+    end
+    
+    def test value
+      return false if @min && value < @min
+      return false if @max && value > @max
+      true
+    end
+    
+    def default_name
+      attrs_str = ['min', 'max'].map {|name|
+        [name, instance_variable_get("@#{ name }")]
+      }.reject {|name, value|
+        value.nil?
+      }.map {|name, value|
+        "#{ name }=#{ value }"
+      }.join(', ')
+      
+      "#{ self.class.short_name }(#{ attrs_str })"
+    end
+  end # Bounded
+  
+  def self.bounded **options
+    Bounded.new **options
+  end
+   
+end # NRSER::Types

data/lib/nrser/types/combinators.rb

@@ -0,0 +1,86 @@
+require 'nrser/refinements'
+require 'nrser/types/type'
+
+using NRSER
+
+# base class for Union and Intersection which combine over a set of types.
+module NRSER::Types
+  class Combinator < NRSER::Types::Type
+    attr_reader :types
+    
+    def initialize *types, **options
+      super **options
+      @types = types.map {|type| NRSER::Types.make type}
+    end
+    
+    def name
+      @name || (
+        "#{ self.class.short_name }(" + 
+        @types.map {|type| type.name }.join(',') + 
+        ")"
+      )
+    end
+    
+    # a combinator may attempt to parse from a string if any of it's types
+    # can do so
+    def has_from_s?
+      @types.any? {|type| type.has_from_s?}
+    end
+    
+    # a combinator iterates through each of it's types, trying the
+    # conversion and seeing if the result satisfies the combinator type
+    # itself. the first such value found is returned.
+    def from_s s
+      @types.each {|type|
+        if type.respond_to? :from_s
+          begin
+            return check type.from_s(s)
+          rescue TypeError => e
+            # pass
+          end
+        end
+      }
+      
+      raise TypeError,
+        "none of union types could convert #{ string.inspect }"
+    end
+    
+    def == other
+      equal?(other) || (
+        other.class == self.class && other.types == @types
+      )
+    end
+  end
+  
+  class Union < Combinator        
+    def test value
+      @types.any? {|type| type.test value}
+    end
+  end # Union
+  
+  # match any of the types
+  def self.union *types, **options
+    NRSER::Types::Union.new *types, **options
+  end
+  
+  # match any of the types
+  def self.one_of *types, **options
+    union *types, **options
+  end
+  
+  class Intersection < Combinator      
+    def test value
+      @types.all? {|type| type.test value}
+    end
+  end
+  
+  # match all of the types
+  def self.intersection *types, **options
+    Intersection.new *types, **options
+  end
+  
+  # match all of the types
+  def self.all_of *types, **options
+    intersection *types, **options
+  end
+end # NRSER::Types

data/lib/nrser/types/hash.rb

@@ -0,0 +1,15 @@
+require 'nrser/refinements'
+require 'nrser/types/type'
+
+using NRSER
+  
+module NRSER::Types
+
+  class Hash < NRSER::Types::Type
+    attr_reader :keys, :values, :including, :exactly, :min, :max
+    
+    def initialize options = {}
+      
+    end
+  end # Hash
+end

data/lib/nrser/types/is.rb

@@ -0,0 +1,33 @@
+require 'nrser/refinements'
+require 'nrser/types/type'
+using NRSER
+
+module NRSER::Types
+  class Is < NRSER::Types::Type
+    attr_reader :value
+    
+    def initialize value, **options
+      super **options
+      
+      @value = value
+    end
+    
+    def name
+      "Is(#{ @value.inspect })"
+    end
+    
+    def test value
+      @value.equal? value
+    end
+    
+    def == other
+      equal?(other) || @value === other.value
+    end
+  end # Is
+  
+  # an exact value (using ===)
+  def self.is value, **options
+    Is.new value, **options
+  end
+  
+end # NRSER::Types

data/lib/nrser/types/is_a.rb

@@ -0,0 +1,27 @@
+require 'nrser/refinements'
+require 'nrser/types/type'
+using NRSER
+
+module NRSER::Types
+  class IsA < NRSER::Types::Type
+    attr_reader :klass
+    
+    def initialize klass, **options
+      super **options
+      @klass = klass
+    end
+    
+    def name
+      @name || "#{ self.class.short_name }(#{ @klass })"
+    end
+    
+    def test value
+      value.is_a? @klass
+    end
+  end # IsA
+  
+  # class membership
+  def self.is_a klass
+    IsA.new klass
+  end
+end # NRSER::Types

data/lib/nrser/types/maybe.rb

@@ -0,0 +1,11 @@
+require 'nrser/refinements'
+require 'nrser/types/combinators'
+
+using NRSER
+  
+module NRSER::Types
+  # nil or the argument type
+  def self.maybe type
+    union nil, type, name: "Maybe(#{ type.name })"
+  end
+end # NRSER::Types

data/lib/nrser/types/numbers.rb

@@ -0,0 +1,100 @@
+require 'nrser/refinements'
+require 'nrser/types/type'
+require 'nrser/types/is_a'
+require 'nrser/types/combinators'
+require 'nrser/types/bounded'
+
+using NRSER
+  
+module NRSER::Types
+  def self.parse_number s
+    float = s.to_f
+    int = float.to_i
+    if float == int then int else float end
+  end
+  
+  # zero
+  # ====
+  
+  ZERO = is 0, name: 'zero', from_s: method(:parse_number)
+  
+  def self.zero
+    ZERO
+  end
+  
+  # number (Numeric)
+  # ================
+  
+  NUM = IsA.new Numeric, name: 'Num', from_s: method(:parse_number)
+  
+  def self.num
+    NUM
+  end
+  
+  # integers
+  # ========
+  
+  INT = IsA.new Integer, name: 'Int', from_s: method(:parse_number)
+  
+  def self.int
+    INT
+  end
+  
+  def self.integer
+    int
+  end
+  
+  # bounded integers
+  # ================
+  # 
+  
+  # positive integer
+  # ----------------
+  # 
+  # integer greater than zero.
+  # 
+  
+  POS_INT = intersection INT, bounded(min: 1), name: 'PosInt'
+  
+  def self.pos_int
+    POS_INT
+  end
+  
+  # negative integer
+  # ----------------
+  # 
+  # integer less than zero
+  # 
+  
+  NEG_INT = intersection INT, bounded(max: -1), name: 'NegInt'
+  
+  def self.neg_int
+    NEG_INT
+  end
+  
+  # non-negative integer
+  # --------------------
+  # 
+  # positive integers and zero... but it seems more efficient to define these
+  # as bounded instead of a union. 
+  # 
+  
+  NON_NEG_INT = intersection INT, bounded(min: 0), name: 'NonNegInt'
+  
+  def self.non_neg_int
+    NON_NEG_INT
+  end
+  
+  # non-positive integer
+  # --------------------
+  # 
+  # negative integers and zero.
+  # 
+  
+  NON_POS_INT = intersection INT, bounded(max: 0), name: 'NonPosInt'
+  
+  def self.non_pos_int
+    NON_POS_INT
+  end
+   
+end # NRSER::Types

data/lib/nrser/types/strings.rb

@@ -0,0 +1,34 @@
+require 'nrser/refinements'
+require 'nrser/types/is'
+require 'nrser/types/is_a'
+require 'nrser/types/attrs'
+
+using NRSER
+  
+module NRSER::Types
+  STR = IsA.new String, name: 'Str', from_s: ->(s) { s }
+  
+  def self.str **options
+    if options.empty?
+      # if there are no options can point to the constant for efficiency
+      STR
+    else
+      types = []
+      
+      if options[:length]
+        types << length(options[:length])
+      end
+      
+      intersection STR, *types
+    end
+  end # string
+  
+  def self.string
+    str
+  end
+  
+  EMPTY_STR = Is.new ''
+  
+  NON_EMPTY_STR = str length: {min: 1}, name: "NonEmptyStr"
+  
+end # NRSER::Types

data/lib/nrser/types/type.rb

@@ -0,0 +1,61 @@
+require 'nrser/refinements'
+using NRSER
+
+module NRSER::Types
+  class Type
+    def self.short_name
+      name.split('::').last
+    end
+    
+    def initialize **options
+      @name = options[:name]
+      @from_s = options[:from_s]
+    end
+    
+    def name
+      @name || default_name
+    end
+    
+    def default_name
+      self.class.short_name
+    end
+    
+    def test value
+      raise NotImplementedError
+    end
+    
+    def check value
+      unless test value
+        raise TypeError.new NRSER.squish <<-END
+          value #{ value.inspect } failed check #{ self.inspect }
+        END
+      end
+      
+      value
+    end
+    
+    def respond_to? name, include_all = false
+      if name == :from_s || name == 'from_s'
+        has_from_s?
+      else
+        super name, include_all
+      end
+    end
+    
+    def from_s s
+      if @from_s.nil?
+        raise NoMethodError, "#from_s not defined"
+      end
+      
+      check @from_s.(s)
+    end
+    
+    def has_from_s?
+      ! @from_s.nil?
+    end
+    
+    def to_s
+      "<Type:#{ name }>"
+    end
+  end # Type
+end # NRSER::Types

data/lib/nrser/types/where.rb

@@ -0,0 +1,22 @@
+require 'nrser/refinements'
+using NRSER
+
+module NRSER::Types
+  class Where < NRSER::Types::Type
+    attr_reader :predicate
+    
+    def initialize predicate, **options
+      super **options
+      @predicate = predicate
+    end
+    
+    def test value
+      !!@predicate.call(value)
+    end
+  end # Where
+  
+  # create a type based on a predicate
+  def self.where **options, &block
+    Where.new block, **options
+  end
+end # NRSER::Types

data/lib/nrser/version.rb

@@ -1,3 +1,3 @@
 module NRSER
-  VERSION = "0.0.15"
+  VERSION = "0.0.16"
 end

data/spec/nrser/logger/die_spec.rb

@@ -3,39 +3,39 @@ require 'spec_helper'
 using NRSER
 
 describe 'NRSER::Logger#die' do
-  it "prints the log message when logger is off" do
-    src = <<-END.dedent
-      require 'nrser/logger'
-    
-      NRSER::Logger.install self
-      
-      die "die!", cause: "just 'cause"
-    END
-    
-    err = Cmds.err("bundle exec ruby"){ src }
-    data = YAML.load(err)['FATAL']
-    
-    expect(data['msg']).to eq 'die!'
-    expect(data['values']).to eq({'cause' => "just 'cause"})
-  end
-  
-  it(
-    "prints only to the log when it's on and the log writes to " + 
-    "$stderr"
-  ) do
-    src = <<-END
-      require 'nrser/logger'
-      
-      NRSER::Logger.install self, on: true, say_hi: false
-      
-      die "die!", cause: "just 'cause"
-    END
-    
-    err = Cmds.err("bundle exec ruby"){ src }
-    
-    data = YAML.load(err)['FATAL']
-    
-    expect(data['msg']).to eq 'die!'
-    expect(data['values']).to eq({'cause' => "just 'cause"})
-  end
+  # it "prints the log message when logger is off" do
+  #   src = <<-END.dedent
+  #     require 'nrser/logger'
+  #   
+  #     NRSER::Logger.install self
+  #     
+  #     die "die!", cause: "just 'cause"
+  #   END
+  #   
+  #   err = Cmds.err("bundle exec ruby"){ src }
+  #   data = YAML.load(err)['FATAL']
+  #   
+  #   expect(data['msg']).to eq 'die!'
+  #   expect(data['values']).to eq({'cause' => "just 'cause"})
+  # end
+  # 
+  # it(
+  #   "prints only to the log when it's on and the log writes to " + 
+  #   "$stderr"
+  # ) do
+  #   src = <<-END
+  #     require 'nrser/logger'
+  #     
+  #     NRSER::Logger.install self, on: true, say_hi: false
+  #     
+  #     die "die!", cause: "just 'cause"
+  #   END
+  #   
+  #   err = Cmds.err("bundle exec ruby"){ src }
+  #   
+  #   data = YAML.load(err)['FATAL']
+  #   
+  #   expect(data['msg']).to eq 'die!'
+  #   expect(data['values']).to eq({'cause' => "just 'cause"})
+  # end
 end

data/spec/nrser/refinements/pathname_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+require 'nrser/refinements'
+
+using NRSER
+
+describe 'Pathname' do
+  
+  describe '#start_with?' do
+    it "works with other Pathname instances" do
+      expect(
+        Pathname.new('a/b/c').start_with? Pathname.new('a/b')
+      ).to be true
+      
+      expect(
+        Pathname.new('a/b/c').start_with? Pathname.new('a/b/')
+      ).to be true
+      
+      expect(
+        Pathname.new('/a/b/c').start_with? Pathname.new('/')
+      ).to be true
+    end
+  end # #start_with?
+  
+  describe '#sub' do
+    context "other pathnames" do
+      it "works for basic replacement" do
+        expect(
+          Pathname.new('a/b/c').sub Pathname.new('a/b'), 'c/d'
+        ).to eq Pathname.new('c/d/c')
+      end
+      
+      it "only substitutes the first occurrence" do
+        expect(
+          Pathname.new('c/c/c').sub Pathname.new('c'), 'a'
+        ).to eq Pathname.new('a/c/c')
+      end
+    end
+  end
+  
+end # Pathname

data/spec/nrser/types/combinators_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe NRSER::Types::Union do
+  t = NRSER::Types
+  
+  describe '==' do 
+    it "equates two different instances with equal types" do
+      expect(t.union 1, 2, 3).to eq t.union(1, 2, 3)
+    end
+  end
+end # NRSER::Types::Union

data/spec/nrser/types/is_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+describe NRSER::Types::Is do
+  t = NRSER::Types
+  
+  describe '==' do 
+    it "equates two different instances with equal types" do
+      expect(t.is 1).to eq t.is(1)
+      expect([t.is(1)]).to eq [t.is(1)]
+    end
+  end
+end # NRSER::Types::Union

data/spec/nrser/types_spec.rb

@@ -0,0 +1,197 @@
+require 'spec_helper'
+
+describe NRSER::Types do
+  t = NRSER::Types
+  
+  describe 'basic types #test and #check' do
+    {
+      t.any => {
+        pass: [nil, 'blah', 1, 3.14, [], {}, Object.new],
+        from_s: {
+          pass: ['hey', 'ho', "let's go"],
+        },
+      },
+      
+      t.is(1) => {
+        pass: [1],
+        fail: [2, '1', nil, true],
+      },
+      
+      t.is_a(Array) => {
+        pass: [[]],
+        fail: [{}],
+      },
+      
+      t.true => {
+        pass: [true],
+        fail: [1, 'true'],
+      },
+      
+      t.false => {
+        pass: [false],
+        fail: [true, 0, nil, 'false'],
+      },
+      
+      t.bool => {
+        pass: [true, false],
+        fail: [0, 1, nil],
+      },
+      
+      t.int => {
+        pass: [0, 1, -1, 888],
+        fail: ['0', 3.14],
+        from_s: {
+          pass: ['1', '10', '0', '-1', '1000000000000000000000'],
+          fail: ['3.14', '1more', 'hey'],
+        }
+      },
+      
+      t.pos_int => {
+        pass: [1, 10, 1000000000000000000000],
+        fail: [0, -1],
+        from_s: {
+          pass: ['1', '10', '1000000000000000000000'],
+          fail: ['0', '-1', '3.14'],
+        }
+      },
+      
+      t.neg_int => {
+        pass: [-1, -10, -1000000000000000000000],
+        fail: [0, 1],
+        from_s: {
+          pass: ['-1', '-10', '-1000000000000000000000'],
+          fail: ['0', '1', '3.14'],
+        }
+      },
+      
+      t.non_neg_int => {
+        pass: [0, 1],
+        fail: [nil, -1, false],
+        from_s: {
+          pass: ['0', '1'],
+          fail: ['-1'],
+        },
+      },
+      
+      t.non_pos_int => {
+        pass: [0, -1],
+        fail: [1],
+        from_s: {
+          pass: ['0', '-1'],
+          fail: ['1', 'blah'],
+        },
+      },
+      
+      t.str => {
+        pass: ['hey', ''],
+        fail: [1, {}, nil],
+        from_s: {
+          pass: ['hey', ''],
+        }
+      },
+      
+      t.attrs(to_s: t.str) => {
+        pass: [''],
+      },
+      
+      t.length(min: 0, max: 0) => {
+        pass: ['', [], {}],
+        fail: ['x', [1], {x: 1}],
+      },
+      
+      t.length(0) => {
+        pass: ['', [], {}],
+        fail: ['x', [1], {x: 1}],
+      },
+      
+      t.bounded(min: 0, max: 0) => {
+        pass: [0],
+      },
+      
+      t.union(t.non_neg_int, t.bounded(min: 0, max: 0)) => {
+        pass: [0],
+      },
+      
+      t.attrs(length: t.bounded(min: 0, max: 0)) => {
+        pass: ['', []],
+        fail: ['hey'],
+      },
+      
+      t.str(length: 0) => {
+        pass: [''],
+        fail: ['hey'],
+      },
+      
+      t.array => {
+        pass: [[], [1, 2, 3]],
+        fail: [nil, {}, '1,2,3'],
+        from_s: {
+          pass: ['1,2,3', '', '[1,2,3]', 'a, b, c'],
+        }
+      },
+      
+      t.array(t.int) => {
+        pass: [[], [1, 2, 3]],
+        fail: [['1']],
+        from_s: {
+          pass: ['1,2,3', '', '[1,2,3]'],
+          fail: ['a,b,c'],
+        }
+      },
+      
+    }.each do |type, tests|
+      if tests[:pass]
+        tests[:pass].each do |value|
+          it "ACCEPS #{ value.inspect } as #{ type }" do
+            expect(type.test value).to be true
+            expect {type.check value}.not_to raise_error
+          end
+        end
+      end
+      
+      if tests[:fail]
+        tests[:fail].each do |value|
+          it "REJECTS #{ value.inspect } as #{ type }" do
+            expect(type.test value).to be false
+            expect {type.check value}.to raise_error TypeError
+          end
+        end
+      end
+      
+      if tests[:from_s]
+        if tests[:from_s][:pass]
+          tests[:from_s][:pass].each do |string|
+            unless string.is_a? String
+              raise "must be string: #{ string.inspect }"
+            end
+            
+            it "#{ type }#from_s ACCEPTS string #{ string.inspect }" do
+              expect{ type.from_s string }.not_to raise_error
+            end
+          end
+        end
+      end # from_s
+    end # each
+  end # basic types #test and #check
+  
+  describe ".from_repr" do
+    {
+      t.str => ['string', 'str', 'String', 'STRING', 'STR'],
+      t.int => ['int', 'integer', 'Integer', 'INT'],
+      t.bool => ['bool', 'boolean', 'Boolean', 'BOOL'],
+      t.array => ['array', 'list', 'Array'],
+      # t.union('a', 'b', 'c') => [
+      #   {
+      #     'one_of': ['a', 'b', 'c'],
+      #   }
+      # ]
+    }.each do |type, inputs|
+      inputs.each do |input|
+        it "converts #{ input.inspect } to #{ type }" do
+          expect(NRSER::Types.from_repr input).to eq type
+        end
+      end
+    end
+  end # #from_repr
+  
+end # QB::Types

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: nrser
 version: !ruby/object:Gem::Version
-  version: 0.0.15
+  version: 0.0.16
 platform: ruby
 authors:
 - nrser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-13 00:00:00.000000000 Z
+date: 2017-04-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -98,6 +98,21 @@ files:
 - lib/nrser/collection.rb
 - lib/nrser/logger.rb
 - lib/nrser/refinements.rb
+- lib/nrser/types.rb
+- lib/nrser/types/any.rb
+- lib/nrser/types/array.rb
+- lib/nrser/types/attrs.rb
+- lib/nrser/types/booleans.rb
+- lib/nrser/types/bounded.rb
+- lib/nrser/types/combinators.rb
+- lib/nrser/types/hash.rb
+- lib/nrser/types/is.rb
+- lib/nrser/types/is_a.rb
+- lib/nrser/types/maybe.rb
+- lib/nrser/types/numbers.rb
+- lib/nrser/types/strings.rb
+- lib/nrser/types/type.rb
+- lib/nrser/types/where.rb
 - lib/nrser/version.rb
 - nrser.gemspec
 - spec/nrser/collection/each_spec.rb
@@ -117,9 +132,13 @@ files:
 - spec/nrser/refinements/erb_spec.rb
 - spec/nrser/refinements/format_exception_spec.rb
 - spec/nrser/refinements/indent_spec.rb
+- spec/nrser/refinements/pathname_spec.rb
 - spec/nrser/refinements/truncate_spec.rb
 - spec/nrser/template_spec.rb
 - spec/nrser/truncate_spec.rb
+- spec/nrser/types/combinators_spec.rb
+- spec/nrser/types/is_spec.rb
+- spec/nrser/types_spec.rb
 - spec/nrser_spec.rb
 - spec/spec_helper.rb
 - tmp/.gitkeep
@@ -143,7 +162,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.6.11
 signing_key: 
 specification_version: 4
 summary: basic ruby utils i use in a lot of stuff.
@@ -165,9 +184,12 @@ test_files:
 - spec/nrser/refinements/erb_spec.rb
 - spec/nrser/refinements/format_exception_spec.rb
 - spec/nrser/refinements/indent_spec.rb
+- spec/nrser/refinements/pathname_spec.rb
 - spec/nrser/refinements/truncate_spec.rb
 - spec/nrser/template_spec.rb
 - spec/nrser/truncate_spec.rb
+- spec/nrser/types/combinators_spec.rb
+- spec/nrser/types/is_spec.rb
+- spec/nrser/types_spec.rb
 - spec/nrser_spec.rb
 - spec/spec_helper.rb
-has_rdoc: