mug 0.5.3 → 0.5.4

data/lib/mug/clamp.rb

@@ -1,46 +1,46 @@
 
 class Numeric
 
-	#
-	# Clamps num so that lower <= new_num <= higher.
-	#
-	# Returns lower when num < lower, higher when num > higher, otherwise
-	# num itself.
-	#
-	# Raises an exception if lower > higher
-	#
-	def clamp lower, higher=nil
-		return lower.bound(self) if lower.is_a?(Range) && higher.nil?
-		raise ArgumentError, 'range must not be negative' if lower > higher
-		[[lower, self].max, higher].min
-	end
+  #
+  # Clamps num so that lower <= new_num <= higher.
+  #
+  # Returns lower when num < lower, higher when num > higher, otherwise
+  # num itself.
+  #
+  # Raises an exception if lower > higher
+  #
+  def clamp lower, higher=nil
+    return lower.bound(self) if lower.is_a?(Range) && higher.nil?
+    raise ArgumentError, 'range must not be negative' if lower > higher
+    [[lower, self].max, higher].min
+  end
 
 end
 
 class Range
 
-	#
-	# Bounds val so that first <= new_val <= last.
-	#
-	# Returns first when val < first, last when val > last, otherwise
-	# val itself.
-	#
-	# Raises an exception if val >= end and the range is exclusive.
-	#
-	def bound val
-		a = first
-		return a if val < a
-
-		b = last
-		if val >= b
-			if exclude_end?
-				raise ArgumentError, 'more than or equal to the exclusive range'
-			end
-			return b
-		end
-
-		val
-	end
+  #
+  # Bounds val so that first <= new_val <= last.
+  #
+  # Returns first when val < first, last when val > last, otherwise
+  # val itself.
+  #
+  # Raises an exception if val >= end and the range is exclusive.
+  #
+  def bound val
+    a = first
+    return a if val < a
+
+    b = last
+    if val >= b
+      if exclude_end?
+        raise ArgumentError, 'more than or equal to the exclusive range'
+      end
+      return b
+    end
+
+    val
+  end
 
 end
 

data/lib/mug/counts.rb

@@ -1,34 +1,34 @@
 
 module Enumerable
 
-	#
-	# Returns a hash of item=>count showing how many
-	# of each +item+ are in this Enumerable.
-	#
-	def counts &block
-		return counts_by(&block) if block_given?
-		hsh = Hash.new{|h,k| h[k] = 0 }
-		each do |k|
-			hsh[k] += 1
-		end
-		hsh
-	end
+  #
+  # Returns a hash of item=>count showing how many
+  # of each +item+ are in this Enumerable.
+  #
+  def counts &block
+    return counts_by(&block) if block_given?
+    hsh = Hash.new{|h,k| h[k] = 0 }
+    each do |k|
+      hsh[k] += 1
+    end
+    hsh
+  end
 
-	#
-	# Passes each element in turn to the block, and returns a
-	# hash of result=>count.
-	#
-	# If no block is given, an enumerator is returned.
-	#
-	def counts_by &block
-		return enum_for(:counts_by) unless block_given?
-		hsh = Hash.new{|h,k| h[k] = 0 }
-		each do |j|
-			k = yield j
-			hsh[k] += 1
-		end
-		hsh
-	end
+  #
+  # Passes each element in turn to the block, and returns a
+  # hash of result=>count.
+  #
+  # If no block is given, an enumerator is returned.
+  #
+  def counts_by &block
+    return enum_for(:counts_by) unless block_given?
+    hsh = Hash.new{|h,k| h[k] = 0 }
+    each do |j|
+      k = yield j
+      hsh[k] += 1
+    end
+    hsh
+  end
 
 end
 

data/lib/mug/fragile-method-chain.rb

@@ -8,55 +8,55 @@
 #     nested_hash._?[:a][:b][:c]._!
 #
 class FragileMethodChain
-	#
-	# Creates a FragileMethodChain which will send its first method to +o+
-	#
-	def initialize o, falsy: true
-		@o = o
-		@falsy = falsy
-	end
+  #
+  # Creates a FragileMethodChain which will send its first method to +o+
+  #
+  def initialize o, falsy: true
+    @o = o
+    @falsy = falsy
+  end
 
-	#
-	# Finalises the FragileMethodChain.
-	#
-	# The final result will be the first +nil+ or +false+ value
-	# returned in the chain, or its end result.
-	#
-	def _!
-		@o
-	end
+  #
+  # Finalises the FragileMethodChain.
+  #
+  # The final result will be the first +nil+ or +false+ value
+  # returned in the chain, or its end result.
+  #
+  def _!
+    @o
+  end
 
-	# Delegate the method args/block
-	def method_missing *a, &b #:nodoc:
-		if __defer?
-			@o = @o.__send__(*a, &b)
-		end
-		self
-	end
+  # Delegate the method args/block
+  def method_missing *a, &b #:nodoc:
+    if __defer?
+      @o = @o.__send__(*a, &b)
+    end
+    self
+  end
 
