nrser 0.2.2 → 0.3.0

data/lib/nrser/types/where.rb

@@ -1,22 +1,107 @@
-require 'nrser/refinements'
-using NRSER
+# encoding: UTF-8
+# frozen_string_literal: true
+
+require_relative './type'
 
 module NRSER::Types
+  
+  # {Where} instances are predicate functions¹ as a type.
+  # 
+  # They have a {#predicate} block, and {#test?} calls it with values and
+  # returns the boolean of the result (double-bangs it `!!`).
+  # 
+  # Super simple, right? And easy! Why don't we just use these things all over
+  # the place?
+  # 
+  # If you're been around the programing block a few times, you probably saw
+  # this coming a mile away: you should avoid using them.
+  # 
+  # Yeah, sorry. Here's the reasons:
+  # 
+  # 1.  They're **opaque** - it's hard to see inside a {Proc}... even if you
+  #     got the source code (which seems like it requires gems and involves
+  #     some amount of hackery), that wouldn't really give you the whole
+  #     picture because you need to look at the binding as well... Ruby
+  #     procs capture their entire environment.
+  #     
+  #     Essentially, they suck to easily and/or comprehensively communicate
+  #     what they hell they do.
+  #     
+  # 2.  Like {When}, they're totally Ruby-centric... we can't really serialize
+  #     them and pass them off anywhere, so they're shitty for APIs and
+  #     property types and stuff that you may want or need to expose outside
+  #     the runtime.
+  #     
+  #     In this sense they're ok as implementations of types like {.file_path}
+  #     that represent an *idea* to be communicated to the outside world,
+  #     where each system that handles that idea will need to have it's own
+  #     implementation of it.
+  #     
+  #     Lit addresses a lot of this with serializable functions, but that's
+  #     nowhere near ready to rock, and support for it would probably be
+  #     added along side {Where}, not in place of it (since {Where} is
+  #     probably still going to be used and useful).
+  # 
+  # So please be aware of those, and be reasonable about your {Where}s.
+  # 
+  # > ¹ I say *functions*, because they really *should* be functions (same
+  # > input always gets same output, pure, etc.).
+  # >
+  # > Yeah, there's not much stopping you from making them state-based or
+  # > random or whatever, but please don't do that shit unless you've really
+  # > thought it through. And if you still do, please write me and tell me
+  # > what you thought and why it's a reasonable idea and I'll update this.
+  # 
   class Where < NRSER::Types::Type
+    
+    # Predicate {Proc} used to test value for membership.
+    # 
+    # @return [Proc<(V) => Boolean>]
+    #   Really, we double-bang (`!!`) whatever the predicate returns to
+    #   get the result in {#test?}, but you get the idea... the response will
+    #   be evaluated on its truthiness.
+    # 
     attr_reader :predicate
     
-    def initialize predicate, **options
+    
+    # Make a new {Where}.
+    # 
+    # @param [Proc<(V) => Boolean>] &predicate
+    #   See {#predicate}.
+    # 
+    # @param **options (see NRSER::Types::Type#initialize)
+    # 
+    def initialize **options, &predicate
       super **options
+      
+      unless predicate.arity == 1
+        raise NRSER::ArgumentError.new \
+          "Predicate block must have arity 1",
+          predicate: predicate,
+          options: options
+      end
+      
       @predicate = predicate
     end
     
-    def test value
+    
+    # Test a value for membership.
+    # 
+    # @param  (see NRSER::Types::Type#test?)
+    # @return (see NRSER::Types::Type#test?)
+    # @raise  (see NRSER::Types::Type#test?)
+    # 
+    def test? value
       !!@predicate.call(value)
     end
-  end # Where
+    
+  end # class Where
   
-  # create a type based on a predicate
-  def self.where **options, &block
-    Where.new block, **options
+  
+  # Get a type based on a predicate.
+  # 
+  def_factory :where do |**options, &predicate|
+    Where.new **options, &predicate
   end
-end # NRSER::Types
+  
+end # NRSER::Types

data/lib/nrser/types.rb

@@ -1,3 +1,6 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
 # Abstract infrastructure for type creation - stuff that doesn't define any
 # concrete type instances.
 # 
