y_support 2.1.5 → 2.1.12

data/lib/y_support/abstract_algebra.rb

@@ -231,3 +231,4 @@ class Matrix
     build r_count, c_count do |r, c| WILDCARD_ZERO end
   end
 end
+

data/lib/y_support/all.rb

@@ -42,3 +42,4 @@ require 'y_support/misc'
 #     end
 #   end
 # end # class BlankSlate
+

data/lib/y_support/core_ext/array.rb

@@ -1,2 +1,2 @@
-require 'y_support'
-require 'y_support/core_ext/array/misc'
+require 'y_support' unless defined? YSupport
+require File.dirname( __FILE__ ) + '/array/misc'

data/lib/y_support/core_ext/class/misc.rb

@@ -1,17 +1,16 @@
-#encoding: utf-8
-
 class Class
   # Creates a subclass of the current class parametrized with a given set of
   # parameters. The parameters have form { symbol: value } and they cause
   # singleton method(s) named "symbol" be defined on the subclass, returning
   # "value".
   # 
-  def parametrize parameters
+  def parametrize **parameters, &block
     Class.new( self ).tap do |subclass|
       parameters.each_pair { |symbol, value|
         subclass.define_singleton_method symbol do value end
       }
       subclass.define_singleton_method inspect do subclass.superclass.inspect + "<" end
+      subclass.class_exec &block if block
     end
   end
 end

data/lib/y_support/core_ext/class.rb

@@ -1,2 +1,2 @@
-require 'y_support'
-require 'y_support/core_ext/class/misc'
+require 'y_support' unless defined? YSupport
+require File.dirname( __FILE__ ) + '/class/misc'

data/lib/y_support/core_ext/enumerable/misc.rb

@@ -1,4 +1,4 @@
-#encoding: utf-8
+# encoding: utf-8
 
 module Enumerable
   # Checks whether #all? collection elements are #kind_of? module

data/lib/y_support/core_ext/enumerable.rb

@@ -1,2 +1,2 @@
-require 'y_support'
-require 'y_support/core_ext/enumerable/misc'
+require 'y_support' unless defined? YSupport
+require File.dirname( __FILE__ ) + '/enumerable/misc'

data/lib/y_support/core_ext/hash/misc.rb

@@ -1,10 +1,8 @@
-# encoding: utf-8
-
 require 'active_support/core_ext/hash/reverse_merge'
 
 class Hash
   class << self
-    # This kluge method guards against overwriting of the #slice method by
+    # This kludge method guards against overwriting of the #slice method by
     # ActiveSupport.
     # 
     def method_added( sym )
@@ -26,11 +24,8 @@ class Hash
             # 
             define_method sym do |matcher|
               self.class[ case matcher
-                          when Array then
-                            select { |key, _| matcher.include? key }
-                          else
-                            select { |key, _| matcher === key }
-                          end ]
+                          when Array then select { |k, _| matcher.include? k }
+                          else select { |k, _| matcher === k } end ]
             end
           end
 
@@ -49,8 +44,8 @@ class Hash
   # Applies a block as a mapping on all keys, returning a new hash.
   # 
   def with_keys
-    keys.each_with_object self.class.new do |hash_key, hsh|
-      hsh[ yield hash_key ] = self[ hash_key ]
+    keys.each_with_object self.class.new do |key, hsh|
+      hsh[ yield key ] = self[ key ]
     end
   end
 
@@ -58,8 +53,8 @@ class Hash
   # 2 arguments (key: value pair) and returns the new key.
   # 
   def modify_keys
-    each_with_object self.class.new do |hash_pair, hsh|
-      hsh[ yield( hash_pair ) ] = self[ hash_pair[0] ]
+    each_with_object self.class.new do |pair, hsh|
+      hsh[ yield pair ] = self[ pair[0] ]
     end
   end
 
@@ -79,25 +74,25 @@ class Hash
   # that takes 2 arguments (key: value pair) and returns the new value.
   # 
   def modify_values
