nrser 0.0.20 → 0.0.21

data/lib/nrser/refinements/set.rb

@@ -0,0 +1,9 @@
+require 'set'
+
+require_relative './enumerable'
+
+module NRSER
+  refine ::Set do
+    include NRSER::Refinements::Enumerable
+  end # refine ::Set
+end # NRSER

data/lib/nrser/refinements/string.rb

@@ -1,3 +1,5 @@
+require 'pathname'
+
 module NRSER
   refine String do
     def squish
@@ -27,5 +29,12 @@ module NRSER
     
     alias_method :to_const, :constantize
     
+    # @return [Pathname]
+    #   Convert self into a {Pathname}
+    # 
+    def to_pn
+      Pathname.new self
+    end
+    
   end # refine String
 end # NRSER

data/lib/nrser/refinements.rb

@@ -5,3 +5,6 @@ require_relative './refinements/hash'
 require_relative './refinements/pathname'
 require_relative './refinements/exception'
 require_relative './refinements/binding'
+require_relative './refinements/set'
+require_relative './refinements/open_struct'
+require_relative './refinements/enumerator'

data/lib/nrser/types/attrs.rb

@@ -8,62 +8,89 @@ module NRSER::Types
   class Attrs < NRSER::Types::Type
     def initialize attrs, **options
       super **options
-      @attrs = attrs
+      @attrs = NRSER.map_values(attrs) { |name, type|
+        NRSER::Types.make type
+      }
     end
     
     def default_name
-      attrs_str = @attrs.map {|name, type|
+      attrs_str = @attrs.map { |name, type|
         "#{ name }=#{ type.name }"
       }.join(', ')
       
-      "#{ self.class.short_name }(#{ attrs_str })"
+      "#{ self.class.short_name } #{ attrs_str }"
     end
     
     def test value
-      @attrs.all? {|name, type|
+      @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)
+  # Eigenclass (Singleton Class)
+  # ========================================================================
+  # 
+  class << self
+    def attrs attrs, options = {}
+      Attrs.new attrs, **options
+    end
+
+    def 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 = NRSER.symbolize_keys args[0]
+          
+          bounds[:min] = options.delete :min
+          bounds[:max] = options.delete :max
+          
+          if length = options.delete(:length)
+            bounds[:min] = length
+            bounds[:max] = length
           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
         
-      else        
+      when 2
+        bounds[:min] = bounds[:max] = non_neg_int.check(args[0])
+        options = args[1]
+        
+      else
         raise ArgumentError, <<-END.squish
-          arg must be positive integer or option hash, found:
-          #{ args[0].inspect } of type #{ args[0].class }
+          must provided 1 or 2 args.
         END
       end
       
-    when 2
-      bounds[:min] = bounds[:max] = non_neg_int.check(args[0])
-      options = args[1]
+      bounded_type = bounded bounds
       
-    else
-      raise ArgumentError, <<-END.squish
-        must provided 1 or 2 args.
-      END
-    end
+      length_type = if !bounded_type.min.nil? && bounded_type.min >= 0
+        # We don't need the non-neg check
+        bounded_type
+      else
+        # We do need the non-neg check
+        intersection(non_neg_int, bounded_type)
+      end
+      
+      options[:name] ||= "Length<#{ bounded_type.name }>"
+      
+      attrs({ length: length_type }, options)
+    end # #length
+    
     
-    attrs({length: intersection(non_neg_int, bounded(bounds))}, options)
-  end
+  end # class << self (Eigenclass)
+  
 end # NRSER::Types

data/lib/nrser/types/bounded.rb

@@ -5,9 +5,26 @@ using NRSER
   
 module NRSER::Types  
   class Bounded < NRSER::Types::Type
-    def initialize **options
-      @min = options[:min]
-      @max = options[:max]
+    
+    # @!attribute [r] min
+    #   @return [Number]
+    #     Minimum value.
+    attr_reader :min
+    
+    
+    # @!attribute [r] max
+    #   @return [Number]
+    #     Minimum value.
+    attr_reader :max
+    
+    
+    def initialize  min: nil,
+                    max: nil,
+                    **options
+      super **options
+      
+      @min = min
+      @max = max
     end
     
     def test value
@@ -25,7 +42,7 @@ module NRSER::Types
         "#{ name }=#{ value }"
       }.join(', ')
       
-      "#{ self.class.short_name }(#{ attrs_str })"
+      "#{ self.class.short_name } #{ attrs_str }"
     end
   end # Bounded
   

