tins 0.3.0

data/.gitignore

@@ -0,0 +1,4 @@
+.*.sw[pon]
+.rvmrc
+Gemfile.lock
+pkg

data/.travis.yml

@@ -0,0 +1,7 @@
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - ruby-head
+  - ree
+  - rbx
+  - jruby

data/Gemfile

@@ -0,0 +1,5 @@
+# vim: set filetype=ruby et sw=2 ts=2:
+
+source :rubygems
+
+gemspec

data/LICENSE

@@ -0,0 +1,18 @@
+Copyright (c) 2010 Florian Frank
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE X
+CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,20 @@
+= Tins - Useful tools library in Ruby
+
+== Description
+
+Non yet.
+
+== Download
+
+The homepage of this library is located at
+
+* http://flori.github.com/tins
+
+== Author
+
+Florian Frank mailto:flori@ping.de
+
+== License
+
+This software is licensed under the X11 (or MIT) license:
+http://www.xfree86.org/3.3.6/COPYRIGHT2.html#3

data/Rakefile

@@ -0,0 +1,28 @@
+# vim: set filetype=ruby et sw=2 ts=2:
+
+require 'gem_hadar'
+
+GemHadar do
+  name        'tins'
+  author      'Florian Frank'
+  email       'flori@ping.de'
+  homepage    "http://flori.github.com/#{name}"
+  summary     'Useful stuff.'
+  description 'All the stuff that isn\'t good/big enough for a real library.'
+  test_dir    'tests'
+  ignore      '.*.sw[pon]', 'pkg', 'Gemfile.lock', '.rvmrc'
+  readme      'README.rdoc'
+  development_dependency 'test-unit', '~>2.3'
+
+  install_library do
+    libdir = CONFIG["sitelibdir"]
+    cd 'lib' do
+      for file in Dir['**/*.rb']
+        dst = File.join(libdir, file)
+        mkdir_p File.dirname(dst)
+        install file, dst
+      end
+    end
+    install 'bin/enum', File.join(CONFIG['bindir'], 'enum')
+  end
+end

data/TODO

@@ -0,0 +1 @@
+- Ruby1.9 has File.write method now, that conflicts with Tins::Write module's and has to be fixed in some way

data/VERSION

@@ -0,0 +1 @@
+0.3.0

data/lib/spruz.rb

@@ -0,0 +1 @@
+require 'tins/alias'

data/lib/tins.rb

@@ -0,0 +1,34 @@
+module Tins
+  require 'tins/attempt'
+  require 'tins/bijection'
+  require 'tins/count_by'
+  require 'tins/deep_dup'
+  require 'tins/file_binary'
+  require 'tins/generator'
+  require 'tins/go'
+  require 'tins/hash_symbolize_keys_recursive'
+  require 'tins/hash_union'
+  require 'tins/limited'
+  require 'tins/lines_file'
+  require 'tins/memoize'
+  require 'tins/minimize'
+  require 'tins/module_group'
+  require 'tins/null'
+  require 'tins/once'
+  require 'tins/p'
+  require 'tins/partial_application'
+  require 'tins/range_plus'
+  require 'tins/round'
+  require 'tins/secure_write'
+  require 'tins/shuffle'
+  require 'tins/string_camelize'
+  require 'tins/string_underscore'
+  require 'tins/string_version'
+  require 'tins/subhash'
+  require 'tins/time_dummy'
+  require 'tins/to_proc'
+  require 'tins/uniq_by'
+  require 'tins/version'
+  require 'tins/write'
+end
+require 'tins/alias'

data/lib/tins/alias.rb

@@ -0,0 +1 @@
+Spruz = Tins

data/lib/tins/attempt.rb

@@ -0,0 +1,51 @@
+module Tins
+  module Attempt
+    def attempt(opts = {}, &block)
+      sleep           = nil
+      exception_class = StandardError
+      if Numeric === opts
+        attempts = opts
+      else
+        attempts        = opts[:attempts] || 1
+        exception_class = opts[:exception_class] if opts.key?(:exception_class)
+        sleep           = opts[:sleep]
+      end
+      return if attempts <= 0
+      count = 0
+      if exception_class.nil?
+        begin
+          count += 1
+          if block.call(count)
+            return true
+          elsif count < attempts
+            sleep_duration(sleep, count)
+          end
+        end until count == attempts
+        false
+      else
+        begin
+          count += 1
+          block.call(count)
+          true
+        rescue exception_class
+          if count < attempts
+            sleep_duration(sleep, count)
+            retry
+          end
+          false
+        end
+      end
+    end
+
+    private
+
+    def sleep_duration(duration, count)
+      case duration
+      when Numeric
+        sleep duration
+      when Proc
+        sleep duration.call(count)
+      end
+    end
+  end
+end

