nrser 0.0.25 → 0.0.26

data/lib/nrser/string.rb

@@ -1,3 +1,5 @@
+require_relative './string/looks_like'
+
 module NRSER
   class << self
     # Functions the operate on strings.
@@ -155,5 +157,6 @@ module NRSER
     end # constantize
     
     alias_method :to_const, :constantize
+    
   end # class << self
 end # module NRSER

data/lib/nrser/string/looks_like.rb

@@ -0,0 +1,51 @@
+##
+# Functional methods that try to tell what format a string that
+# is presumed to encode structural data is encoded in.
+##
+
+# Requirements
+# =======================================================================
+
+# Stdlib
+# -----------------------------------------------------------------------
+
+# Deps
+# -----------------------------------------------------------------------
+
+# Project / Package
+# -----------------------------------------------------------------------
+
+
+# Definitions
+# =======================================================================
+
+module NRSER
+  
+  # Constants
+  # =====================================================================
+  
+  JSON_ARRAY_RE = /\A\s*\[.*\]\s*\z/m
+  
+  # Eigenclass (Singleton Class)
+  # ========================================================================
+  # 
+  class << self
+    
+    # Test if a string looks like it might encode an array in JSON format by
+    # seeing if it's first non-whitespace character is `[` and last 
+    # non-whitespace character is `]`.
+    # 
+    # @param [String] string
+    #   String to test.
+    # 
+    # @return [Boolean]
+    #   `true` if we think `string` encodes a JSON array.
+    # 
+    def looks_like_json_array? string
+      !!( string =~ JSON_ARRAY_RE )
+    end # #looks_like_json_array
+    
+  end # class << self (Eigenclass)
+  
+end # module NRSER
+

data/lib/nrser/temp/where.rb

@@ -0,0 +1,52 @@
+
+
+# Definitions
+# =======================================================================
+
+module NRSER
+  
+  # A class to hold info about how to find a record (besides by primary key).
+  # 
+  # Needs to support "template/placeholder"-type information - instructions
+  # about *how* to find the values to match against depending on a source
+  # object available later.
+  # 
+  # @todo
+  #   Not sure if this is the best name... there's already
+  #   {NRSER::Types::Where}...
+  #   
+  #   Maybe this functionality has something to do with the types system?
+  #   It seems like the placeholder stuff would be hard to integrate with 
+  #   that, but having a whole other very similar system sucks too.
+  # 
+  class Where
+    
+    # Constants
+    # ======================================================================
+    
+    
+    # Class Methods
+    # ======================================================================
+    
+    
+    # Attributes
+    # ======================================================================
+    
+    
+    # Constructor
+    # ======================================================================
+    
+    # Instantiate a new `Where`.
+    def initialize
+      
+    end # #initialize
+    
+    
+    # Instance Methods
+    # ======================================================================
+    
+    
+  end # class Where
+  
+  
+end # module NRSER

data/lib/nrser/tree.rb

@@ -0,0 +1,86 @@
+# Requirements
+# =======================================================================
+
+# Project / Package
+# -----------------------------------------------------------------------
+require_relative './tree/leaves'
+require_relative './tree/map_leaves'
+require_relative './tree/transform'
+
+
+# Definitions
+# =======================================================================
+
+module NRSER
+  
+  # Enumerate over the immediate "branches" of a structure that can be used
+  # to compose our idea of a *tree*: nested hash-like and array-like structures
+  # like you would get from parsing a JSON document.
+  # 
+  # Written and tested against Hash and Array instances, but should work with
+  # anything hash-like that responds to `#each_pair` appropriately or
+  # array-like that responds to `#each_index` and `#each_with_index`.
+  # 
+  # @note Not sure what will happen if the tree has circular references!
+  # 
+  # @param [#each_pair | (#each_index & #each_with_index)] tree
+  #   Structure representing a tree via hash-like and array-like containers.
+  # 
+  # @yieldparam [Object] key
+  #   The first yielded param is the key or index for the value branch at the
+  #   top level of `tree`.
+  #   
+  # @yieldparam [Object] value
+  #   The second yielded param is the branch at the key or index at the top
+  #   level of `tree`.
+  # 
+  # @yieldreturn
+  #   Ignored.
+  # 
+  # @return [Enumerator]
+  #   If no block is provided.
+  # 
+  # @return [#each_pair | (#each_index & #each_with_index)]
+  #   If a block is provided, the result of the `#each_pair` or
+  #   `#each_with_index` call.
+  # 
+  # @raise [NoMethodError]
+  #   If `tree` does not respond to `#each_pair` or to `#each_index` and 
+  #   `#each_with_index`.
+  # 
+  def self.each_branch tree, &block
+    if tree.respond_to? :each_pair
+      # Hash-like
+      tree.each_pair &block
+      
+    elsif tree.respond_to? :each_index
+      # Array-like... we test for `each_index` because - unintuitively - 
+      # `#each_with_index` is a method of {Enumerable}, meaning that {Set}
+      # responds to it, though sets are unordered and the values can't be
+      # accessed via those indexes. Hence we look for `#each_index`, which 
+      # {Set} does not respond to.
+      
+      if block.nil?        
+        index_enumerator = tree.each_with_index
+        
+        Enumerator.new( index_enumerator.size ) { |yielder|
+          index_enumerator.each { |value, index|
+            yielder.yield index, value
+          }
+        }
+      else
+        tree.each_with_index.map { |value, index|
+          block.call index, value
+        }
+      end
+      
+    else
+      raise NoMethodError.new NRSER.squish <<-END
+        `tree` param must respond to `#each_pair` or `#each_index`,
+        found #{ tree.inspect }
+      END
+      
+    end # if / else
+  end # .each_branch
+  
+end # module NRSER