-	# Explicitly invoke :_? as a method in the chain.
-	def _? #:nodoc:
-		# Unconditionally invoke it, so the eventual _! doesn't fail
-		#if __defer?
-			@o = @o.__send__(:_?)
-		#end
-		self
-	end
+  # Explicitly invoke :_? as a method in the chain.
+  def _? #:nodoc:
+    # Unconditionally invoke it, so the eventual _! doesn't fail
+    #if __defer?
+      @o = @o.__send__(:_?)
+    #end
+    self
+  end
 
-	# Return true iff @o is deferable.
-	def __defer?
-		return @o if @falsy
-		! @o.nil?
-	end
+  # Return true iff @o is deferable.
+  def __defer?
+    return @o if @falsy
+    ! @o.nil?
+  end
 end
 
 class Object
-	#
-	# Begins a FragileMethodChain.
-	#
-	def _?
-		FragileMethodChain.new(self)
-	end
+  #
+  # Begins a FragileMethodChain.
+  #
+  def _?
+    FragileMethodChain.new(self)
+  end
 end
 
 =begin

data/lib/mug/hash/map.rb

@@ -1,85 +1,85 @@
 
 class Hash
-	#
-	# Returns a new hash which is a copy of the current hash but each
-	# value is replaced by the result of running it through +block+.
-	#
-	#   {'a'=>1, 'b'=>2}.map_values { |v| v*2 } #=> {'a'=>2, 'b'=>4}
-	#   {'a'=>1, 'b'=>2}.map_values { "cat" }   #=> {'a'=>"cat", 'b'=>"cat"}
-	#
-	def map_values &block # :yields: value
-		hsh = {}
-		each do |k, v|
-			hsh[k] = yield v
-		end
-		hsh
-	end
+  #
+  # Returns a new hash which is a copy of the current hash but each
+  # value is replaced by the result of running it through +block+.
+  #
+  #   {'a'=>1, 'b'=>2}.map_values { |v| v*2 } #=> {'a'=>2, 'b'=>4}
+  #   {'a'=>1, 'b'=>2}.map_values { "cat" }   #=> {'a'=>"cat", 'b'=>"cat"}
+  #
+  def map_values &block # :yields: value
+    hsh = {}
+    each do |k, v|
+      hsh[k] = yield v
+    end
+    hsh
+  end
 
-	#
-	# Replaces the values in +hsh+ by running them each through +block+.
-	#
-	# See: #map_values
-	#
-	def map_values! &block # :yields: value
-		replace map_values(&block)
-	end
+  #
+  # Replaces the values in +hsh+ by running them each through +block+.
+  #
+  # See: #map_values
+  #
+  def map_values! &block # :yields: value
+    replace map_values(&block)
+  end
 
-	#
-	# Returns a new hash which is a copy of the current hash but each
-	# key is replaced by the result of running it through +block+.
-	#
-	# If +block+ returns duplicate keys, they will be overwritten in
-	# the resulting hash.
-	#
-	#   {'a'=>1, 'b'=>2}.map_keys { |k| k*2 } #=> {'aa'=>1, 'bb'=>2}
-	#   {'a'=>1, 'b'=>2}.map_keys { "cat" }   #=> {'cat'=>2}
-	#
-	def map_keys &block # :yields: key
-		hsh = {}
-		each do |k, v|
-			hsh[ yield k ] = v
-		end
-		hsh
-	end
+  #
+  # Returns a new hash which is a copy of the current hash but each
+  # key is replaced by the result of running it through +block+.
+  #
+  # If +block+ returns duplicate keys, they will be overwritten in
+  # the resulting hash.
+  #
+  #   {'a'=>1, 'b'=>2}.map_keys { |k| k*2 } #=> {'aa'=>1, 'bb'=>2}
+  #   {'a'=>1, 'b'=>2}.map_keys { "cat" }   #=> {'cat'=>2}
+  #
+  def map_keys &block # :yields: key
+    hsh = {}
+    each do |k, v|
+      hsh[ yield k ] = v
+    end
+    hsh
+  end
 
-	#
-	# Replaces the keys in +hsh+ by running them each through +block+.
-	#
-	# If +block+ returns duplicate keys, they will be overwritten in turn.
-	#
-	# See: #map_keys
-	#
-	def map_keys! &block # :yields: key
-		replace map_keys(&block)
-	end
+  #
+  # Replaces the keys in +hsh+ by running them each through +block+.
+  #
+  # If +block+ returns duplicate keys, they will be overwritten in turn.
+  #
+  # See: #map_keys
+  #
+  def map_keys! &block # :yields: key
+    replace map_keys(&block)
+  end
 