data/lib/tins/bijection.rb

@@ -0,0 +1,46 @@
+module Tins
+  class Bijection < Hash
+    def self.[](*pairs)
+      pairs.size % 2 == 0 or
+        raise ArgumentError, "odd number of arguments for #{self}"
+      new.fill do |obj|
+        (pairs.size / 2).times do |i|
+          j = 2 * i
+          key = pairs[j]
+          value = pairs[j + 1]
+          obj.key?(key) and raise ArgumentError, "duplicate key #{key.inspect} for #{self}"
+          obj.inverted.key?(value) and raise ArgumentError, "duplicate value #{value.inspect} for #{self}"
+          obj[pairs[j]] = pairs[j + 1]
+        end
+      end
+    end
+
+    def initialize(inverted = Bijection.new(self))
+      @inverted = inverted
+    end
+
+    def fill
+      if empty?
+        yield self
+        freeze
+      end
+      self
+    end
+
+    def freeze
+      r = super
+      unless @inverted.frozen?
+        @inverted.freeze
+      end
+      r
+    end
+
+    def []=(key, value)
+      key?(key) and return
+      super
+      @inverted[value] = key
+    end
+
+    attr_reader :inverted
+  end
+end

data/lib/tins/count_by.rb

@@ -0,0 +1,8 @@
+module Tins
+  module CountBy
+    def count_by(&b)
+      b ||= lambda { |x| true }
+      inject(0) { |s, e| s += 1 if b[e]; s }
+    end
+  end
+end

data/lib/tins/deep_dup.rb

@@ -0,0 +1,11 @@
+module Tins
+  module DeepDup
+    def deep_dup
+      Marshal.load(Marshal.dump(self))
+    rescue TypeError
+      return self
+    end
+  end
+end
+
+require 'tins/alias'

data/lib/tins/file_binary.rb

@@ -0,0 +1,85 @@
+require 'tins/xt/hash_union'
+
+module Tins
+  module FileBinary
+    module Constants
+      SEEK_SET = ::File::SEEK_SET
+
+      ZERO   = "\x00"
+      BINARY = "\x01-\x1f\x7f-\xff"
+
+      if defined?(::Encoding)
+        ZERO.force_encoding(Encoding::ASCII_8BIT)
+        BINARY.force_encoding(Encoding::ASCII_8BIT)
+      end
+    end
+
+    class << self
+      # Default options can be queried/set via this hash.
+      attr_accessor :default_options
+    end
+    self.default_options = {
+      :offset            => 0,
+      :buffer_size       => 2 ** 13,
+      :percentage_binary => 30.0,
+      :percentage_zeros  => 0.0,
+    }
+
+    # Returns true if this file is considered to be binary, false if it is not
+    # considered to be binary, and nil if it was empty.
+    #
+    # A file is considered to be binary if the percentage of zeros exceeds
+    # <tt>options[:percentage_zeros]</tt> or the percentage of binary bytes
+    # (8-th bit is 1) exceeds <tt>options[:percentage_binary]</tt> in the
+    # buffer of size <tt>options[:buffer_size]</tt> that is checked (beginning
+    # from offset <tt>options[:offset]</tt>). If an option isn't given the one
+    # from FileBinary.default_options is used instead.
+    def binary?(options = {})
+      options |= FileBinary.default_options
+      old_pos = tell
+      seek options[:offset], Constants::SEEK_SET
+      data = read options[:buffer_size]
+      !data or data.empty? and return nil
+      data_size = data.size
+      data.count(Constants::ZERO).to_f / data_size >
+        options[:percentage_zeros] / 100.0 and return true
+      data.count(Constants::BINARY).to_f / data_size >
+        options[:percentage_binary] / 100.0
+    ensure
+      old_pos and seek old_pos, Constants::SEEK_SET
+    end
+
+    # Returns true if FileBinary#binary? returns false, false if
+    # FileBinary#binary? returns true, and nil otherwise. For an explanation of
+    # +options+, see FileBinary#binary?.
+    def ascii?(options = {})
+      case binary?(options)
+      when true   then false
+      when false  then true
+      end
+    end
+
+    def self.included(modul)
+      modul.instance_eval do
+        extend ClassMethods
+      end
+      super
+    end
+
+    module ClassMethods
+      # Returns true if the file with name +name+ is considered to be binary
+      # using the FileBinary#binary? method.
+      def binary?(name, options = {})
+        open(name, 'rb') { |f| f.binary?(options) }
+      end
+
+      # Returns true if the file with name +name+ is considered to be ascii
+      # using the FileBinary#ascii? method.
+      def ascii?(name, options = {})
+        open(name, 'rb') { |f| f.ascii?(options) }
+      end
+    end
+  end
+end
+
+require 'tins/alias'

