facets-glimmer 3.2.0

data/lib/core/facets/enumerable/purge.rb

@@ -0,0 +1,43 @@
+module Enumerable
+
+  # A versitle compaction method. Like #map but used
+  # to filter out multiple items in a single step.
+  #
+  # Without +trash+ arguments +nil+ is assumed.
+  #
+  #   [1, nil, 2].purge  #=> [1,2]
+  #
+  # If +trash+ arguments are given, each argument is
+  # compared for a match using #==.
+  #
+  #   (1..6).purge(3,4)  #=> [1,2,5,6]
+  #
+  # If a block is given, the yield is used in the
+  # matching condition instead of the element itsef.
+  # 
+  #   (1..6).purge(0){ |n| n % 2 }  #=> [1,3,5]
+  #
+  # NOTE: This could just as well be an override of the
+  # core #compact method, but to avoid potential issues
+  # associated with overriding core methods we use the
+  # alternate name #purge.
+  #
+  # CREDIT: Trans
+
+  def purge(*trash, &block)
+    trash = [nil] if trash.empty?
+    r = []
+    if block_given?
+      each do |e|
+        y = yield(e)
+        r << e unless trash.any?{|t| t == y}
+      end
+    else
+      each do |e|
+        r << e unless trash.any?{|t| t == e}
+      end
+    end
+    r
+  end
+
+end

data/lib/core/facets/enumerable/recursively.rb

@@ -0,0 +1,66 @@
+module Enumerable
+
+  # Returns a recursive functor, that allows enumerable methods to iterate
+  # through enumerable sub-elements. By default it only recurses over
+  # elements of the same type.
+  #
+  def recursively(*types, &block)
+    Recursor.new(self, *types, &block)
+  end
+
+  # Recursor is a specialized Functor for recurively iterating over Enumerables.
+  #
+  # TODO: Return Enumerator if no +yld+ block is given.
+  #
+  # TODO: Add limiting +depth+ option to Enumerable#recursively?
+  #
+  class Recursor
+    instance_methods(true).each{ |m| private m unless /^(__|object_id$)/ =~ m.to_s }
+
+    def initialize(enum, *types, &block)
+      @enum   = enum
+      @types  = types.empty? ? [@enum.class] : types
+      @block  = block
+    end
+
+    def method_missing(op, &yld)
+      rec = @block || lambda{ |v| v }
+      yld = yld    || lambda{ |v| v }  # ? to_enum
+      @enum.__send__(op) do |v|
+        case v
+        when String # b/c of 1.8
+          yld.call(v)
+        when *@types
+          res = v.recursively(*@types, &@block).__send__(op,&yld)
+          rec.call(res)
+        else
+          yld.call(v)
+        end
+      end
+    end
+  end
+
+  ## TODO: When no longer needing to support 1.8.6 we could get rid of
+  ## the Recursor class and use:
+  ## #
+  ## def recursively(*types, &block)
+  ##   types = types.empty? ? [self.class] : types
+  ##   Functor.new do |op, &yld|
+  ##     rec = block || lambda{ |v| v }
+  ##     yld = yld   || lambda{ |v| v }  # ? to_enum
+  ##     __send__(op) do |v|
+  ##       case v
+  ##       when String # b/c of 1.8
+  ##         yld.call(v)
+  ##       when *types
+  ##         res = v.recursively(*types, &block).__send__(op,&yld)
+  ##         rec.call(res)
+  ##       else
+  ##         yld.call(v)
+  ##       end
+  ##     end
+  ##   end
+  ## end
+
+end
+

data/lib/core/facets/enumerable/squeeze.rb

@@ -0,0 +1,36 @@
+module Enumerable
+
+  # Squeeze out the same elements. This behaves like C++ unique(),
+  # removing equivalent elements that are concomitant to each other.
+  # To get a similar result with Array#uniq, the array would have to
+  # be sorted first.
+  #
+  # Calculation order is O(n).
+  #
+  # Examples
+  #
+  #   [1,2,2,3,3,2,1].squeeze #=> [1,2,3,2,1]
+  #   [1,2,2,3,3,2,1].sort.squeeze #=> [1,2,3]
+  #   [1,2,2,3,3,2,1].squeeze(*[3]) #=> [1,2,2,3,2,1]
+  #
+  # Returns [Array].
+  #
+  # CREDIT: T. Yamada
+
+  def squeeze(*limited_to)
+    first = true
+    r = []   # result
+    c = nil  # current
+    each do |e|
+      if !limited_to.empty? && !limited_to.include?(e)
+        r << e
+      elsif first || c != e
+        r << e
+        first = false
+        c = e
+      end
+    end
+    r
+  end
+
+end

