tins 0.3.0

data/lib/tins/hash_symbolize_keys_recursive.rb

@@ -0,0 +1,28 @@
+module Tins
+  module HashSymbolizeKeysRecursive
+    def symbolize_keys_recursive
+      inject(self.class.new) do |h,(k, v)|
+        k = k.to_s
+        k.empty? and next
+        case v
+        when Hash
+          h[k.to_sym] = v.symbolize_keys_recursive
+        when Array
+          h[k.to_sym] = a = v.dup
+          v.each_with_index do |x, i|
+            Hash === x and a[i] = x.symbolize_keys_recursive
+          end
+        else
+          h[k.to_sym] = v
+        end
+        h
+      end
+    end
+
+    def symbolize_keys_recursive!
+      replace symbolize_keys_recursive
+    end
+  end
+end
+
+require 'tins/alias'

data/lib/tins/hash_union.rb

@@ -0,0 +1,15 @@
+module Tins
+  module HashUnion
+    def |(other)
+      case
+      when other.respond_to?(:to_hash)
+        other = other.to_hash
+      when other.respond_to?(:to_h)
+        other = other.to_h
+      end
+      other.merge(self)
+    end
+  end
+end
+
+require 'tins/alias'

data/lib/tins/limited.rb

@@ -0,0 +1,38 @@
+require 'thread'
+
+module Tins
+  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
+
+require 'tins/alias'

data/lib/tins/lines_file.rb

@@ -0,0 +1,123 @@
+module Tins
+  class LinesFile
+    module LineExtension
+      attr_reader :line_number
+
+      def filename
+        lines_file.filename.dup
+      end
+    end
+
+    def self.for_filename(filename, line_number = nil)
+      obj = new(File.readlines(filename), line_number)
+      obj.filename = filename
+      obj
+    end
+
+    def self.for_file(file, line_number = nil)
+      obj = new(file.readlines, line_number)
+      obj.filename = file.path
+      obj
+    end
+
+    def self.for_lines(lines, line_number = nil)
+      new(lines, line_number)
+    end
+
+    def initialize(lines, line_number = nil)
+      @lines = lines
+      @lines.each_with_index do |line, i|
+        line.extend LineExtension
+        line.instance_variable_set :@line_number, i + 1
+        line.instance_variable_set :@lines_file, self
+      end
+      instance_variable_set :@line_number, line_number || (@lines.empty? ? 0 : 1)
+    end
+
+    attr_accessor :filename
+
+    attr_reader :line_number
+
+    def rewind
+      self.line_number = 1
+      self
+    end
+
+    def next!
+      old = line_number
+      self.line_number += 1
+      line_number > old ? self : nil
+    end
+
+    def previous!
+      old = line_number
+      self.line_number -= 1
+      line_number < old ? self : nil
+    end
+
+    def line_number=(number)
+      number = number.to_i
+      if number > 0 && number <= last_line_number
+        @line_number = number
+      end
+    end
+
+    def last_line_number
+      @lines.size
+    end
+
+    def empty?
+      @lines.empty?
+    end
+
+    def each(&block)
+      empty? and return self
+      old_line_number = line_number
+      1.upto(last_line_number) do |number|
+        self.line_number = number
+        block.call(line)
+      end
+      self
+    ensure
+      self.line_number = old_line_number
+    end
+    include Enumerable
+
+    def line
+      index = line_number - 1
+      @lines[index] if index >= 0
+    end
+
+    def file_linenumber
+      "#{filename}:#{line_number}"
+    end
+
+    def match_backward(regexp, previous_after_match = false)
+      begin
+        if line =~ regexp
+          previous_after_match and previous!
+          return $~.captures
+        end
+      end while previous!
+    end
+
+    def match_forward(regexp, next_after_match = false)
+      begin
+        if line =~ regexp
+          next_after_match and next!
+          return $~.captures
+        end
+      end while next!
+    end
+
+    def to_s
+      "#{line_number} #{line.chomp}"
+    end
+
+    def inspect
+      "#<#{self.class}: #{to_s.inspect}>"
+    end
+  end
+end
+
+require 'tins/alias'

data/lib/tins/memoize.rb

@@ -0,0 +1,78 @@
+module Tins
+  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|
+          method_id = method_id.to_s.to_sym
+          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?(method_id) and result = mc[method_id][args]
+              result
+            else
+              (mc[method_id] ||= {})[args] = result = orig_method.bind(self).call(*args)
+              $DEBUG and warn "#{self.class} cached method #{method_id}(#{args.inspect unless args.empty?}) = #{result.inspect} [#{__id__}]"
+            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|
+          method_id = method_id.to_s.to_sym
+          orig_method = instance_method(method_id)
+          __send__(:define_method, method_id) do |*args|
+            if mc.key?(method_id) and result = mc[method_id][args]
+              result
+            else
+              (mc[method_id] ||= {})[args] = result = orig_method.bind(self).call(*args)
+              $DEBUG and warn "#{self.class} cached function #{method_id}(#{args.inspect unless args.empty?}) = #{result.inspect}"
+            end
+            result
+          end
+        end
+      end
+
+      # Clear cached values for all methods and functions.
+      def memoize_cache_clear
+        mc = @__memoize_cache__ and mc.clear
+        mc = ::Module.__memoize_cache__ and mc.clear
+        self
+      end
+    end
+  end
+end
+
+require 'tins/alias'

data/lib/tins/minimize.rb

@@ -0,0 +1,55 @@
+module Tins
+  # 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
+
+require 'tins/alias'

data/lib/tins/module_group.rb

@@ -0,0 +1,13 @@
+module Tins
+  module ModuleGroup
+    def self.[](*modules)
+      modul = Module.new
+      modules.each do |m|
+        m.module_eval { include modul }
+      end
+      modul
+    end
+  end
+end
+
+require 'tins/alias'

data/lib/tins/null.rb

@@ -0,0 +1,26 @@
+module Tins
+  # Implementation of the null object pattern in Ruby.
+  module Null
+    def method_missing(*)
+      self
+    end
+
+    def const_missing(*)
+      self
+    end
+
+    def to_s
+      ''
+    end
+
+    def inspect
+      'NULL'
+    end
+  end
+
+  NULL = Class.new do
+    include Tins::Null
+  end.new
+end
+
+require 'tins/alias'

data/lib/tins/once.rb

@@ -0,0 +1,25 @@
+module Tins
+  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
+
+require 'tins/alias'

data/lib/tins/p.rb

@@ -0,0 +1,23 @@
+require 'pp'
+
+module Tins
+  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
+
+require 'tins/alias'

data/lib/tins/partial_application.rb

@@ -0,0 +1,31 @@
+module Tins
+  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
+
+require 'tins/alias'