tins 0.3.0

data/lib/tins/range_plus.rb

@@ -0,0 +1,9 @@
+module Tins
+  module RangePlus
+    def +(other)
+      to_a + other.to_a
+    end
+  end
+end
+
+require 'tins/alias'

data/lib/tins/round.rb

@@ -0,0 +1,51 @@
+module Tins
+  # A bit more versatile rounding for Ruby
+  module Round
+    def self.included(klass)
+      if klass.instance_method(:round)
+        klass.class_eval do
+          begin
+            alias_method :__old_round__, :round
+            remove_method :round
+          rescue NameError
+          end
+        end
+        super
+      else
+        raise NoMethodError, 'no round method found'
+      end
+    end
+
+    def round(places = nil)
+      if places == nil || places == 0
+        return __old_round__
+      elsif places.respond_to?(:to_int)
+        places = places.to_int
+      else
+        raise TypeError, "argument places has to be like 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.infinite?
+        result = self
+      else
+        if t >= 0.0
+          t = (t + 0.5).floor
+        elsif t < 0.0
+          t = (t - 0.5).ceil
+        end
+        t /= f
+        result = t.nan? ? self : t
+      end
+      max_places and result = result.to_i # if places < 0
+      result
+    end
+  end
+end
+
+require 'tins/alias'

data/lib/tins/secure_write.rb

@@ -0,0 +1,25 @@
+module Tins
+  module SecureWrite
+    # Write to a file atomically
+    def secure_write(filename, content = nil, mode = 'w')
+      temp = File.new(filename + ".tmp.#$$.#{Time.now.to_f}", mode)
+      if content.nil? and block_given?
+        yield temp
+      elsif !content.nil?
+        temp.write content
+      else
+        raise ArgumentError, "either content or block argument required"
+      end
+      temp.fsync
+      size = temp.stat.size
+      temp.close
+      File.rename temp.path, filename
+      size
+    ensure
+      temp and !temp.closed? and temp.close
+      File.file?(temp.path) and File.unlink temp.path
+    end
+  end
+end
+
+require 'tins/alias'

data/lib/tins/shuffle.rb

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

data/lib/tins/string_camelize.rb

@@ -0,0 +1,16 @@
+module Tins
+  module StringCamelize
+    def camelize(first_letter = :upper)
+      case first_letter
+      when :upper, true
+        gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+      when :lower, false
+        self[0].chr.downcase + camelize[1..-1]
+      end
+    end
+
+    alias camelcase camelize
+  end
+end
+
+require 'tins/alias'

data/lib/tins/string_underscore.rb