data/lib/core/facets/enumerable/sum.rb

@@ -0,0 +1,40 @@
+module Enumerable
+
+  # Uses #+ to sum the enumerated elements.
+  #
+  #     [1,2,3].sum      #=> 6
+  #     [3,3,3].sum      #=> 9
+  #
+  # Note that Facets' sum method is completely generic -- it can work
+  # on any objects that respond to #+.
+  #
+  #     [[1],[2],[3]].sum   #=> [1,2,3]
+  #
+  # For this reason it is usually a good idea to provide a default
+  # value. Consider the difference between the two expressions below.
+  #
+  #     [].sum           #=> nil
+  #     [].sum(0)        #=> 0
+  #
+  # This default value also acts as an initial value.
+  #
+  #     [].sum(5)        #=> 5
+  #     [1,2,3].sum(10)  #=> 16
+  #
+  # A block can also be passed to coax the elements before summation.
+  # 
+  #     [1.1,2.2,3.3].sum(10.4, &:to_i)  #=> 16.4
+  #
+  # Notice the initial value is not effected by the block.
+  #
+  # @author Dawid Marcin Grzesiak
+
+  def sum(*identity, &block)
+    if block_given?
+      map(&block).sum(*identity)
+    else
+      reduce(*identity) { |sum, element| sum + element }
+    end
+  end
+
+end

data/lib/core/facets/enumerable/unassociate.rb

@@ -0,0 +1,23 @@
+module Enumerable
+
+  # Take an associative array and unassociate it.
+  #
+  #   [[:a,1], [:b,2]].unassociate.to_a     #=> [:a, [1], :b, [2]]
+  #   [[:a,1], [:b,2]].unassociate(1).to_a  #=> [:a, 1, :b, 2]
+  #
+  def unassociate(index = 1..-1)
+    return to_enum(:unassociate, index) unless block_given?
+
+    each do |v|
+      case v
+      when Array
+        yield v[0]
+        yield v[index]
+      else
+        yield v
+        yield nil
+      end
+    end
+  end
+
+end

data/lib/core/facets/enumerable/uniq_by.rb

@@ -0,0 +1,13 @@
+module Enumerable
+
+  # Like #uniq, but determines uniqueness based on a given block.
+  #
+  #   (-5..5).to_a.uniq_by {|i| i*i }
+  #   #=> [-5, -4, -3, -2, -1, 0]
+  #
+  def uniq_by #:yield:
+    h = {}; inject([]) {|a,x| h[yield(x)] ||= a << x}
+  end
+
+end
+

data/lib/core/facets/enumerable/value_by.rb

@@ -0,0 +1,25 @@
+module Enumerable
+  # Create a hash whose keys are the enumerable's elements, with specified
+  # values.
+  #
+  # If no block is given, the given parameter (default true) is used for
+  # all values, e.g.:
+  #
+  #     [1,2,3].value_by{ true }     #=> {1=>true, 2=>true, 3=>true}
+  #     [1,2,3].value_by{ "a" }      #=> {1=>"a", 2=>"a", 3=>"a"}
+  #
+  # If a block is given, each key's value is the result of running the
+  # block for that key, e.g.:
+  #
+  #     [1,2,3].value_by{ |n| "a"*n }  #=> {1=>"a", 2=>"aa", 3=>"aaa"}
+  #
+  # @author Ronen Barzel
+  #
+  def value_by
+    return to_enum(:value_by) unless block_given?
+
+    h = {}
+    each { |item| h[item] = yield(item) }
+    h
+  end
+end

data/lib/core/facets/enumerable/visit.rb

@@ -0,0 +1,30 @@
+module Enumerable
+
+  # Recursively iterate over all Enumerable elements, or
+  # subset given :type=>[type1, type2, ...].
+  #
+  #   [1, 2, 8..9].visit{ |x| x.succ }
+  #   # => [2, 3, [9, 10]]
+  #
+  def visit(opts={}, &block)
+    type = opts[:type] ? [opts[:type]].flatten : [Enumerable]
+    skip = opts[:skip]
+
+    map do |v|
+      case v
+      when String # b/c of 1.8
+        block.call(v)
+      when *type
+        v.visit(opts, &block)
+      else
+        if skip && Enumerable === v
+          v
+        else
+          block.call(v)
+        end
+      end
+    end
+  end
+
+end
+