-    each_with_object self.class.new do |hash_pair, ꜧ|
-      ꜧ[ hash_pair[0] ] = yield( hash_pair )
+    each_with_object self.class.new do |pair, hsh|
+      hsh[ pair[0] ] = yield pair
     end
   end
 
   # Like #modify_values, but modifies the receiver.
   # 
   def modify_values!
-    each_with_object self do |hash_pair, ꜧ|
-      ꜧ[ hash_pair[0] ] = yield( hash_pair )
+    each_with_object self do |pair, hsh|
+      hsh[ pair[0] ] = yield pair
     end
   end
 
   # Like #map that returns a hash.
   # 
   def modify
-    each_with_object self.class.new do |hash_pair, ꜧ|
-      key, val = yield hash_pair
-      ꜧ[key] = val
+    each_with_object self.class.new do |pair, hsh|
+      key, val = yield pair
+      hsh[key] = val
     end
   end
 
@@ -113,11 +108,8 @@ class Hash
   # 
   def slice matcher
     self.class[ case matcher
-                when Array then
-                  select { |key, _| matcher.include? key }
-                else
-                  select { |key, _| matcher === key }
-                end ]
+                when Array then select { |key, _| matcher.include? key }
+                else select { |key, _| matcher === key } end ]
   end
 
   # Makes hash keys accessible as methods. If the hash keys collide with
@@ -125,31 +117,26 @@ class Hash
   # option == true.
   # 
   def dot! overwrite_methods: false
-    keys.each do |key|
-      msg = "key #{key} of #dot!-ted hash is not convertible to a symbol"
-      fail ArgumentError, msg unless key.respond_to? :to_sym
-      msg = "#dot!-ted hash must not have key names colliding with its methods"
-      fail ArgumentError, msg if methods.include? key.to_sym unless
-        overwrite_methods
+    each_pair do |key, _|
+      fail ArgumentError, "key #{key} of #dot!-ted hash is not convertible " +
+        "to a symbol" unless key.respond_to? :to_sym
+      fail ArgumentError, "#dot!-ted hash must not have keys colliding with " +
+        "its methods" if methods.include? key.to_sym unless overwrite_methods
       define_singleton_method key.to_sym do self[key] end
-      define_singleton_method "#{key}=".to_sym do |value| self[key] = value end
+      define_singleton_method "#{key}=".to_sym do |val| self[key] = val end
     end
-    return self
   end
 
   # Pretty-prints the hash consisting of names as keys, and numeric values.
   # Takes 2 named arguments: +:gap+ and +:precision+.
   # 
   def pretty_print_numeric_values gap: 0, precision: 2
-    key_strings = keys.map &:to_s
+    lmax = keys.map( &:to_s ).map( &:size ).max
     value_strings = values.map { |n| "%.#{precision}f" % n rescue "%s" % n }
-    lmax, rmax = key_strings.map( &:size ).max, value_strings.map( &:size ).max
+    rmax = value_strings.map( &:size ).max
     lgap = gap / 2
     rgap = gap - lgap
-    key_strings.zip( value_strings ).map do |kς, vς|
-      "%- #{lmax+lgap+1}s%#{rmax+rgap+1}.#{precision}f" % [ kς, vς ]
-    end.each { |line| puts line }
-    return nil
+    line = "%- #{lmax+lgap+1}s%#{rmax+rgap+1}.#{precision}f"
+    puts keys.zip( values ).map &line.method( :% )
   end
 end
-

data/lib/y_support/core_ext/hash.rb

@@ -1,2 +1,2 @@
-require 'y_support'
-require 'y_support/core_ext/hash/misc'
+require 'y_support' unless defined? YSupport
+require File.dirname( __FILE__ ) + '/hash/misc'

data/lib/y_support/core_ext/module/misc.rb

@@ -1,5 +1,30 @@
-#encoding: utf-8
+class Module
+  # Sets a constant to a value if this has not been previously defined.
+  # 
+  def const_set_if_not_defined( const, value )
+    const_set( const, value ) unless const_defined? const
+  end
 