@@ -0,0 +1,15 @@
+module Tins
+  module StringUnderscore
+    def underscore
+      word = dup
+      word.gsub!(/::/, '/')
+      word.gsub!(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+      word.tr!("-", "_")
+      word.downcase!
+      word
+    end
+  end
+end
+
+require 'tins/alias'

data/lib/tins/string_version.rb

@@ -0,0 +1,105 @@
+require 'tins/xt/symbol_to_proc'
+
+module Tins
+  module StringVersion
+    class Version
+      include Comparable
+
+      def initialize(string)
+        string =~ /\A[\.\d]+\Z/ or raise ArgumentError, "#{string.inspect} isn't a version number"
+        @version = string.frozen? ? string.dup : string
+      end
+
+      def major
+        self[0]
+      end
+
+      def major=(number)
+        self[0] = number
+      end
+
+      def minor
+        self[1]
+      end
+
+      def minor=(number)
+        self[1] = number
+      end
+
+      def build
+        self[2]
+      end
+
+      def build=(number)
+        self[2] = number
+      end
+
+      def revision
+        self[3]
+      end
+
+      def revision=(number)
+        self[3] = number
+      end
+
+      def [](index)
+        array[index]
+      end
+
+      def []=(index, value)
+        value = value.to_i
+        value >= 0 or raise ArgumentError, "version numbers can't contain negative numbers like #{value}"
+        a = array
+        @array = nil
+        a[index] = value
+        a.map! { |x| x.nil? ? 0 : x }
+        @version.replace a * '.'
+      end
+
+      def succ!
+        self[-1] += 1
+      end
+
+      def pred!
+        self[-1] -= 1
+      end
+
+      def <=>(other)
+        pairs = array.zip(other.array)
+        pairs.map! { |a, b| [ a.nil? ? 0 : a, b.nil? ? 0 : b ] }
+        a, b = pairs.transpose
+        a <=> b
+      end
+
+      def ==(other)
+        (self <=> other).zero?
+      end
+
+      def array
+         @version.split('.').map(&:to_i)
+      end
+
+      alias to_a array
+
+      def to_s
+        @version
+      end
+
+      alias inspect to_s
+
+      def version
+        self
+      end
+    end
+
+    def version
+      if frozen?
+        Version.new(self)
+      else
+        @version ||= Version.new(self)
+      end
+    end
+  end
+end
+
+require 'tins/alias'

data/lib/tins/subhash.rb

@@ -0,0 +1,42 @@
+module Tins
+  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! do |pat|
+        pat = pat.to_sym.to_s if pat.respond_to?(:to_sym)
+        pat.respond_to?(:match) ? pat : pat.to_s
+      end
+      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
+
+require 'tins/alias'

data/lib/tins/time_dummy.rb

@@ -0,0 +1,31 @@
+module Tins
+  module TimeDummy
+    def self.included(modul)
+      modul.module_eval do
+        class << self
+          alias really_new new
+          remove_method :now rescue nil
+          remove_method :new rescue nil
+        end
+
+        extend ClassMethods
+      end
+    end
+
+    module ClassMethods
+      attr_accessor :dummy
+
+      def new
+        if dummy
+          dummy.dup
+        else
+          really_new
+        end
+      end
+
+      alias now new
+    end
+  end
+end
+
+require 'tins/alias'

data/lib/tins/to_proc.rb

@@ -0,0 +1,11 @@
+module Tins
+  module ToProc
+    def to_proc
+      lambda do |obj, *args|
+        obj.__send__(self, *args[0..-1])
+      end
+    end
+  end
+end
+
+require 'tins/alias'

data/lib/tins/uniq_by.rb

@@ -0,0 +1,10 @@
+module Tins
+  module UniqBy
+    def uniq_by(&b)
+      b ||= lambda { |x| x }
+      inject({}) { |h, e| h[b[e]] ||= e; h }.values
+    end
+  end
+end
+
+require 'tins/alias'

data/lib/tins/version.rb

@@ -0,0 +1,10 @@
+module Tins
+  # Tins version
+  VERSION         = '0.3.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
+
+require 'tins/alias'

data/lib/tins/write.rb

@@ -0,0 +1,19 @@
+require 'tins/secure_write'
+
+module Tins
+  module Write
+    def self.extended(modul)
+      modul.extend SecureWrite
+      if modul.respond_to?(:write)
+        $DEBUG and warn "Skipping inclusion of Tins::Write#write method, include Tins::Write::SecureWrite#secure_write instead"
+      else
+        class << modul; self; end.instance_eval do
+          alias_method :write, :secure_write
+        end
+      end
+      super
+    end
+  end
+end
+
+require 'tins/alias'

data/lib/tins/xt.rb

@@ -0,0 +1,25 @@
+require 'tins'
+
+module Tins
+  require 'tins/xt/blank'
+  require 'tins/xt/count_by'
+  require 'tins/xt/full'
+  require 'tins/xt/hash_union'
+  require 'tins/xt/irb'
+  require 'tins/xt/null'
+  require 'tins/xt/round'
+  require 'tins/xt/subhash'
+  require 'tins/xt/time_dummy'
+  require 'tins/xt/uniq_by'
+  require 'tins/xt/p'
+  require 'tins/xt/symbol_to_proc'
+  require 'tins/xt/write'
+  require 'tins/xt/secure_write'
+  require 'tins/xt/deep_dup'
+  require 'tins/xt/attempt'
+  require 'tins/xt/hash_symbolize_keys_recursive'
+  require 'tins/xt/range_plus'
+  require 'tins/xt/named'
+  require 'tins/xt/string'
+  require 'tins/xt/file_binary'
+end

data/lib/tins/xt/attempt.rb

@@ -0,0 +1,7 @@
+require 'tins/attempt'
+
+module Tins
+  class ::Object
+    include Tins::Attempt
+  end
+end

data/lib/tins/xt/blank.rb

@@ -0,0 +1,67 @@
+module Tins
+  module Blank
+    module Object
+      def blank?
+        respond_to?(:empty?) ? empty? : !self
+      end
+
+      def present?
+        !blank?
+      end
+    end
+
+    module NilClass
+      def blank?
+        true
+      end
+    end
+
+    module FalseClass
+      def blank?
+        true
+      end
+    end
+
+    module TrueClass
+      def blank?
+        false
+      end
+    end
+
+    module Array
+      def self.included(modul)
+        modul.module_eval do
+          alias_method :blank?, :empty?
+        end
+      end
+    end
+
+    module Hash
+      def self.included(modul)
+        modul.module_eval do
+          alias_method :blank?, :empty?
+        end
+      end
+    end
+
+    module String
+      def blank?
+        self !~ /\S/
+      end
+    end
+
+    module Numeric
+      def blank?
+        false
+      end
+    end
+  end
+
+  unless Object.respond_to?(:blank?)
+    for k in Blank.constants
+      Object.const_get(k).class_eval do
+        include Blank.const_get(k)
+      end
+    end
+  end
+end