data/lib/core/facets/enumerable/with_position.rb

@@ -0,0 +1,58 @@
+
+module Enumerable
+	class Position
+		def initialize
+			@first = true
+			@last = false
+		end
+		
+		def after_first!
+			@first = false
+		end
+		
+		def at_end!
+			@last = true
+		end
+		
+		def first?
+			@first
+		end
+		
+		def middle?
+			not (@first or @last)
+		end
+		
+		def last?
+			@last
+		end
+	end
+	
+	# Allows one to know the position of the enumeration easily.
+	#
+	#    5.times.collect.with_position do |i, position|
+	#        $stdout.write "#{i}#{position.middle? ? ',' : ''}"
+	#    end
+	#
+	# Where this becomes more useful, is when it's easy to determine the position of elements, e.g.
+	#
+	#    10.times.select(&:odd?).with_position{|n,p| ... }
+	#
+	def with_position
+		return to_enum(:with_position) unless block_given?
+		
+		position = Position.new
+		
+		while item = self.next
+			begin
+				self.peek
+			rescue StopIteration
+				position.at_end!
+			end
+			
+			yield item, position.dup
+			
+			position.after_first!
+		end
+	rescue StopIteration
+	end
+end

data/lib/core/facets/enumerable/zip_map.rb

@@ -0,0 +1 @@
+require 'facets/enumerable/map_with'

data/lib/core/facets/enumerable.rb

@@ -0,0 +1,40 @@
+require_relative 'enumerable/accumulate.rb'
+#require_relative 'enumerable/associate.rb'
+require_relative 'enumerable/cluster.rb'
+require_relative 'enumerable/collect_with_index.rb'
+require_relative 'enumerable/compact_map.rb'
+require_relative 'enumerable/defer.rb'
+require_relative 'enumerable/each_by.rb'
+require_relative 'enumerable/every.rb'
+require_relative 'enumerable/ewise.rb'
+require_relative 'enumerable/exclude.rb'
+require_relative 'enumerable/expand.rb'
+require_relative 'enumerable/filter.rb'
+require_relative 'enumerable/find_yield.rb'
+require_relative 'enumerable/frequency.rb'
+require_relative 'enumerable/graph.rb'
+#require_relative 'enumerable/hashify.rb'
+require_relative 'enumerable/incase.rb'
+require_relative 'enumerable/key_by'
+require_relative 'enumerable/map_by.rb'
+require_relative 'enumerable/map_detect.rb'
+require_relative 'enumerable/map_send.rb'
+require_relative 'enumerable/map_with.rb'
+require_relative 'enumerable/map_with_index.rb'
+require_relative 'enumerable/mash.rb'
+require_relative 'enumerable/modulate.rb'
+require_relative 'enumerable/occur.rb'
+require_relative 'enumerable/organize_by.rb'
+require_relative 'enumerable/only.rb'
+require_relative 'enumerable/pair.rb'
+require_relative 'enumerable/per.rb'
+require_relative 'enumerable/purge.rb'
+require_relative 'enumerable/recursively.rb'
+require_relative 'enumerable/squeeze.rb'
+require_relative 'enumerable/sum.rb'
+require_relative 'enumerable/value_by'
+#require_relative 'enumerable/unassociate.rb'
+require_relative 'enumerable/uniq_by.rb'
+require_relative 'enumerable/visit.rb'
+require_relative 'enumerable/zip_map.rb'
+

data/lib/core/facets/enumerator/fx.rb

@@ -0,0 +1,27 @@
+require 'facets/functor'
+
+class Enumerator
+
+  # TODO: Should Enumerator#fx be moved to functor gem?
+
+  #
+  def fx
+    Functor.new do |op, *a, &b|
+      map{ |e| e.send(op, *a, &b) }
+    end
+  end
+
+#  Old 1.8 version (left temporarily for reference)
+#
+#  def fx
+#    Functor.new(&method(:fx_send).to_proc)
+#  end
+#
+#  private
+#
+#  def fx_send(op, *a, &b)
+#    map{ |e| e.send(op, *a, &b) }
+#  end
+
+end
+

