spruz 0.1.0

data/lib/spruz/hash_union.rb

@@ -0,0 +1,8 @@
+module Spruz
+  module HashUnion
+    def |(other)
+      other = other.to_hash if other.respond_to?(:to_hash)
+      other.merge(self)
+    end
+  end
+end

data/lib/spruz/limited.rb

@@ -0,0 +1,36 @@
+require 'thread'
+
+module Spruz
+  class Limited
+    # Create a Limited instance, that runs _maximum_ threads at most.
+    def initialize(maximum)
+      @mutex =  Mutex.new
+      @continue = ConditionVariable.new
+      @maximum = Integer(maximum)
+      raise ArgumentError, "maximum < 1" if @maximum < 1
+      @count = 0
+    end
+
+    # The maximum number of worker threads.
+    attr_reader :maximum
+
+    # Execute _maximum_ number of threads in parallel.
+    def execute
+      @mutex.synchronize do
+        loop do
+          if @count < @maximum
+            @count += 1
+            Thread.new do
+              yield
+              @mutex.synchronize { @count -= 1 }
+              @continue.signal
+            end
+            return
+          else
+            @continue.wait(@mutex)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spruz/memoize.rb

@@ -0,0 +1,71 @@
+module Spruz
+  module Memoize
+    class ::Module
+      class << self
+        # Returns the current memoize cache for all the stored objects and
+        # method call results.
+        def __memoize_cache__
+          @__memoize_cache__ ||= {}
+        end
+
+        # Finalizer to delete the stored result for a garbage collected object.
+        def __memoize_cache_delete__
+          lambda do |id|
+            $DEBUG and warn "Deleted method results for object id='#{id}'"
+            __memoize_cache__.delete(id)
+          end
+        end
+      end
+
+      # Automatically memoize calls of the the methods +method_ids+. The
+      # memoized results do NOT ONLY depend on the arguments, but ALSO on the
+      # object the method is called on.
+      def memoize_method(*method_ids)
+        method_ids.each do |method_id|
+          orig_method = instance_method(method_id)
+          __send__(:define_method, method_id) do |*args|
+            unless mc = ::Module.__memoize_cache__[__id__]
+              mc = ::Module.__memoize_cache__[__id__] ||= {}
+              ObjectSpace.define_finalizer(self, ::Module.__memoize_cache_delete__)
+            end
+            if mc.key?(args)
+              result = mc[args]
+            else
+              result = mc[args] = orig_method.bind(self).call(*args)
+              if $DEBUG
+                warn "#{self.class} cached method #{method_id}(#{args.inspect unless args.empty?}) = #{result.inspect} [#{__id__}]"
+              end
+            end
+            result
+          end
+        end
+      end
+
+      # Returns the current memoize cache for this Module.
+      def __memoize_cache__
+        @__memoize_cache__
+      end
+
+      # Automatically memoize calls of the functions +function_ids+. The
+      # memoized result does ONLY depend on the arguments given to the
+      # function.
+      def memoize_function(*function_ids)
+        mc = @__memoize_cache__ ||= {}
+        function_ids.each do |method_id|
+          orig_method = instance_method(method_id)
+          __send__(:define_method, method_id) do |*args|
+            if mc.key?(args)
+              result = mc[args]
+            else
+              result = mc[args] = orig_method.bind(self).call(*args)
+              if $DEBUG
+                warn "#{self.class} cached function #{method_id}(#{args.inspect unless args.empty?}) = #{result.inspect}"
+              end
+            end
+            result
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spruz/minimize.rb