+  # Redefines a constant without warning.
+  # 
+  def const_reset!( const, value )
+    send :remove_const, const if const_defined? const
+    const_set( const, value )
+  end
+
+  # Defines a set of methods by applying the block on the return value of
+  # another set of methods. Accepts a hash of pairs { mapped_method_symbol =>
+  # original_method_symbol } and a block which to chain to the original
+  # method result.
+  # 
+  def chain **hash, &block
+    hash.each_pair { |mapped_method_symbol, original_method_symbol|
+      define_method mapped_method_symbol do |*args, &b|
+        block.( send original_method_symbol, *args, &b )
+      end
+    }
+  end
+end
 class Module
   # Sets a constant to a value if this has not been previously defined.
   # 
@@ -13,4 +38,17 @@ class Module
     send :remove_const, const if const_defined? const
     const_set( const, value )
   end
+
+  # Defines a set of methods by applying the block on the return value of
+  # another set of methods. Accepts a hash of pairs { mapped_method_symbol =>
+  # original_method_symbol } and a block which to chain to the original
+  # method result.
+  # 
+  def chain **hash, &block
+    hash.each_pair { |mapped_method_symbol, original_method_symbol|
+      define_method mapped_method_symbol do |*args, &b|
+        block.( send original_method_symbol, *args, &b )
+      end
+    }
+  end
 end

data/lib/y_support/core_ext/module.rb

@@ -1,2 +1,2 @@
-require 'y_support'
-require 'y_support/core_ext/module/misc'
+require 'y_support' unless defined? YSupport
+require File.dirname( __FILE__ ) + '/module/misc'

data/lib/y_support/core_ext/numeric/misc.rb

@@ -1,5 +1,3 @@
-#encoding: utf-8
-
 class << Integer
   def zero; 0 end
 end

data/lib/y_support/core_ext/numeric.rb

@@ -1,2 +1,2 @@
-require 'y_support'
-require 'y_support/core_ext/numeric/misc'
+require 'y_support' unless defined? YSupport
+require File.dirname( __FILE__ ) + '/numeric/misc'

data/lib/y_support/core_ext/object/inspection.rb

@@ -1,5 +1,3 @@
-# encoding: utf-8
-
 class Object
   # Constructs the string "#{self.class}:#{self}". Useful for inspection.
   # 

data/lib/y_support/core_ext/object/misc.rb

@@ -1,6 +1,6 @@
 # encoding: utf-8
 
-require 'y_support/core_ext/class'
+require File.dirname( __FILE__ ) + '/../class'
 
 class Object
   # Assigns prescribed atrributes to the object and makes them accessible with
@@ -14,38 +14,53 @@ class Object
     }
   end
 
-  # Assigns prescribed atrributes to the object and makes them accessible with
-  # getter (reader) methods. Shadows / overwrites existing methods.
+  # Like +#set_attr_with_readers+, but it overloads existing methods, if present.
+  # Whereas +#set_attr_with_readers+ guards against the presence of methods with
+  # the same name, +#set_attr_with_reader!+ overloads them in the following way:
+  #
+  # * Colliding instance method defined in the singleton class of the receiver
+  #   is overwritten (redefined).
+  # * Colliding instance methods defined on the receiver's class ancestors are
+  #   overloaded (partially shadowed). If the method message is sent without
+  #   arguments or block, the reader activates and returns the corresponding
+  #   instance variable regardless of what the behavior of the shadowed method
+  #   might have been. However, if the method message is sent with arguments
+  #   or block, the original method is invoked (via +super+) and its result
+  #   returned.
   # 
   def set_attr_with_readers! hash
     hash.each_pair { |symbol, value|
       instance_variable_set "@#{symbol}", value
-      singleton_class.class_exec { attr_reader symbol }
+      singleton_class.class_exec do
+        define_method symbol do |*args, &block|
+          return instance_variable_get "@#{symbol}" if args.empty? && block.nil?
+          super *args, &block
+        end
+      end
     }
   end
 
   # Constructs parametrized subclasses of the supplied classes and makes them