data/lib/core/facets/enumerator/lazy/squeeze.rb

@@ -0,0 +1,33 @@
+if defined?(Enumerator::Lazy)
+  class Enumerator
+    class Lazy
+
+      # Enumerator::Lazy version of Enumerable#squeeze.
+      # Note: you must use Ruby 2.0+ or require 'backports'.
+      # For now, you have to require 'facets/enumerator/lazy/squeeze' explicitly.
+      #
+      # Examples
+      #
+      #   [1,2,2,3,3,2,1].lazy.squeeze.to_a #=> [1,2,3,2,1]
+      #   [1,2,2,3,3,2,1].lazy.squeeze(*[3]).to_a #=> [1,2,2,3,2,1]
+      #
+      # Returns Enumerator::Lazy.
+      #
+      # CREDIT: T. Yamada
+
+      def squeeze(*limited_to)
+        first = true
+        cur = nil
+        self.class.new(self) do |y,v|
+          if !limited_to.empty? && !limited_to.include?(v)
+            y << v
+          elsif first || cur != v
+            y << v
+            first = false
+            cur = v
+          end
+        end
+      end
+    end
+  end
+end

data/lib/core/facets/enumerator.rb

@@ -0,0 +1,75 @@
+if RUBY_VERSION < '1.9'
+
+  require 'enumerator'
+
+  # for Ruby 1.8 -> 1.9 transition
+  Enumerator = Enumerable::Enumerator unless defined?(::Enumerator)
+
+  class Enumerator
+
+    private
+
+    alias :old_initialize :initialize
+
+    # Provides the ruby-1.9 block form of Enumerator, where you can write:
+    #
+    #    obj = Enumerator.new do |yielder|
+    #      # ...
+    #      yielder.yield(data)  # or: yielder << data
+    #      # ...
+    #    end
+    #
+    # When obj.each is called, the block is run once. It should call
+    # yielder.yield with each item it wishes to generate.
+    #
+    # Example:
+    #
+    #   fib = Enumerator.new { |y|
+    #     a = b = 1
+    #     loop {   
+    #       y << a
+    #       a, b = b, a + b
+    #     }
+    #   }  
+    #
+    #   fib.take(10)  #=> [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
+    #                                                 
+    def initialize(*args, &block)
+      if block
+        @body = block
+        old_initialize(self, :_start)
+      else
+        old_initialize(*args)
+      end
+    end
+
+    def _start(*args,&receiver) #:nodoc:
+      @body.call(Yielder.new(&receiver), *args)
+    end
+
+    # Wrapper to allow yielder.yield(output) or yielder << output
+    # in the same way as ruby-1.9
+    #
+    # TODO: Why can't Yielder take a block instead of a proc argument?
+
+    class Yielder #:nodoc:
+      def initialize(&proc)
+        @proc = proc
+      end
+      def yield(*args)
+        @proc[*args]
+      end
+      alias :<< :yield
+    end
+
+  end
+
+end
+
+path = __FILE__.chomp('.rb')
+base = File.basename(path)
+Dir[File.join(path, '*.rb')].each do |lib|
+  #require lib # why is this so much slower?
+  require "facets/#{base}/#{File.basename(lib)}"
+end
+

data/lib/core/facets/essentials.rb

@@ -0,0 +1,65 @@
+# As suggested by Roger Pack this file is a simple convenience
+# for loading a limited set of *essential* core extensions. By
+# *essential* we mean, more or less, the extensions we think
+# ought to be in Ruby proper anyway.
+#
+# NOTE: This is very much a work in progress! Please feel frre to 
+#   suggest which extensions you think belong here.
+
+require_relative 'functor'
+
+### Kernel
+require_relative 'kernel/blank'
+#require_relative 'kernel/deep_copy'
+#require_relative 'kernel/deep_dup'
+require_relative 'kernel/false'
+require_relative 'kernel/true'
+
+### Object
+require_relative 'object/itself'
+
+### Array
+require_relative 'array/delete_values'
+require_relative 'array/reject_values'
+require_relative 'array/uniq_by'
+
+### Binding
+require_relative 'binding/self'
+
+### Dir
+require_relative 'dir/ascend'
+require_relative 'dir/descend'
+require_relative 'dir/lookup'
+
+### Enumerable
+require_relative 'enumerable/cluster'
+require_relative 'enumerable/graph'
+require_relative 'enumerable/value_by'
+
+### File
+require_relative 'file/write'
+
+### Hash
+require_relative 'hash/autonew'
+require_relative 'hash/compact'
+#require_relative 'hash/data'
+require_relative 'hash/delete_values'
+require_relative 'hash/except'
+require_relative 'hash/rekey'
+require_relative 'hash/revalue'
+require_relative 'hash/slice'
+
+### Proc
+#require_relative 'proc/wrap'
+
+### Regexp
+#require_relative 'regexp/to_proc'
+
+### String
+require_relative 'string/indent'
+require_relative 'string/index_all'
+require_relative 'string/mscan'
+require_relative 'string/trim'
+require_relative 'string/unindent'
+#require_realtive 'string/word_wrap'
+