@@ -0,0 +1,53 @@
+module Spruz
+  # This module can be mixed into all classes, whose instances respond to the
+  # [] and size-methods, like for example Array. The returned elements from []
+  # should respond to the succ method.
+  module Minimize
+    # Returns a minimized version of this object, that is successive elements
+    # are substituted with ranges a..b. In the situation ..., x, y,... and y !=
+    # x.succ a range x..x is created, to make it easier to iterate over all the
+    # ranges in one run. A small example:
+    #  [ 'A', 'B', 'C', 'G', 'K', 'L', 'M' ].minimize # => [ 'A'..'C', 'G'..'G', 'K'..'M' ]
+    #
+    # If the order of the original elements doesn't matter, it's a good idea to
+    # first sort them and then minimize:
+    #  [ 5, 1, 4, 2 ].sort.minimize # => [ 1..2, 4..5 ]
+    def minimize
+      result = []
+      last_index = size - 1
+      size.times do |i|
+        result << [ self[0] ] if i == 0
+        if self[i].succ != self[i + 1] or i == last_index
+          result[-1] << self[i]
+          result << [ self[i + 1] ] unless i == last_index
+        end
+      end
+      result.map! { |a, b| a..b }
+    end
+
+    # First minimizes this object, then calls the replace method with the
+    # result.
+    def minimize!
+      replace minimize
+    end
+
+    # Invert a minimized version of an object. Some small examples:
+    #  [ 'A'..'C', 'G'..'G', 'K'..'M' ].unminimize # => [ 'A', 'B', 'C', 'G', 'K', 'L', 'M' ]
+    # and
+    #  [ 1..2, 4..5 ].unminimize # => [ 1, 2, 4, 5 ]
+    def unminimize
+      result = []
+      for range in self
+        for e in range
+          result << e
+        end
+      end
+      result
+    end
+
+    # Invert a minimized version of this object in place.
+    def unminimize!
+      replace unminimize
+    end
+  end
+end

data/lib/spruz/module_group.rb

@@ -0,0 +1,11 @@
+module Spruz
+  module ModuleGroup
+    def self.[](*modules)
+      modul = Module.new
+      modules.each do |m|
+        m.module_eval { include modul }
+      end
+      modul
+    end
+  end
+end

data/lib/spruz/null.rb

@@ -0,0 +1,20 @@
+module Spruz
+  # Implementation of the null object pattern in Ruby.
+  module Null
+    def method_missing(*)
+      self
+    end
+
+    def to_s
+      ''
+    end
+
+    def inspect
+      'NULL'
+    end
+  end
+
+  NULL = Class.new do
+    include Spruz::Null
+  end.new
+end

data/lib/spruz/once.rb

@@ -0,0 +1,23 @@
+module Spruz
+  module Once
+    include File::Constants
+
+    module_function
+
+    def only_once(lock_filename = nil, locking_constant = nil)
+      lock_filename ||= $0
+      locking_constant ||= LOCK_EX
+      f = File.new(lock_filename, RDONLY)
+      f.flock(locking_constant) and yield
+    ensure
+      if f
+        f.flock LOCK_UN
+        f.close
+      end
+    end
+
+    def try_only_once(lock_filename = nil, locking_constant = nil, &block)
+      only_once(lock_filename, locking_constant || LOCK_EX | LOCK_NB, &block)
+    end
+  end
+end

data/lib/spruz/p.rb

@@ -0,0 +1,21 @@
+require 'pp'
+
+module Spruz
+  module P
+    private
+
+    # Raise a runtime error with the inspected objects +objs+ (obtained by
+    # calling the #inspect method) as their message text. This is useful for
+    # quick debugging.
+    def p!(*objs)
+      raise((objs.size < 2 ? objs.first : objs).inspect)
+    end
+
+    # Raise a runtime error with the inspected objects +objs+ (obtained by
+    # calling the #pretty_inspect method) as their message text. This is useful
+    # for quick debugging.
+    def pp!(*objs)
+      raise("\n" + (objs.size < 2 ? objs.first : objs).pretty_inspect.chomp)
+    end
+  end
+end

data/lib/spruz/partial_application.rb

@@ -0,0 +1,29 @@
+module Spruz
+  module PartialApplication
+    # If this module is included into a Proc (or similar object), it tampers
+    # with its Proc#arity method.
+    def self.included(modul)
+      modul.module_eval do
+        old_arity = instance_method(:arity)
+        define_method(:arity) do
+          @__arity__ or old_arity.bind(self).call
+        end
+      end
+      super
+    end
+
+    # Create a partial application of this Proc (or similar object) using
+    # _args_ as the already applied arguments. 
+    def partial(*args)
+      if args.empty?
+        dup
+      elsif args.size > arity
+        raise ArgumentError, "wrong number of arguments (#{args.size} for #{arity})"
+      else
+        f = lambda { |*b| call(*(args + b)) }
+        f.instance_variable_set :@__arity__, arity - args.size
+        f
+      end
+    end
+  end
+end

data/lib/spruz/round.rb