-  # available under specified getters. Expects a hash of pairs { reader_symbol:
-  # class }, and a hash of parameters, with which the class(es) is (are)
-  # parametrized. Raises NameError should any of the getters shadow / overwrite
-  # existing methods.
+  # available under specified getters. Expects a hash of pairs { symbol: class },
+  # and a hash of parameters with which to parametrize the class(es). Guards
+  # against collisions in the subclass getter symbols, rasing NameError should
+  # these shadow or overwrite existing methods.
   # 
-  def param_class hash, with: (fail ArgumentError, "No parameters!")
+  def param_class( hash, with: {} )
     hash.each { |ß, ç|
-      sub = ç.parametrize with
+      sub = ç.parametrize( with )
       set_attr_with_readers( ß => sub )
     }
     return nil
   end
 
-  # Constructs parametrized subclasses of the supplied classes and makes them
-  # available under specified getters. Expects a hash of pairs { reader_symbol:
-  # class }, and a hash of parameters, with which the class(es) is (are)
-  # parametrized. Shadows / overwrites existing methods.
+  # Like +#param_class+, but it shadows or overwrites existing methods colliding
+  # with the getters of the parametrized classes. See +#set_attr_with_readers!"
+  # for full explanation of the shadowing / overwriting behavior.
   # 
-  def param_class! hash, with: (fail ArgumentError, "No parameters!")
+  def param_class!( hash, with: {} )
     hash.each { |ß, ç|
-      sub = ç.parametrize with
+      sub = ç.parametrize( with )
       set_attr_with_readers!( ß => sub )
     }
     return nil

data/lib/y_support/core_ext/object.rb

@@ -1,3 +1,3 @@
-require 'y_support'
-require 'y_support/core_ext/object/misc'
-require 'y_support/core_ext/object/inspection'
+require 'y_support' unless defined? YSupport
+require File.dirname( __FILE__ ) + '/object/misc'
+require File.dirname( __FILE__ ) + '/object/inspection'

data/lib/y_support/core_ext/string/misc.rb

@@ -1,4 +1,4 @@
-#encoding: utf-8
+# encoding: utf-8
 
 require 'active_support/core_ext/object/blank'
 
@@ -32,7 +32,7 @@ class String
       .gsub("\n", "")
       .strip
   end
-  
+
   # Joins a paragraph of possibly indented, newline separated lines into a
   # single contiguous string.
   # 
@@ -43,19 +43,19 @@ class String
       .delete_if( &:blank? )         # delete blank lines
       .join " "                      # and join with whitspace
   end
-  
+
   # If the string is empty, it gets replace with the string given as argument.
   # 
   def default! default_string
     strip.empty? ? clear << default_string.to_s : self
   end
-  
+
   # As it says – replaces spaces with underscores.
   # 
   def underscore_spaces
     gsub ' ', '_'
   end
-  
+
   # Converts a string into a standard symbol. While Symbol class objects can
   # be created from any string, it is good practice to keep symbols free of
   # whitespaces and weird characters, so that the are typed easily, usable as
@@ -70,7 +70,7 @@ class String
       .squeeze(" ")
       .underscore_spaces
   end
-  
+
   # Applies #standardize to the receiver and converts the result to a symbol.
   # 
   def to_standardized_sym
@@ -78,7 +78,7 @@ class String
       .to_sym
   end
 
-  # Capitalizes a string and append an exclamation mark. Also allows optional
+  # Capitalizes a string and appends an exclamation mark. Also allows optional
   # argument for string interpolation. Handy for constructing error messages.
   # 
   def X! arg=nil

data/lib/y_support/core_ext/string.rb

@@ -1,2 +1,2 @@
-require 'y_support'
-require 'y_support/core_ext/string/misc'
+require 'y_support' unless defined? YSupport
+require File.dirname( __FILE__ ) + '/string/misc'

data/lib/y_support/core_ext/symbol/misc.rb