data/lib/core/facets/exception/detail.rb

@@ -0,0 +1,17 @@
+class Exception
+
+  # Pretty string output of exception/error object useful for helpful
+  # debug messages.
+  #
+  # @author George Moschovitis
+
+  def detail
+    if backtrace
+      %{#{self.class.name}: #{message}\n  #{backtrace.join("\n  ")}\n  LOGGED FROM: #{caller[0]}}
+    else
+      %{#{self.class.name}: #{message}\n  LOGGED FROM: #{caller[0]}}
+    end
+  end
+
+end
+

data/lib/core/facets/exception/error_print.rb

@@ -0,0 +1,80 @@
+class Exception
+
+  # Formats the Exception so that it looks *familiar*,
+  # i.e. exactly like your interpreter does it.
+  #
+  # Port of MRI native `error_print` function.
+  #
+  # @author Evgeniy Dolzhenko
+
+  def self.error_print(e)
+    warn_print = ""
+    backtrace = e.backtrace
+    backtrace = [ backtrace ] if backtrace.is_a?(String) # 1.9 returns single String for SystemStackError
+
+    warn_print << backtrace[0]
+    if e.is_a?(RuntimeError) && e.message.empty?
+      warn_print << ": unhandled exception\n"
+    else
+      if e.message.empty?
+        warn_print << ": #{ e.class.name }\n"
+      else
+        split_message = e.message.split("\n")
+        warn_print << ": "
+        if split_message.size == 1
+          warn_print << "#{ e.message } (#{ e.class.name })\n"
+        else
+          warn_print << split_message[0]
+          warn_print << " (#{ e.class.name })\n"
+          warn_print << split_message[1..-1].join("\n").chomp << "\n"
+        end
+      end
+    end
+
+    len = backtrace.size
+
+    ## int skip = eclass == rb_eSysStackError;
+    skip = e.is_a?(SystemStackError)
+
+    ## #define TRACE_MAX (TRACE_HEAD+TRACE_TAIL+5)
+    ## #define TRACE_HEAD 8
+    ## #define TRACE_TAIL 5
+    trace_head = 8
+    trace_tail = 5
+    trace_max = (trace_head + trace_tail + 5)
+    ##
+    ##	for (i = 1; i < len; i++) {
+    i = 1
+    while i < len
+      ##	    if (TYPE(ptr[i]) == T_STRING) {
+      ##		warn_printf("\tfrom %s\n", RSTRING_PTR(ptr[i]));
+      ##	    }
+      warn_print << "\tfrom %s\n" % e.backtrace[i]
+
+      ##	    if (skip && i == TRACE_HEAD && len > TRACE_MAX) {
+      if skip && i == trace_head && len > trace_max
+      ##		warn_printf("\t ... %ld levels...\n",
+      ##			    len - TRACE_HEAD - TRACE_TAIL);
+        warn_print << "\t ... %d levels...\n" % (len - trace_head - trace_tail)
+      ##		i = len - TRACE_TAIL;
+        i = len - trace_tail
+      ##	    }
+      end
+      ##	}
+      i += 1
+    end
+    warn_print
+  end
+
+  # Formats the Exception so that it looks *familiar*,
+  # i.e. exactly like your interpreter does it.
+  #
+  # @author Evgeniy Dolzhenko
+  #
+  # @todo Anyone have a better name for this method?
+  def error_print
+    Exception.error_print(self)
+  end
+
+end
+