data/lib/nrser/types/combinators.rb

@@ -13,11 +13,11 @@ module NRSER::Types
       @types = types.map {|type| NRSER::Types.make type}
     end
     
-    def name
+    def default_name
       @name || (
-        "#{ self.class.short_name }(" + 
+        "#{ self.class.short_name }<" + 
         @types.map {|type| type.name }.join(',') + 
-        ")"
+        ">"
       )
     end
     
@@ -42,7 +42,7 @@ module NRSER::Types
       }
       
       raise TypeError,
-        "none of union types could convert #{ string.inspect }"
+        "none of combinator #{ self.to_s } types could convert #{ s.inspect }"
     end
     
     def == other
@@ -69,6 +69,10 @@ module NRSER::Types
     def test value
       @types.all? {|type| type.test value}
     end
+    
+    def default_name
+      "( #{ @types.map { |t| t.name }.join ' | ' } )"
+    end
   end
   
   # match all of the types

data/lib/nrser/types/is.rb

@@ -12,7 +12,7 @@ module NRSER::Types
       @value = value
     end
     
-    def name
+    def default_name
       "Is(#{ @value.inspect })"
     end
     

data/lib/nrser/types/responds.rb

@@ -0,0 +1,110 @@
+
+# @todo document NRSER::Types module.
+module NRSER::Types
+  
+  # @todo document Responds class.
+  class Responds < NRSER::Types::Type
+    
+    # Constants
+    # ======================================================================
+    
+    
+    # Class Methods
+    # ======================================================================
+    
+    
+    # Attributes
+    # ======================================================================
+    
+    
+    # Constructor
+    # ======================================================================
+    
+    # Instantiate a new `Responds`.
+    def initialize  map,
+                    public: true,
+                    **options
+      @map = NRSER.map_values(map) { |args, type|
+        NRSER::Types.make type
+      }
+    end # #initialize
+    
+    
+    # Instance Methods
+    # ======================================================================
+    
+    
+    def default_name
+      attrs_str = @map.map { |args, type|
+        args_str = args[1..-1].map(&:inspect).join ', '
+        "#{ args[0] }(#{ args_str })=#{ type.name }"
+      }.join(', ')
+      
+      "#{ self.class.short_name } #{ attrs_str }"
+    end
+    
+    
+    # @todo Document test method.
+    # 
+    # @param [type] arg_name
+    #   @todo Add name param description.
+    # 
+    # @return [return_type]
+    #   @todo Document return value.
+    # 
+    def test value
+      @map.all? { |args, type|
+        response = if @public
+          value.public_send *args
+        else
+          value.send *args
+        end
+        
+        type.test response
+      }
+    end # #test
+    
+    
+  end # class Responds
+  
+  
+  # Eigenclass (Singleton Class)
+  # ========================================================================
+  # 
+  class << self
+    
+    
+    # @todo Document responds method.
+    # 
+    # @param [type] arg_name
+    #   @todo Add name param description.
+    # 
+    # @return [return_type]
+    #   @todo Document return value.
+    # 
+    def responds *args
+      Responds.new *args
+    end # #responds
+    
+    
+    
+    # @todo Document respond_to Responds.
+    # 
+    # @param [type] arg_name
+    #   @todo Add name param description.
+    # 
+    # @return [return_type]
+    #   @todo Document return value.
+    # 
+    def respond_to name, **options
+      responds(
+        {[:respond_to?, name] => NRSER::Types::TRUE},
+        **options
+      )
+    end # #respond_to
+    
+    
+  end # class << self (Eigenclass)
+  
+  
+end # module NRSER::Types

data/lib/nrser/types/strings.rb

@@ -31,4 +31,10 @@ module NRSER::Types
   
   NON_EMPTY_STR = str length: {min: 1}, name: "NonEmptyStr"
   
+  
+  def self.non_empty_str
+    NON_EMPTY_STR
+  end # .non_empty_str
+  
+  
 end # NRSER::Types

data/lib/nrser/types/type.rb

@@ -24,14 +24,19 @@ module NRSER::Types
       raise NotImplementedError
     end
     
-    def check value
-      unless test value
-        raise TypeError.new NRSER.squish <<-END
-          value #{ value.inspect } failed check #{ self.inspect }
+    def check value, &make_fail_message
+      # success case
+      return value if test value
+      
+      msg = if make_fail_message
+        make_fail_message.call type: self, value: value
+      else
+        NRSER.squish <<-END
+          value #{ value.inspect } failed check #{ self.to_s }
         END
       end
       