data/lib/nrser/tree/leaves.rb

@@ -0,0 +1,92 @@
+module NRSER
+  
+  # Eigenclass (Singleton Class)
+  # ========================================================================
+  # 
+  class << self
+    
+    # Create a new hash where all the values are the scalar "leaves" of the 
+    # possibly nested `hash` param. Leaves are keyed by "key path" arrays 
+    # representing the sequence of keys to dig that leaf out of the has param.
+    # 
+    # In abstract, if `h` is the `hash` param and
+    # 
+    #     l = NRSER.leaves h
+    # 
+    # then for each key `k` and corresponding value `v` in `l`
+    # 
+    #     h.dig( *k ) == v
+    # 
+    # @example Simple "flat" hash
+    #   
+    #   NRSER.leaves( {a: 1, b: 2} )
+    #   => {
+    #     [:a] => 1,
+    #     [:b] => 2,
+    #   }
+    # 
+    # @example Nested hash
+    #   
+    #   NRSER.leaves(
+    #     1 => {
+    #       name: 'Neil',
+    #       fav_color: 'blue',
+    #     },
+    #     2 => {
+    #       name: 'Mica',
+    #       fav_color: 'red',  
+    #     }
+    #   )
+    #   # => {
+    #   #   [1, :name]      => 'Neil',
+    #   #   [1, :fav_color] => 'blue',
+    #   #   [2, :name]      => 'Mica',
+    #   #   [2, :fav_color] => 'red',
+    #   # }
+    #   
+    # @param [#each_pair | (#each_index & #each_with_index)] tree
+    # 
+    # @return [Hash<Array, Object>]
+    # 
+    def leaves tree
+      {}.tap { |results|
+        _internal_leaves tree, path: [], results: results
+      }
+    end # #leaves
+    
+    
+    private
+    # ========================================================================
+      
+      # Internal recursive implementation for {NRSER.leaves}.
+      # 
+      # @param [#each_pair | (#each_index & #each_with_index)] tree
+      #   Tree to walk.
+      # 
+      # @param [Array] path
+      #   Key path down to `tree`.
+      # 
+      # @param [Hash<Array, Object>] results
+      #   New hash to stick results in.
+      # 
+      # @return [nil]
+      # 
+      def _internal_leaves tree, path:, results:
+        NRSER.each_branch( tree ) { |key, value|
+          new_path = [*path, key]
+          
+          if NRSER::Types.tree.test value
+            _internal_leaves value, path: new_path, results: results
+          else
+            results[new_path] = value
+          end
+        }
+        
+        nil
+      end # #_internal_leaves
+      
+    # end private
+    
+  end # class << self (Eigenclass)
+  
+end # module NRSER

data/lib/nrser/tree/map_leaves.rb