@@ -6,13 +9,9 @@
 # uncontrollable mutability of Ruby and the importance of type checks)
 # need to be required in the "Post-Processing" section at the bottom.
 # 
-require_relative './types/type'
-
-# Refinements
-# =======================================================================
-
-using NRSER
 
+# Want to mix logging in
+require 'nrser/log'
 
 # Stuff to help you define, test, check and match types in Ruby.
 # 
@@ -20,9 +19,31 @@ using NRSER
 # 
 module NRSER::Types
   
+  # Sub-Tree Requirements
+  # ========================================================================
+  
+  require_relative './types/type'
+  require_relative './types/factory'
+  
+  
+  # Mixins
+  # ========================================================================
+  
+  extend Factory
+  include NRSER::Log::Mixin
+  
+  
+  # Constants
+  # ========================================================================
+  
   L_PAREN = '(' # '❪'
   R_PAREN = ')' # '❫'
   RESPONDS_WITH = '→'
+  ASSOC = '=>'
+  
+  
+  # Module Methods
+  # ========================================================================
   
   # Make a {NRSER::Types::Type} from a value.
   # 
@@ -55,17 +76,56 @@ module NRSER::Types
   end
   
   
-  # raise an error if value doesn't match type.
-  def self.check value, type
-    make(type).check value
+  # The {.make} method reference; for easy map and such.
+  # 
+  # @return [Method]
+  # 
+  def self.maker
+    method :make
+  end
+  
+  
+  # Create a {NRSER::Types::Type} from `type` with {.make} and check that
+  # `value` satisfies it, raising if it doesn't.
+  # 
+  # @param [*] value
+  #   Value to type check.
+  # 
+  # @param [*] type
+  #   Type to check value against.
+  # 
+  # @return
+  #   The `value` parameter.
+  # 
+  # @raise [NRSER::Types::CheckError]
+  #   If the value fails the type check.
+  # 
+  def self.check! value, type
+    make( type ).check! value
   end
   
+  # Old name
+  singleton_class.send :alias_method, :check, :check!
+  
   
-  def self.test value, type
+  # Create a {NRSER::Types::Type} from `type` with {.make} and test if
+  # `value` satisfies it.
+  # 
+  # @return [Boolean]
+  #   `true` if `value` satisfies `type`.
+  # 
+  def self.test? value, type
     make(type).test value
   end
   
+  # Old name
+  singleton_class.send :alias_method, :test, :test?
+  
   
+  # @todo
+  #   Switch {NRSER::Types.match} to use `===`! Should allow us to avoid
+  #   making types for everything?
+  #   
   def self.match value, *clauses
     if clauses.empty?
       raise ArgumentError.new NRSER.dedent <<-END
@@ -95,7 +155,7 @@ module NRSER::Types
     end
     
     enum.each { |type, expression|
-      if test value, type
+      if test? value, type
         # OK, we matched! Is the corresponding expression callable?
         if expression.respond_to? :call
           # It is; invoke and return result.
@@ -138,57 +198,6 @@ module NRSER::Types
     }
   end # .from_repr
   
-  
-  # Define a type factory.
-  # 
-  # @!macro [attach] factory
-  #   @param [Hash] **options
-  #     Common type construction options, see {Type#initialize}.
-  #   
-  #   @return [NRSER::Types::Type]
-  #     The type.
-  # 
-  def self.def_factory name, maybe: true, aliases: [], &body
-    define_singleton_method name, &body
-    
-    aliases.each do |alias_name|
-      singleton_class.send :alias_method, alias_name, name
-    end
-    
-    if maybe && !name.to_s.end_with?( '?' )
-      maybe_name = "#{ name }?".to_sym
-      
-      # HACK  Ugh maybe I wrote this quick to fix it, not sure if it's a decent
-      #       idea.. basically, need to figure out what `options` keys go
-      #       to {.maybe} and which ones go to the regular factory... matters
-      #       for shit like {.attrs} and {.hash_type} 'cause they use option
-      #       keys (whether they *should* is something I've debated... sigh,
-      #       it is what it is for now).
-      #       
-      #       So they options that go to {.maybe} just go strait through to
-      #       {Type#initialize}, so just grab that method, see what keys it
-      #       takes, and then can slice and dice off that...
-      # 
-      maybe_option_keys = Set.new \
-        Type.
-          instance_method( :initialize ).
-          parameters.
-          select { |param_type, name| param_type == :key }.
-          map { |param_type, name| name }
-      
-      define_singleton_method maybe_name do |*args, **options|
-        maybe_options = options.slice *maybe_option_keys
-        factory_options = options.except *maybe_option_keys
-        
-        maybe public_send( name, *args, **factory_options ), **maybe_options
-      end
-      
-      aliases.each do |alias_name|
-        singleton_class.send :alias_method, "#{ alias_name }?", maybe_name
-      end
-    end
-  end
-  
 end # NRSER::Types
 
 