@@ -0,0 +1,38 @@
+module Spruz
+  # A bit more versatile rounding for Ruby
+  module Round
+    def self.included(klass)
+      if klass.instance_method(:round)
+        klass.class_eval do
+          begin
+            remove_method :round
+          rescue NameError
+          end
+        end
+        super
+      else
+        raise NoMethodError, 'no round method found'
+      end
+    end
+
+    def round(places = 0)
+      unless Integer === places
+        raise TypeError, "argument places has to be an Integer"
+      end
+      if places < 0
+        max_places = -Math.log(self.abs + 1) / Math.log(10)
+        raise ArgumentError, "places has to be >= #{max_places.ceil}" if max_places > places 
+      end
+      t = self
+      f = 10.0 ** places
+      t *= f
+      if t >= 0.0
+        t = (t + 0.5).floor
+      elsif t < 0.0
+        t = (t - 0.5).ceil
+      end
+      t /= f
+      t.nan? ? self : t
+    end
+  end
+end

data/lib/spruz/shuffle.rb

@@ -0,0 +1,15 @@
+module Spruz
+  module Shuffle
+    def shuffle!
+      (size - 1) .downto(1) do |i|
+        j = rand(i + 1)
+        self[i], self[j] = self[j], self[i]
+      end
+      self
+    end
+
+    def shuffle
+      dup.shuffle!
+    end
+  end
+end

data/lib/spruz/subhash.rb

@@ -0,0 +1,37 @@
+module Spruz
+  module Subhash
+    # Create a subhash from this hash, that only contains key-value pairs
+    # matching +patterns+ and return it. +patterns+ can be for example /^foo/
+    # to put 'foobar' and 'foobaz' or 'foo'/:foo to put 'foo' into the subhash.
+    # 
+    # If a block is given this method yields to it after the first pattern
+    # matched with a 3-tuple of +(key, value, match_data)+ using the return
+    # value of the block as the value of the result hash. +match_data+ is a
+    # MatchData instance if the matching pattern was a regular rexpression
+    # otherwise it is nil.
+    def subhash(*patterns)
+      patterns.map! { |pat| pat.respond_to?(:match) ? pat : pat.to_s }
+      result =
+        if default_proc
+          self.class.new(&default_proc)
+        else 
+          self.class.new(default)
+        end
+      if block_given?
+        each do |k, v|
+          patterns.each { |pat|
+            if pat === k.to_s
+              result[k] = yield(k, v, $~)
+              break
+            end
+          }
+        end
+      else
+        each do |k, v|
+          result[k] = v if patterns.any? { |pat| pat === k.to_s }
+        end
+      end
+      result
+    end
+  end
+end

data/lib/spruz/time_dummy.rb

@@ -0,0 +1,29 @@
+module Spruz
+  module TimeDummy
+    def self.included(modul)
+      modul.module_eval do
+        class << self
+          alias really_new new
+        end
+
+        extend ClassMethods
+
+        class << self
+          alias now new
+        end
+      end
+    end
+
+    module ClassMethods
+      attr_accessor :dummy
+
+      def new
+        if dummy
+          dummy.dup
+        else
+          really_new
+        end
+      end
+    end
+  end
+end

data/lib/spruz/to_proc.rb

@@ -0,0 +1,9 @@
+module Spruz
+  module ToProc
+    def to_proc
+      lambda do |obj, *args|
+        obj.__send__(self, *args[0..-1])
+      end
+    end
+  end
+end

data/lib/spruz/uniq_by.rb

@@ -0,0 +1,8 @@
+module Spruz
+  module UniqBy
+    def uniq_by(&b)
+      b ||= lambda { |x| x }
+      inject({}) { |h, e| h[b[e]] ||= e; h }.values
+    end
+  end
+end

data/lib/spruz/version.rb

@@ -0,0 +1,8 @@
+module Spruz
+  # Spruz version
+  VERSION         = '0.1.0'
+  VERSION_ARRAY   = VERSION.split(/\./).map { |x| x.to_i } # :nodoc:
+  VERSION_MAJOR   = VERSION_ARRAY[0] # :nodoc:
+  VERSION_MINOR   = VERSION_ARRAY[1] # :nodoc:
+  VERSION_BUILD   = VERSION_ARRAY[2] # :nodoc:
+end