-	#
-	# Returns a new hash which is a copy of the current hash but each
-	# key-value pair is replaced by the result of running it through +block+.
-	#
-	# If +block+ returns duplicate keys, they will be overwritten in
-	# the resulting hash.
-	#
-	#   {'a'=>1, 'b'=>2}.map_pairs { |k,v| [k*2, v+1] } #=> {'aa'=>2, 'bb'=>3}
-	#   {'a'=>1, 'b'=>2}.map_pairs { ["cat","dog"] }   #=> {'cat'=>'dog'}
-	#
-	def map_pairs &block # :yields: key, value
-		hsh = {}
-		each do |k, v|
-			a, b = yield k, v
-			hsh[a] = b
-		end
-		hsh
-	end
+  #
+  # Returns a new hash which is a copy of the current hash but each
+  # key-value pair is replaced by the result of running it through +block+.
+  #
+  # If +block+ returns duplicate keys, they will be overwritten in
+  # the resulting hash.
+  #
+  #   {'a'=>1, 'b'=>2}.map_pairs { |k,v| [k*2, v+1] } #=> {'aa'=>2, 'bb'=>3}
+  #   {'a'=>1, 'b'=>2}.map_pairs { ["cat","dog"] }   #=> {'cat'=>'dog'}
+  #
+  def map_pairs &block # :yields: key, value
+    hsh = {}
+    each do |k, v|
+      a, b = yield k, v
+      hsh[a] = b
+    end
+    hsh
+  end
 
-	#
-	# Replaces the values in +hsh+ by running them each through +block+.
-	#
-	# See: #map_values
-	#
-	def map_pairs! &block # :yields: key, value
-		replace map_pairs(&block)
-	end
+  #
+  # Replaces the values in +hsh+ by running them each through +block+.
+  #
+  # See: #map_values
+  #
+  def map_pairs! &block # :yields: key, value
+    replace map_pairs(&block)
+  end
 end
 
 =begin

data/lib/mug/hash/operations.rb

@@ -1,54 +1,54 @@
 
 class Hash
 
-	#
-	# Returns a new Hash, whose value is the same as this
-	# one, with any extras in +other_hash+ added in.
-	#
-	# Useful for default options.
-	#
-	# Example:
-	#     opts = {:a => 1, :b => 2 }
-	#     dflt = {:a => 0, :x => 9 }
-	#     opts |= dflt # => opts = {:a=>1, :b=>2, :x=>9}
-	#
-	def | other_hash
-		other_hash.merge self
-	end
+  #
+  # Returns a new Hash, whose value is the same as this
+  # one, with any extras in +other_hash+ added in.
+  #
+  # Useful for default options.
+  #
+  # Example:
+  #     opts = {:a => 1, :b => 2 }
+  #     dflt = {:a => 0, :x => 9 }
+  #     opts |= dflt # => opts = {:a=>1, :b=>2, :x=>9}
+  #
+  def | other_hash
+    other_hash.merge self
+  end
 
-	#
-	# Adds the contents of +other_hash+ to +hsh+.
-	# Entries with duplicate keys are overwritten with the
-	# values from +other_hash+
-	#
-	def + other_hash
-		merge other_hash
-	end
+  #
+  # Adds the contents of +other_hash+ to +hsh+.
+  # Entries with duplicate keys are overwritten with the
+  # values from +other_hash+
+  #
+  def + other_hash
+    merge other_hash
+  end
 
-	#
-	# Appends stuff to the hash.
-	#
-	# If +o+ is a Hash, this is identical to calling #merge!
-	# If +o+ is an Array with two elements, it is interpreted as [key,value]
-	# If +o+ can be converted to a hash with #to_h, this is identical to calling #merge!
-	# Otherwise an ArgumentError is raised.
-	#
-	# Example:
-	#     h = {}
-	#     h << {:a=>0}       # h = {:a=>0}
-	#     h << {:b=>2,:c=>3} # h = {:a=>0,:b=>2,:c=>3}
-	#     h << [:a,1]        # h = {:a=>1,:b=>2,:c=>3}
-	#
-	def << o
-		if o.respond_to? :to_hash
-			merge! o.to_hash
-		elsif o.respond_to?(:to_a) && (a = o.to_a) && a.length == 2
-			tap { store a[0], a[1] }
-		elsif o.respond_to? :to_h
-			merge! o.to_h
-		else
-			raise ArgumentError, "#{o.class.name} is not a Hash"
-		end
-	end
+  #
+  # Appends stuff to the hash.
+  #
+  # If +o+ is a Hash, this is identical to calling #merge!
+  # If +o+ is an Array with two elements, it is interpreted as [key,value]
+  # If +o+ can be converted to a hash with #to_h, this is identical to calling #merge!
+  # Otherwise an ArgumentError is raised.
+  #
+  # Example:
+  #     h = {}
+  #     h << {:a=>0}       # h = {:a=>0}
+  #     h << {:b=>2,:c=>3} # h = {:a=>0,:b=>2,:c=>3}
+  #     h << [:a,1]        # h = {:a=>1,:b=>2,:c=>3}
+  #
+  def << o
+    if o.respond_to? :to_hash
+      merge! o.to_hash
+    elsif o.respond_to?(:to_a) && (a = o.to_a) && a.length == 2
+      tap { store a[0], a[1] }
+    elsif o.respond_to? :to_h
+      merge! o.to_h
+    else
+      raise ArgumentError, "#{o.class.name} is not a Hash"
+    end
+  end
 end