@@ -218,7 +227,7 @@ require_relative './types/numbers'
 require_relative './types/strings'
 require_relative './types/symbols'
 require_relative './types/labels'
-require_relative './types/array'
+require_relative './types/arrays'
 require_relative './types/hashes'
 require_relative './types/paths'
 require_relative './types/tuples'

data/lib/nrser/version.rb

@@ -18,7 +18,7 @@ module NRSER
   # 
   # @return [String]
   # 
-  VERSION = '0.2.2'
+  VERSION = '0.3.0'
   
   
   module Version

data/lib/nrser.rb

@@ -14,13 +14,20 @@ require 'pp'
 require 'ostruct'
 require 'json'
 require 'yaml'
-require 'logger'
 require 'singleton'
 
 # Deps
 # -----------------------------------------------------------------------
 require 'hamster'
 
+### Active Support
+# 
+# We're not going to import all of it, but here we'll import the stuff we
+# always want to use and then add pieces in places as needed.
+# 
+require 'active_support/json'
+# require 'active_support/core_ext/object/json'
+
 
 # Hi there!
 # 
@@ -47,33 +54,26 @@ require 'hamster'
 # Enjoy!
 # 
 
-# 1.  Load up version, which has {NRSER::ROOT} in it and depends on nothing
-#     else, then logging
+# Load up version, which has {NRSER::ROOT} in it and depends on nothing else
 require_relative './nrser/version'
-require_relative './nrser/logging'
 
-# 2.  Load up extension mixins first - they don't invoke anything, just define
-#     methods
-require_relative './nrser/ext'
+# {Module.safe_name} is really useful all around, including in logging
+require_relative './nrser/core_ext/module/names'
 
-# 3.  Then load up the refinements, which either include the extension mixins
-#     or directly define proxies and methods (but don't execute them).
-#     
-#     This way everything else should be able to use them.
-#     
-require_relative './nrser/refinements'
+# Then logging can come in...
+require_relative './nrser/log'
 
-# 4.  Then everything else...
+# Tons need this for error messages
+require_relative './nrser/core_ext/binding'
+
+# Then everything else...
 require_relative './nrser/char'
 require_relative './nrser/errors'
 require_relative './nrser/no_arg'
 require_relative './nrser/message'
-require_relative './nrser/env'
 require_relative './nrser/collection'
 require_relative './nrser/functions'
 require_relative './nrser/types'
 require_relative './nrser/meta'
+require_relative './nrser/props'
 require_relative './nrser/mean_streak'
-
-# 5.  Stuff that *uses* the refinements *at require time* (usually defining
-#     constants or meta-programming)

data/spec/lib/nrser/{functions/binding/template_spec.rb → core_ext/binding/erb_spec.rb}

@@ -1,11 +1,11 @@
-require 'spec_helper'
+require 'nrser/core_ext/binding'
 
-describe 'NRSER.template' do
+describe 'Binding#erb' do
   it "processes a simple template" do
     x = 1
 
     expect(
-      NRSER.template binding, <<-BLOCK
+      binding.erb <<-BLOCK
         x is <%= x %>
       BLOCK
     ).to eq NRSER.dedent <<-BLOCK
@@ -14,7 +14,7 @@ describe 'NRSER.template' do
   end
 
   it "handles edge cases" do
-    expect( NRSER.template binding, ''     ).to eq ''
-    expect( NRSER.template binding, 'blah' ).to eq 'blah'
+    expect( binding.erb ''     ).to eq ''
+    expect( binding.erb 'blah' ).to eq 'blah'
   end
 end # template