-      value
+      raise TypeError.new msg
     end
     
     def respond_to? name, include_all = false
@@ -55,7 +60,7 @@ module NRSER::Types
     end
     
     def to_s
-      "<Type:#{ name }>"
+      "`Type: #{ name }`"
     end
   end # Type
 end # NRSER::Types

data/lib/nrser/types.rb

@@ -8,6 +8,7 @@ require 'nrser/types/where'
 require 'nrser/types/combinators'
 require 'nrser/types/maybe'
 require 'nrser/types/attrs'
+require 'nrser/types/responds'
 
 using NRSER
   
@@ -32,21 +33,55 @@ module NRSER::Types
     make(type).test value
   end
   
-  def self.match value, type_map
-    type_map.each {|type, block|
+  def self.match value, *clauses
+    if clauses.empty?
+      raise ArgumentError.new NRSER.dedent <<-END
+        Must supply either a single {type => expression} hash argument or a
+        even amount of arguments representing (type, expression) pairs after
+        `value`.
+        
+        #{ NRSER::Version.doc_url 'NRSER/Types#match-class_method' }
+      END
+    end
+    
+    enum = if clauses.length == 1 && clauses.first.respond_to?(:each_pair)
+      clauses.first.each_pair
+    else
+      unless clauses.length % 2 == 0
+        raise TypeError.new NRSER.dedent <<-END
+          When passing a list of clauses, it must be an even length
+          representing (type, expression) pairs.
+          
+          Found an argument list with length #{ clauses.length }:
+          
+          #{ clauses }
+        END
+      end
+      
+      clauses.each_slice(2)
+    end
+    
+    enum.each { |type, expression|
       if test value, type
-        return block.call value
+        # OK, we matched! Is the corresponding expression callable?
+        if expression.respond_to? :call
+          # It is; invoke and return result.
+          return expression.call value
+        else
+          # It's not; assume it's a value and return it.
+          return expression
+        end
       end
     }
     
     raise TypeError, <<-END.dedent
-      could not match value
+      Could not match value
       
-        #{ value.inspect }
+          #{ value.inspect }
       
       to any of types
       
-          #{ type_map.keys.map {|type| "\n    #{ type.inspect }"} }
+          #{ enum.map {|type, expression| "\n    #{ type.inspect }"} }
       
     END
   end

data/lib/nrser/version.rb

@@ -1,3 +1,52 @@
 module NRSER
-  VERSION = "0.0.20"
+  VERSION = "0.0.21"
+  
+  module Version
+    
+    # @return [Gem::Version]
+    #   Parse of {NRSER::VERSION}.
+    # 
+    def self.gem_version
+      Gem::Version.new VERSION
+    end # .gem_version
+    
+    
+    # The `Gem::Version` "release" for {NRSER::VERSION} - everything before 
+    # any `-<alpha-numeric>` prerelease part (like `-dev`).
+    # 
+    # @see https://ruby-doc.org/stdlib-2.4.1/libdoc/rubygems/rdoc/Gem/Version.html#method-i-release
+    # 
+    # @example
+    # 
+    #   NRSER::VERSION
+    #   # => '0.0.21.dev'
+    #   
+    #   NRSER::Version.release
+    #   # => #<Gem::Version "0.0.21">
+    # 
+    # @return [Gem::Version]
+    # 
+    def self.release
+      gem_version.release
+    end # .release
+    
+    
+    # Get a URL to a place in the current version's docs on ruby-docs.org.
+    # 
+    # @param [String] rel_path
+    #   Relative path.
+    # 
+    # @return [String]
+    #   The RubyDocs URL.
+    # 
+    def self.doc_url rel_path
+      File.join(
+        "http://www.rubydoc.info/gems/nrser",
+        NRSER::Version.release.to_s,
+        rel_path
+      )
+    end # .doc_url
+    
+    
+  end
 end

data/lib/nrser.rb

@@ -12,3 +12,4 @@ require_relative './nrser/hash'
 require_relative './nrser/array'
 require_relative './nrser/types'
 require_relative './nrser/meta'
+require_relative './nrser/open_struct'

data/spec/nrser/enumerable_spec.rb

@@ -0,0 +1,97 @@
+require 'spec_helper'
+
+describe "NRSER Enumerable Methods" do
+  
+  describe NRSER.method(:find_bounded) do
+    
+    context "when just :length bounds arg is provided" do
+      it "returns found elements when length is correct" do
+        expect(
+          subject.([1, 2, 3], length: 1) { |i| i == 2 }
+        ).to eq [2]
+      end
+      
+      it "raises TypeError when length in incorrect" do
+        expect {
+          subject.([1, 2, 3], length: 2) { |i| i == 2 }
+        }.to raise_error TypeError
+      end
+    end # when just :length bounds arg is provided
+    
+    context "when just :min bounds arg is provided" do
+      it "returns found elements when min is correct" do
+        expect(
+          subject.([1, 2, 3], min: 1) { |i| i == 2 }
+        ).to eq [2]
+      end
+      
+      it "raises TypeError when min in incorrect" do
+        expect {
+          subject.([1, 2, 3], min: 2) { |i| i == 2 }
+        }.to raise_error TypeError
+      end
+    end # when just :min bounds arg is provided
+
+    context "when just :max bounds arg is provided" do
+      it "returns found elements when max is correct" do
+        expect(
+          subject.([1, 2, 3], max: 2) { |i| i >= 2 }
+        ).to eq [2, 3]
+      end
+      
+      it "raises TypeError when max in incorrect" do
+        expect {
+          subject.([1, 2, 3], max: 1) { |i| i >= 2 }
+        }.to raise_error TypeError
+      end
+    end # when just :max bounds arg is provided
+    
+    
+    context "when :min and :max bounds args are both provided" do
+      it "returns found elements when min and max are correct" do
+        expect(
+          subject.([1, 2, 3], min: 1, max: 2) { |i| i >= 2 }
+        ).to eq [2, 3]
+      end
+      
+      it "raises TypeError when min is incorrect" do
+        expect {
+          subject.([1, 2, 3], min: 1, max: 2) { |i| false }
+        }.to raise_error TypeError
+      end
+      
+      it "raises TypeError when max is incorrect" do
+        expect {
+          subject.([1, 2, 3], min: 1, max: 2) { |i| true }
+        }.to raise_error TypeError
+      end
+    end # when :min and :max bounds args are both provided
+    
+  end # NRSER.method(:find_bounded)
+  
+  
+  describe NRSER.method(:find_only) do
+    
+    it "returns the element when only one is found" do
+      expect(
+        subject.call [1, 2, 3] { |i| i == 2 }
+      ).to be 2
+    end
+    
+    it "raises TypeError when more than one element is found" do
+      expect {
+        subject.call [1, 2, 3] { |i| i >= 2 }
+      }.to raise_error TypeError
+    end
+    
+    it "raises TypeError when no elements are found" do
+      expect {
+        subject.call [1, 2, 3] { |i| false }
+      }.to raise_error TypeError
+    end
+    
+  end # NRSER.method(:find_only)
+  
+  
+end # NRSER Enumerable Methods
+

data/spec/nrser/hash_spec.rb

@@ -1,8 +1,11 @@
+require 'set'
+require 'ostruct'
+
 require 'spec_helper'
 
 using NRSER
 
-describe NRSER.method(:truncate) do
+describe NRSER.method(:leaves) do
   it do
     expect(NRSER.leaves({a: 1, b: 2})).to eq ({[:a] => 1, [:b] => 2})
     expect(
@@ -21,4 +24,45 @@ describe NRSER.method(:truncate) do
       [:b] => 'bee',
     })
   end
-end # truncate
+end # NRSER.leaves
+
+describe NRSER.method(:map_values) do
+  
+  it "handles hashes" do
+    expect(
+      NRSER.map_values({a: 1, b: 2}) { |k, v| v * 3 }
+    ).to eq(
+      {a: 3, b: 6}
+    )
+  end # handles hashes
+  
+  
+  it "handles arrays" do
+    expect(
+      NRSER.map_values([:a, :b, :c]) { |k, v| "#{ k } is ok!" }
+    ).to eq(
+      {a: "a is ok!", b: "b is ok!", c: "c is ok!"}
+    )
+  end # handles arrays
+  
+  
+  it "handles sets" do
+    expect(
+      NRSER.map_values(Set.new [:a, :b, :c]) { |k, v| "#{ k } is ok!" }
+    ).to eq(
+      {a: "a is ok!", b: "b is ok!", c: "c is ok!"}
+    )
+  end # handles sets
+  
+  
+  it "handles OpenStruct instances" do
+    expect(
+      NRSER.map_values(OpenStruct.new a: 1, b: 2) { |k, v| v * 3 }
+    ).to eq(
+      {a: 3, b: 6}
+    )
+  end # handles OpenStruct instances
+  
+  
+end # NRSER.map_values
+