nrser 0.2.2 → 0.3.0

data/lib/nrser/functions/module/method_objects.rb

@@ -0,0 +1,77 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+module NRSER
+  
+  # @!group Module Functions
+  # ==========================================================================
+  
+  # Core private method that supports all the other "method getters".
+  # 
+  # @private
+  # 
+  # @param [Module] mod
+  #   Module in question.
+  # 
+  # @param [Boolean] include_super
+  #   When `true`, includes inherited class methods.
+  # 
+  # @param [:class | :instance] type:
+  #   Get class or instance methods.
+  # 
+  # @param [Boolean] sort:
+  #   If `true`, will sort the methods by name, which is usually
+  #   the useful way to look at and use them.
+  # 
+  # @return [Array<(Method | UnboundMethod)>]
+  #   List of method objects (all bound to `mod`).
+  # 
+  def self.method_objects_for mod,
+                              include_super,
+                              type:,
+                              sort:,
+                              include_initialize: false
+    initialize_method = nil
+    
+    get_names, get_method = case type
+    when :class
+      [:methods, :method]
+      
+    when :instance
+      if include_initialize
+        # Only way I can figure out to find out if it is defined it to try
+        # to get the object and handle the error
+        begin
+          initialize_method = mod.instance_method :initialize
+        rescue NameError => error
+        else
+          # Don't want to include it if we're not `include_super` and it's
+          # inherited from a different module
+          unless include_super || initialize_method.owner == mod
+            initialize_method = nil
+          end
+        end
+      end
+      
+      [:instance_methods, :instance_method]
+      
+    else
+      raise ArgumentError,
+        "`type:` must be `:class` or `:instance`, found #{ type.inspect }"
+      
+    end # case type
+    
+    methods = mod.send( get_names, include_super ).map { |name|
+      mod.send get_method, name
+    }
+    
+    methods << initialize_method unless initialize_method.nil?
+    
+    methods.sort! { |a, b| a.name <=> b.name } if sort
+    
+    methods
+  end # .method_objects_for
+  
+  # @!endgroup Module Functions
+  
+end # module NRSER

data/lib/nrser/functions/module.rb

@@ -1,2 +1 @@
-require_relative './module/methods'
-require_relative './module/source_locations'
+require_relative './module/method_objects'

data/lib/nrser/functions/open_struct.rb

@@ -1,9 +1,4 @@
 module NRSER
-  
-  # Eigenclass (Singleton Class)
-  # ========================================================================
-  # 
-  class << self
     
     # Deeply convert a {Hash} to an {OpenStruct}.
     # 
@@ -14,7 +9,7 @@ module NRSER
     # @raise [TypeError]
     #   If `hash` is not a {Hash}.
     # 
-    def to_open_struct hash, freeze: false
+    def self.to_open_struct hash, freeze: false
       unless hash.is_a? Hash
         raise TypeError,
               "Argument must be hash (found #{ hash.inspect })"
@@ -23,38 +18,33 @@ module NRSER
       _to_open_struct hash, freeze: freeze
     end # #to_open_struct
     
-    
-    private
-    
-      def _to_open_struct value, freeze:
-        result = case value
-        when OpenStruct
-          # Just assume it's already taken care of if it's already an OpenStruct
-          value
-          
-        when Hash
-          OpenStruct.new(
-            map_values(value) { |k, v| _to_open_struct v, freeze: freeze }
-          )
-          
-        when Array
-          value.map { |v| _to_open_struct v, freeze: freeze }
-          
-        when Set
-          Set.new value.map { |v| _to_open_struct v, freeze: freeze }
+  
+    def self._to_open_struct value, freeze:
+      result = case value
+      when OpenStruct
+        # Just assume it's already taken care of if it's already an OpenStruct
+        value
         
-        else
-          value
-        end
+      when Hash
+        OpenStruct.new(
+          value.transform_values { |v| _to_open_struct v, freeze: freeze }
+        )
         
-        if freeze
-          result.freeze
-        end
+      when Array
+        value.map { |v| _to_open_struct v, freeze: freeze }
         
-        result
-      end # ._to_open_struct
-    # end private
+      when Set
+        Set.new value.map { |v| _to_open_struct v, freeze: freeze }
+      
+      else
+        value
+      end
+      
+      result.freeze if freeze
+      
+      result
+    end # ._to_open_struct
     
-  end # class < self (Eigenclass)
+    private_class_method :_to_open_struct
   
 end # module NRSER

data/lib/nrser/functions/proc.rb

@@ -41,7 +41,6 @@ module NRSER
   end # .public_sender
   
   singleton_class.send :alias_method, :sender, :public_sender
-  singleton_class.send :alias_method, :sndr, :public_sender
   
   
   # Create a {Proc} that sends the arguments to a receiver via `#send`,
@@ -94,8 +93,6 @@ module NRSER
     }
   end # .chainer
   
-  singleton_class.send :alias_method, :chnr, :chainer
-  
   
   # Return a {Proc} that accepts a single argument that must respond to `#[]`
   # and retrieves `key` from it.
@@ -107,9 +104,7 @@ module NRSER
   # 
   def self.retriever key
     ->( indexed ) { indexed[key] }
-  end # .getter
-  
-  singleton_class.send :alias_method, :rtvr, :retriever
+  end # .retriever
   
   
 end # module NRSER

data/lib/nrser/functions/string/looks_like.rb

@@ -23,10 +23,16 @@ module NRSER
   JSON_ARRAY_RE = /\A\s*\[.*\]\s*\z/m.freeze
   
   
+  # Regexp used to guess if a string is a JSON-encoded object.
+  # 
+  # @return [Regexp]
+  # 
+  JSON_OBJECT_RE = /\A\s*\{.*\}\s*\z/m.freeze
+  
+  
   # Functions
   # ============================================================================
   