data/spec/lib/nrser/{functions → core_ext}/enumerable/find_map_spec.rb

@@ -1,13 +1,15 @@
+require 'nrser/core_ext/enumerable/find_map'
+
 describe_spec_file(
   spec_path: __FILE__,
-  module: NRSER,
-  method: :find_map,
+  module: Enumerable,
+  instance_method: :find_map,
 ) do
   
   describe "when a result is found" do
     it "should return the block result" do
       expect(
-        subject.call( [1, 2, 3, 4] ) do |i|
+        [1, 2, 3, 4].find_map do |i|
           if i.even?
             "#{ i } is even!"
           end
@@ -20,7 +22,7 @@ describe_spec_file(
   describe "when block returns `false`" do
     it "should not be considered 'found'" do
       expect(
-        subject.call( [1, 2, 3] ) { |i| false }
+        [1, 2, 3].find_map { |i| false }
       ).to be nil
     end
   end
@@ -29,10 +31,10 @@ describe_spec_file(
   describe "when none found and `ifnone` provided" do
     it "should call `ifnone` and return the response" do
       expect(
-        subject.call( [], ->(){ 'blah' } ) { |i| false }
+        [].find_map( -> { 'blah' } ) { |i| false }
       ).to eq 'blah'
     end
   end # "when none found and `ifnone` provided"
   
   
-end
+end # spec_file

data/spec/lib/nrser/{refinements → core_ext}/hash_spec.rb

@@ -1,19 +1,6 @@
-require 'spec_helper'
+require 'nrser/core_ext/hash'
 
-using NRSER
-
-describe 'Refinement Hash#map_values' do
-  it do
-    expect(
-      {x: 1, y: 2}.map_values { |key, value| value + 1 }
-    ).to eq(
-      {x: 2, y: 3}
-    )
-  end
-end # 'Hash#map_values'
-
-
-describe 'Refinement Hash#find_bounded' do
+describe 'Hash#find_bounded' do
   subject { {a: 1, b: 2, c: 3} }
   
   it do
@@ -25,10 +12,10 @@ describe 'Refinement Hash#find_bounded' do
       subject.find_bounded(length: 2) { |k, v| v == 2 }
     }.to raise_error TypeError
   end
-end # Refinement Hash#map_values
+end # Hash#find_bounded
 
 
-describe 'Refinement Hash#find_only' do
+describe 'Hash#find_only' do
   subject { {a: 1, b: 2, c: 3} }
   
   it do
@@ -40,17 +27,17 @@ describe 'Refinement Hash#find_only' do
       subject.find_only { |k, i| i >= 2 }
     }.to raise_error TypeError
   end
-end # Refinement Hash#map_values
+end # Hash#find_only
 
 
-describe "Refinement Hash#leaves" do
+describe "Hash#leaves" do
   subject { {a: 1, b: 2, c: 3}.leaves }
   
   it { is_expected.to eq( {[:a] => 1, [:b] => 2, [:c] => 3}) }
-end # Refinement Hash#leaves
+end # Hash#leaves
 
 
-describe "Refinement Hash#each_branch" do
+describe "Hash#each_branch" do
   let( :abc_hash ) { {a: 1, b: 2, c: 3} }
   
   context "called with no block" do
@@ -74,4 +61,4 @@ describe "Refinement Hash#each_branch" do
     it { is_expected.to eq(a: 1, b: 4, c: 9) }
   end # called with a block
   
-end # Refinement Hash#each_branch
+end # Hash#each_branch

data/spec/lib/nrser/errors/abstract_method_error_spec.rb

@@ -23,7 +23,7 @@ describe_class NRSER::AbstractMethodError do
         NRSER::TestFixtures::AbstractMethodError::Base.new.f
       }.to raise_error(
         NRSER::AbstractMethodError,
-        /Base is an abstract class/
+        /Method #f is abstract/
       )
     end
     