data/lib/tins/generator.rb

@@ -0,0 +1,68 @@
+module Tins
+  # This class can create generator objects, that can produce all tuples, that
+  # would be created by as many for-loops as dimensions were given.
+  #
+  # The generator
+  #  g = Tins::Generator[1..2, %w[a b c]]
+  # produces
+  #  g.to_a # => [[1, "a"], [1, "b"], [1, "c"], [2, "a"], [2, "b"], [2, "c"]]
+  #
+  # The 'each' method can be used to iterate over the tuples
+  #  g.each { |a, b| puts "#{a} #{b}" }
+  # and Tins::Generator includes the Enumerable module, so
+  # Enumerable.instance_methods can be used as well:
+  #  g.select { |a, b| %w[a c].include? b  } # => [[1, "a"], [1, "c"], [2, "a"], [2, "c"]]
+  #
+  class Generator
+    include Enumerable
+
+    # Create a new Generator object from the enumberables _enums_.
+    def self.[](*enums)
+      new(enums)
+    end
+
+    # Create a new Generator instance. Use the objects in the Array _enums_
+    # as dimensions. The should all respond to the :each method (see module
+    # Enumerable in the core ruby library).
+    def initialize(enums)
+      @enums, @iterators, @n = [], [], 0
+      enums.each { |e| add_dimension(e) }
+    end
+
+    # Iterate over all tuples produced by this generator and yield to them.
+    def each(&block) # :yield: tuple
+      recurse(&block)
+      self
+    end
+
+    def recurse(tuple = [ nil ] * @n, i = 0, &block)
+      if i < @n - 1 then
+        @enums[i].__send__(@iterators[i]) do |x|
+          tuple[i] = x
+          recurse(tuple, i + 1, &block)
+        end
+      else
+        @enums[i].__send__(@iterators[i]) do |x|
+          tuple[i] = x
+          yield tuple.dup
+        end
+      end
+    end
+    private :recurse
+
+    # Add another dimension to this generator. _enum_ is an object, that ought
+    # to respond to the _iterator_ method (defaults to :each).
+    def add_dimension(enum, iterator = :each)
+      @enums << enum
+      @iterators << iterator
+      @n += 1
+    end
+
+    # Return the size of this generator, that is the number of its dimensions.
+    def size
+      @enums.size
+    end
+  end
+end
+
+require 'tins/alias'

data/lib/tins/go.rb

@@ -0,0 +1,43 @@
+module Tins
+  module GO
+    module_function
+
+    # Parses the argument array _args_, according to the pattern _s_, to
+    # retrieve the single character command line options from it. If _s_ is
+    # 'xy:' an option '-x' without an option argument is searched, and an
+    # option '-y foo' with an option argument ('foo').
+    #
+    # An option hash is returned with all found options set to true or the
+    # found option argument.
+    def go(s, args = ARGV)
+      b,v = s.scan(/(.)(:?)/).inject([{},{}]) { |t,(o,a)|
+        a = a == ':'
+        t[a ? 1 : 0][o] = a ? nil : false
+        t
+      }
+      while a = args.shift
+        a !~ /\A-(.+)/ and args.unshift a and break
+        p = $1
+        until p == ''
+          o = p.slice!(0, 1)
+          if v.key?(o)
+            if p == '' then
+              v[o] = args.shift or break 1
+            else
+              v[0] = p
+            end
+            break
+          elsif b.key?(o)
+            b[o] = true
+          else
+            args.unshift a
+            break 1
+          end
+        end and break
+      end
+      b.merge(v)
+    end
+  end
+end
+
+require 'tins/alias'