@@ -1,6 +1,5 @@
-# -*- coding: utf-8 -*-
 class Symbol
-  # This method applies String#default! method to the receiver converted to
+  # This method applies +String#default!+ method to the receiver converted to
   # a string. Of course, symbols are immutable, so in spite of the exclamation
   # mark in the method name, a new symbol (supplied as argument) is returned,
   # if the original one is considered "defaulted" (otherwise, original symbol
@@ -10,7 +9,7 @@ class Symbol
     to_s.default!( default_symbol ).to_sym
   end
   
-  # Applies String#to_standardized_sym method to the recevier converted to a
+  # Applies +String#to_standardized_sym+ method to the recevier converted to a
   # string.
   # 
   def to_standardized_sym

data/lib/y_support/core_ext/symbol.rb

@@ -1,2 +1,2 @@
-require 'y_support'
-require 'y_support/core_ext/symbol/misc'
+require 'y_support' unless defined? YSupport
+require File.dirname( __FILE__ ) + '/symbol/misc'

data/lib/y_support/core_ext.rb

@@ -1,5 +1,3 @@
-#encoding: utf-8
-
 Dir["#{File.dirname( __FILE__ )}/core_ext/*.rb"].sort.each do |path|
   require "y_support/core_ext/#{File.basename( path, '.rb' )}"
 end

data/lib/y_support/inert_recorder.rb

@@ -1,4 +1,4 @@
-#encoding: utf-8
+# encoding: utf-8
 
 require 'y_support'
 

data/lib/y_support/kde.rb

@@ -11,3 +11,4 @@ module YSupport::KDE
     end
   end
 end # module YSupport::KDE
+

data/lib/y_support/name_magic/array.rb

@@ -1,13 +1,14 @@
 # encoding: utf-8
 
 class Array
-  # Maps an array to an array of the element names, obtained by applying +#name+
-  # method to them. Takes one optional argument, which regulates its behavior
-  # regarding unnamed objects. If set to _nil_ (default) unnamed objects will
-  # be mapped to _nil_ (default behavior of the +#name+ method). If set to
-  # _true_, unnamed objects will be mapped to themselves. If set to _false_,
-  # unnamed object will not be mapped at all -- the returned array will contain
-  # only the names of the named objects.
+  # Maps an array of some objects into an array of their names, obtained by
+  # applying +#full_name+ method to them. Takes one optional argument, which
+  # regulates its behavior regarding unnamed objects. If set to _nil_ (default),
+  # unnamed
+  # objects will be mapped to _nil_ (default behavior of the +#name+ method).
+  # If set to _true_, unnamed objects will be mapped to themselves. If set to
+  # _false_, unnamed objects will not be mapped at all -- the returned array will
+  # contain only the names of the named objects.
   # 
   def names option=nil
     return map &:name if option.nil?                 # unnamed --> nil
@@ -15,4 +16,23 @@ class Array
     return map( &:name ).compact if option == false  # unnamed squeezed out
     fail ArgumentError, "Unknown option: #{option}"
   end
+  # FIXME: The remaining thing to do to achieve compatibility with Ruby's #name
+  # is to put "full_name" in the body, and "name" in the alias...
+  alias full_names names
+
+  # Maps an array to an array of the element names, obtained by applying
+  # +#_name_+ method to them. Takes one optional argument, which regulates its
+  # behavior regarding unnamed objects. If set to _nil_ (default) unnamed
+  # objects will be mapped to _nil_ (default behavior of +#_name_+ method). If
+  # set to _true_, unnamed objects will be mapped to themselves. If set to
+  # _false_, unnamed objects will not be mapped at all -- the returned array
+  # will contain only the names of the named objects.
+  # 
+  def _names_ option=nil
+    return map &:_name_ if option.nil?                 # unnamed --> nil
+    return map { |e| e.name || e } if option == true   # unnamed --> instance
+    return map( &:_name_ ).compact if option == false  # unnamed squeezed out
+    fail ArgumentError, "Unknown option: #{option}"
+  end
+  alias ɴs _names_
 end