@@ -34,10 +34,17 @@ describe_class NRSER::AbstractMethodError do
     it "explains that an implementing class needs to be found or written" do
       expect {
         NRSER::TestFixtures::AbstractMethodError::Sub.new.f
-      }.to raise_error(
-        NRSER::AbstractMethodError,
-        /find a subclass of .*Sub to instantiate or write your own/
-      )
+      }.to raise_error NRSER::AbstractMethodError
+      
+      
+      message = begin
+        NRSER::TestFixtures::AbstractMethodError::Sub.new.f
+      rescue Exception => e
+        e.to_s
+      end
+      
+      expect( message ).to match \
+        /find a subclass of NRSER::TestFixtures::AbstractMethodError::Sub to instantiate/
     end
     
   end # when raising method is invoked through instance of a subclass

data/spec/lib/nrser/functions/enumerable/{to_h_by_spec.rb → associate_spec.rb}

@@ -1,7 +1,7 @@
 describe_spec_file(
   spec_path: __FILE__,
   module: NRSER,
-  method: :to_h_by,
+  method: :assoc_by,
 ) do
     
   describe "when map does not result in duplicate keys" do

data/spec/lib/nrser/functions/merge_by_spec.rb

@@ -42,7 +42,7 @@ describe "NRSER.merge_by" do
     }
     
     subject {
-      super().call current, update, &[:item_id].digger
+      super().call current, update, &[:item_id].to_digger
     }
     
     it {

data/spec/lib/nrser/functions/tree/each_branch_spec.rb

@@ -9,14 +9,14 @@ describe "NRSER.each_branch" do
   
   context "called without a block" do
     context "called with arrays" do
-      when_called_with( [] ) {
+      describe_called_with( [] ) {
         it {
           is_expected.to be_a( Enumerator ).
             and have_attributes size: 0
         }
       }
       
-      when_called_with( [:x, :y, :z] ) {
+      describe_called_with( [:x, :y, :z] ) {
         it {
           is_expected.to be_a( Enumerator ).
             and have_attributes size: 3
@@ -25,7 +25,7 @@ describe "NRSER.each_branch" do
     end # called with arrays
     
     context "called with hashes" do
-      when_called_with( {} ) {
+      describe_called_with( {} ) {
         it {
           is_expected.to be_a( Enumerator ).
             and have_attributes size: 0

data/spec/lib/nrser/functions/tree/transform_spec.rb

@@ -13,8 +13,8 @@ describe "NRSER.transform" do
       
       let( :tree ) {
         {
-          x: :y.retriever,
-          y: :x.retriever,
+          x: :y.to_retriever,
+          y: :x.to_retriever,
         }
       } # let :tree
       
@@ -35,8 +35,8 @@ describe "NRSER.transform" do
       let :tree do
         {
           users: {
-            { id: :id.retriever } => {
-              name: :name.retriever,
+            { id: :id.to_retriever } => {
+              name: :name.to_retriever,
             }
           }
         }
@@ -65,8 +65,8 @@ describe "NRSER.transform" do
       let :tree do
         {
           list: [
-            { name: :name.rtvr },
-            { age: :age.rtvr },
+            { name: :name.to_retriever },
+            { age: :age.to_retriever },
           ]
         }
       end
@@ -119,15 +119,15 @@ describe "NRSER.transform" do
       let :tree do
         {
           users: {
-            { contact_id: [ :parent, :id ].chainer } => {
+            { contact_id: [ :parent, :id ].to_chainer } => {
               addresses: {
-                { 
-                  address_id: [ :id ].sender } => {
-                  district:   :address.retriever,
-                  line_1:     :street2.retriever,
-                  city:       :city.retriever,
-                  province:   :state.retriever,
-                  post_code:  :zip.retriever,
+                {
+                  address_id: [ :id ].to_sender } => {
+                  district:   :address.to_retriever,
+                  line_1:     :street2.to_retriever,
+                  city:       :city.to_retriever,
+                  province:   :state.to_retriever,
+                  post_code:  :zip.to_retriever,
                 }
               }
             }
@@ -159,4 +159,3 @@ describe "NRSER.transform" do
   
   
 end # NRSER.transform
-

data/spec/lib/nrser/gem_ext/hamster/json_spec.rb

@@ -0,0 +1,4 @@
+##
+# We want {Hamster} containers to automatically encode as JSON, even though
+# it obviously won't automatically go two-ways.
+##