-
   # 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 `]`.
@@ -41,4 +47,29 @@ module NRSER
     !!( string =~ JSON_ARRAY_RE )
   end # #looks_like_json_array
   
+  
+  # Test if a string looks like it might encode an object in JSON format
+  # (JSON object becomes a {Hash} in Ruby) 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 object.
+  # 
+  def self.looks_like_json_object? string
+    !!( string =~ JSON_OBJECT_RE )
+  end # .looks_like_json_object?
+  
+  
+  def self.looks_like_yaml_object? string
+    # YAML is (now) a super-set of JSON, so anything that looks like a JSON
+    # object is kosh
+    looks_like_json_object?( string ) || string.lines.all? { |line|
+      line.start_with?( '---', '  ', '#' ) || line =~ /[^\ ].*\:/
+    }
+  end
+  
+  
 end # module NRSER

data/lib/nrser/functions/string.rb

@@ -95,45 +95,6 @@ module NRSER
     
   end # .lazy_filter_repeated_blank_lines
   
-
-  # Truncates a given +text+ after a given <tt>length</tt> if +text+ is longer than <tt>length</tt>:
-  #
-  #   'Once upon a time in a world far far away'.truncate(27)
-  #   # => "Once upon a time in a wo..."
-  #
-  # Pass a string or regexp <tt>:separator</tt> to truncate +text+ at a natural break:
-  #
-  #   'Once upon a time in a world far far away'.truncate(27, separator: ' ')
-  #   # => "Once upon a time in a..."
-  #
-  #   'Once upon a time in a world far far away'.truncate(27, separator: /\s/)
-  #   # => "Once upon a time in a..."
-  #
-  # The last characters will be replaced with the <tt>:omission</tt> string (defaults to "...")
-  # for a total length not exceeding <tt>length</tt>:
-  #
-  #   'And they found that many people were sleeping better.'.truncate(25, omission: '... (continued)')
-  #   # => "And they f... (continued)"
-  # 
-  # adapted from
-  # 
-  # <https://github.com/rails/rails/blob/7847a19f476fb9bee287681586d872ea43785e53/activesupport/lib/active_support/core_ext/string/filters.rb#L46>
-  # 
-  def self.truncate(str, truncate_at, options = {})
-    return str.dup unless str.length > truncate_at
-
-    omission = options[:omission] || '...'
-    length_with_room_for_omission = truncate_at - omission.length
-    stop = \
-      if options[:separator]
-        str.rindex(options[:separator], length_with_room_for_omission) || length_with_room_for_omission
-      else
-        length_with_room_for_omission
-      end
-
-    "#{str[0, stop]}#{omission}"
-  end # .truncate
-  
   
   # Cut the middle out of a sliceable object with length and stick an ellipsis
   # in there instead.
@@ -141,7 +102,7 @@ module NRSER
   # Categorized with {String} functions 'cause that's where it started, and
   # that's probably how it will primarily continue to be used, but tested to
   # work on {Array} and should for other classes that satisfy the same
-  # slice and  interface.
+  # slice and interface.
   # 
   # @param [V & #length & #slice & #<< & #+] source
   #   Source object. In practice, {String} and {Array} work. In theory,

data/lib/nrser/functions/text/lines.rb

@@ -44,7 +44,8 @@ module NRSER
     when Array
       text
     else
-      raise TypeError, "Expected String or Array, found #{ text.class.name }"
+      raise TypeError,
+        "Expected String or Array, found #{ text.class.safe_name }"
     end
   end
   

data/lib/nrser/functions.rb

@@ -7,7 +7,6 @@ require_relative './functions/proc'
 require_relative './functions/object'
 require_relative './functions/string'
 require_relative './functions/text'
-require_relative './functions/binding'
 require_relative './functions/exception'
 require_relative './functions/enumerable'
 require_relative './functions/hash'

data/lib/nrser/graph/tsorter.rb

@@ -0,0 +1,41 @@
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# Requirements
+# =======================================================================
+
+# Stdlib
+# -----------------------------------------------------------------------
+
+# Topological sorting
+require 'tsort'
+
+
+# Declarations
+# =======================================================================
+
+module NRSER; end
+module NRSER::Graph; end
+
+
+# Definitions
+# =======================================================================
+
+# Topologically sorts an {Enumerable} by a user-provided `child_node` block.
+# 
+class NRSER::Graph::TSorter
+  include TSort
+  
+  def initialize entries, &each_child
+    @entries = entries
+    @each_child = each_child
+  end
+  
+  def tsort_each_node &block
+    @entries.each &block
+  end
+  
+  def tsort_each_child node, &block
+    @each_child.call node, &block
+  end
+end # class NRSER::Graph::TSorter

data/lib/nrser/labs/core_ext/binding.rb

@@ -0,0 +1,37 @@
+class Binding
+  
+  # Experimental "adaptive" call from local variable names.
+  # 
+  def call_block *args, &block
+    arg_count = 0
+    arg_rest = false
+    call_kwds = {}
+    block.parameters.each do |type, name|
+      logger.debug "Processing", type: type, name: name
+      
+      case type
+      when :req, :opt
+        arg_count += 1
+      when :keyreq, :key
+        if self.local_variable_defined? name
+          call_kwds[name] = self.local_variable_get name
+        end
+      when :rest
+        arg_rest = true
+      end
+    end
+    
+    call_args = if arg_rest
+      args
+    else
+      args[0...arg_count]
+    end
+    
+    logger.debug "CALLING WITH",
+      args: call_args,
+      kwds: call_kwds
+    
+    block.call *call_args, **call_kwds
+  end
+  
+end # class Binding