@@ -0,0 +1,63 @@
+module NRSER
+  
+  # Eigenclass (Singleton Class)
+  # ========================================================================
+  # 
+  class << self
+    
+    def map_leaves tree, &block
+      NRSER::Types.tree.check tree
+      
+      _internal_map_leaves tree, key_path: [], &block
+    end # #map_leaves
+    
+    private
+    # ========================================================================
+      
+      # Internal recursive implementation for {NRSER.leaves}.
+      # 
+      # @param [#each_pair | (#each_index & #each_with_index)] tree
+      #   Tree to walk.
+      # 
+      # @param [Array] path
+      #   Key path down to `tree`.
+      # 
+      # @param [Hash<Array, Object>] results
+      #   New hash to stick results in.
+      # 
+      # @return [nil]
+      # 
+      def _internal_map_leaves tree, key_path:, &block
+        NRSER::Types.match tree,
+          NRSER::Types.hash_like, ->( hash_like ) {
+            hash_like.map { |key, value|
+              new_key_path = [*key_path, key]
+              
+              new_value = if NRSER::Types.tree.test( value )
+                _internal_map_leaves value, key_path: new_key_path, &block
+              else
+                block.call new_key_path, value
+              end
+              
+              [key, new_value]
+            }.to_h
+          },
+          
+          NRSER::Types.array_like, ->( array_like ) {
+            array_like.each_with_index.map { |value, index|
+              new_key_path = [*key_path, index]
+              
+              if NRSER::Types.tree.test( value )
+                _internal_map_leaves value, key_path: new_key_path, &block
+              else
+                block.call new_key_path, value
+              end
+            }
+          }
+      end # #_internal_leaves
+      
+    # end private
+    
+  end # class << self (Eigenclass)
+  
+end # module NRSER

data/lib/nrser/tree/transform.rb

@@ -0,0 +1,30 @@
+# Definitions
+# =======================================================================
+
+module NRSER
+  
+  # @todo Document transform method.
+  # 
+  # @param [type] arg_name
+  #   @todo Add name param description.
+  # 
+  # @return [return_type]
+  #   @todo Document return value.
+  # 
+  def self.transform tree, source
+    each_branch( tree ).map { |pair|
+      pair.map { |value|
+        if NRSER::Types.tree.test value
+          transform value, source
+        else
+          if value.is_a? Proc
+            value.call source
+          else
+            value
+          end
+        end
+      }
+    }.to_h
+  end # .transform
+  
+end # module NRSER

data/lib/nrser/types.rb

@@ -30,6 +30,7 @@ require_relative './types/combinators'
 require_relative './types/maybe'
 require_relative './types/attrs'
 require_relative './types/responds'
+require_relative './types/in'
 
 
 # Refinements
@@ -135,7 +136,7 @@ module NRSER::Types
       
       to any of types
       
-          #{ enum.map {|type, expression| "\n    #{ type.inspect }"} }
+          #{ enum.map {|type, expression| "\n    #{ type.inspect }"}.join '' }
       
     END
   end # .match
@@ -168,7 +169,11 @@ require_relative './types/any'
 require_relative './types/booleans'
 require_relative './types/numbers'
 require_relative './types/strings'
-require_relative './types/symbol'
+require_relative './types/symbols'
+require_relative './types/labels'
 require_relative './types/array'
-require_relative './types/hash'
-require_relative './types/paths'
+require_relative './types/hashes'
+require_relative './types/paths'
+require_relative './types/tuples'
+require_relative './types/pairs'
+require_relative './types/trees'

data/lib/nrser/types/any.rb

@@ -4,7 +4,7 @@ require 'nrser/types/where'
 using NRSER
   
 module NRSER::Types
-  ANY = where(name: 'Any', from_s: ->(s) { s }) { true }.freeze
+  ANY = where(name: 'AnyType', from_s: ->(s) { s }) { true }.freeze
   
   # anything
   def self.any

data/lib/nrser/types/array.rb

@@ -1,60 +1,202 @@
-require 'nrser/refinements'
+# Requirements
+# =======================================================================
+
+# Stdlib
+# -----------------------------------------------------------------------
+
+# Deps
+# -----------------------------------------------------------------------
+
+# Project / Package
+# -----------------------------------------------------------------------
 require 'nrser/types/type'
 require 'nrser/types/is_a'
 
+
+# Refinements
+# =======================================================================
+
+require 'nrser/refinements'
 using NRSER
+
+
+# Declarations
+# =======================================================================
+
+module NRSER; end
+
+
+# Definitions
+# =======================================================================
   
 module NRSER::Types
-  class Array < IsA
-    SEP = /\,\s+/
+  class ArrayType < IsA
+    # Default value to split strings with in {#from_s} if the string provided
+    # does is not recognized as an encoding format (as of writing, JSON is
+    # the only format we attempt to detect).
+    # 
+    # Splits 
+    DEFAULT_SPLIT_WITH = /\,\s*/m
     
     attr_reader :item_type
     
-    def initialize item_type = NRSER::Types::ANY, **options
+    def initialize split_with: DEFAULT_SPLIT_WITH, **options
       super ::Array, **options
-      @item_type = NRSER::Types.make item_type
+      @split_with = split_with
     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 }>"
+      self.class.short_name
     end
     
-    def has_from_s?
-      @item_class.has_from_s?
+    
+    # Called on an array of string items that have been split
+    # from a single string by {#from_s} to convert each individual item before
+    # {#check} is called on the value.
+    # 
+    # {NRSER::Types::ArrayType} implementation is a no-op that just returns
+    # `items` - this method is in place for subclasses to override.
+    # 
+    # @param [Array<String>] items
+    # 
+    # @return [Array]
+    # 
+    def items_from_strings items
+      items
     end
     
+    
     def from_s s
-      # does it looks like json?
-      if s.start_with? '['
+      # Use custom {@from_s} if we have one.
+      return check( @from_s.call s ) unless @from_s.nil?
+      
+      # Does it looks like a JSON array?
+      if NRSER.looks_like_json_array? s
+        # It does! Load it
         begin
-          return JSON.load s
+          array = JSON.load( s )
         rescue
+          # pass - if we failed to load as JSON, it may just not be JSON, and
+          # we can try the split approach below.
+        else
+          # Check value and return. If we fail the check here let the error
+          # bubble up
+          return check array
         end
       end
       
-      s.split SEP
+      # Split it with the splitter and check that
+      check items_from_strings( s.split( @split_with ) )
+    end
+    
+  end # ArrayType
+  
+  
+  # Static instance that is satisfied by anything that is an {Array}.
+  ARRAY = ArrayType.new.freeze
+  
+  
+  # Type for arrays where every entry satisfies a specific type.
+  # 
+  # Broken out from {ArrayType} so that {TupleType} can inherit from
+  # {ArrayType} and get share it's string handling functionality without 
+  # receiving the entry type stuff (which it handles differently).
+  # 
+  class ArrayOfType < ArrayType
+    
+    # Attributes
+    # ======================================================================
+    
+    # Type that all items must satisfy for an array to be a member of this
+    # type.
+    # 
+    # @return [NRSER::Types::Type]
+    #     
+    attr_reader :item_type
+    
+    
+    # Constructor
+    # ======================================================================
+    
+    # Instantiate a new `ArrayOfType`.
+    def initialize item_type, **options
+      super **options
+      @item_type = NRSER::Types.make item_type
+    end # #initialize
+    
+    
+    # Instance Methods
+    # ======================================================================
+    
+    def default_name
+      "#{ super() }<#{ @item_type }>"
+    end
+    
+    
+    def test value
+      # Check the super method first, which will test if `value` is an Array
+      # instance, and return `false` if it's not.
+      return false unless super( value )
+      
+      # Otherwise test all the items
+      value.all? &@item_type.method( :test )
     end
     
+    
+    # {ArrayOfType} can convert values from strings if it's {#item_type}
+    # can convert values from strings.
+    # 
+    # @return [Boolean]
+    # 
+    def has_from_s?
+      @item_type.has_from_s?
+    end
+    
+    
+    def items_from_strings items
+      items.map &@item_type.method( :from_s )
+    end
+    
+    
+    # @todo
+    #   I'm not even sure why this is implemented... was it used somewhere?
+    #   
+    #   It doesn't seems too well thought out... seems like the reality of 
+    #   comparing types is much more complicated?
+    # 
     def == other
       equal?(other) || (
         other.class == self.class && @item_type == other.item_type
       )
     end
-  end # Array
+    
+  end # class ArrayOfType
   
-  # array
-  def self.array *args
-    Array.new *args
-  end
   
-  singleton_class.send :alias_method, :list, :array
+  # Eigenclass (Singleton Class)
+  # ========================================================================
+  # 
+  class << self
+    
+    # array
+    # 
+    # @return [NRSER::Types::Type]
+    # 
+    def array item_type = NRSER::NO_ARG, **options
+      if item_type == NRSER::NO_ARG
+        if options.empty?
+          ARRAY
+        else
+          ArrayType.new **options
+        end
+      else
+        ArrayOfType.new item_type, **options
+      end
+    end # #array
+    
+    alias_method :list, :array
+    
+  end # class << self (Eigenclass)
   
 end # NRSER::Types