IST - More Ruby Stuff

#==============================================================================#
# ** IST - More Ruby Stuff
#------------------------------------------------------------------------------#
# ** Created by    : IceDragon (http://www.rpgmakervx.net/)
# ** Version       : 1.8
# ** Date Modified : 08/26/2011
#------------------------------------------------------------------------------#
# Adds some new methods to Ruby's default classes
#==============================================================================#
# // Features
#==============================================================================#
# // Object
# //   deep_clone()
# //
# // Class
# //   ref_accessor( accessor, pointer )
# //   ref_reader( accessor, pointer )
# //   ref_writer( accessor, pointer )
# //   attr_boolean( accessors )
# //
# // Numeric
# //   time_inject( inject_obj ) { |inject_obj, i| do_stuff }
# //   nto_a( n )
# //   to_roman()
# //
# // Enumerable
# //   time_push( n ) { |obj, i| push_stuff }
# //   time_push!( n ) { |obj, i| push_stuff }
# //
# // Array
# //   rotate( n )
# //   rotate!( n )
# //   randomize()  or randomise()
# //   randomize!() or randomise!()
# //   any_match?( other_array )
# //   all_match?( other_array )
# //   count_match( other_array )
# //   return_if() { |element| boolean_expression }
# //   filter() { |element| boolean_expression }
# //   filter!() { |element| boolean_expression }
# //   build_from() { |element| pushable_object }
# //   build_from!() { |element| pushable_object }
# //   count() { |element| boolean_expression }
# //   get_nth( n ) { |element| boolean_expression }
# //   get_nth_index( n ) { |element| boolean_expression }
# //   add_all()
# //   average()
# //   average() { |element| addable_value }
# //   sync_sort( sync_array )
# //   sync_sort!( sync_array )
# //
#==============================================================================#
($imported ||= {})["IST_MoreRubyStuff"] = true
#==============================================================================#
# ** Object
#==============================================================================#
class Object

  #--------------------------------------------------------------------------#
  # * new-method :deep_clone
  #--------------------------------------------------------------------------#
  def deep_clone()
    return Marshal.load( Marshal.dump(self) )
  end unless method_defined? :deep_clone

end

#==============================================================================#
# ** Class
#==============================================================================#
class Class

  def stat_accessor(*accessors)
    accessors.each { |m|
      define_method(m) do
        instance_variable_get("@#{m}")
      end

      define_method("#{m}_limit") do
        instance_variable_get("@#{m}_limit")
      end

      define_method("#{m}=") do |val|
        instance_variable_set("@#{m}",val)
      end
    }
  end if false == true # // Yeah it never gonna happen
  #--------------------------------------------------------------------------#
  # * new-method :ref_accessor
  #--------------------------------------------------------------------------#
  def ref_accessor( accessor, ref )
    ref_reader accessor, ref
    ref_writer accessor, ref
  end unless method_defined? :ref_accessor

  #--------------------------------------------------------------------------#
  # * new-method :ref_reader
  #--------------------------------------------------------------------------#
  def ref_reader( accessor, ref )
    define_method(accessor) {
      self.send(ref)
    }
  end unless method_defined? :ref_reader

  #--------------------------------------------------------------------------#
  # * new-method :ref_writer
  #--------------------------------------------------------------------------#
  def ref_writer( accessor, ref )
    define_method("#{accessor}=") { |val|
      self.send("#{ref.to_s}=", val)
    }
  end unless method_defined? :ref_writer

  #--------------------------------------------------------------------------#
  # * new-method :attr_boolean
  #--------------------------------------------------------------------------#
  def attr_boolean( *accessors )
    accessors.each { |a|
      define_method(a.to_s+"?") {
        instance_variable_get("@#{a}") == true
      }
    }
  end

end

#==============================================================================#
# ** Numeric
#==============================================================================#
class Numeric

  # // ROMAN and to_roman by Zetu
  ROMAN = {
       1  => "I",
       5  => "V",
      10  => "X",
      50  => "L",
     100  => "C",
     500  => "D",
    1000  => "M",
    5000  => "",
   10000  => ""
  }

  #--------------------------------------------------------------------------#
  # * new-method :time_inject
  #--------------------------------------------------------------------------#
  def time_inject( obj )
    result = obj ; self.times { |i| result = yield obj, i } ; return result
  end unless method_defined? :time_inject

  #--------------------------------------------------------------------------#
  # * new-method :nto_a
  #--------------------------------------------------------------------------#
  def nto_a(n=0) ; ("%0#{n}d"%self).to_s.split(//).build_from { |s| s.to_i } ; end unless method_defined? :nto_a

  #--------------------------------------------------------------------------#
  # * new-method :to_roman
  #--------------------------------------------------------------------------#
  def to_roman()
    value = self
    if value < 4000
      base = ""
      for key in ROMAN.keys.sort.reverse
        a = value / key
        case a
        when 0; next
        when 1, 2, 3
          base += ROMAN[key]*a
        when 4
          base += ROMAN[key]
          base += ROMAN[key*5]
        when 5, 6, 7, 8
          base += ROMAN[key*5]
          base += ROMAN[key]*a-5
        when 9
          base += ROMAN[key*10]
          base += ROMAN[key]
        end
        value -= a * key
      end
      return base
    else
      return "---"
    end
  end unless method_defined? :to_roman
end

#==============================================================================#
# ** Enumerable
#==============================================================================#
module Enumerable

  #--------------------------------------------------------------------------#
  # * new-method :time_push
  #--------------------------------------------------------------------------#
  def time_push( n )
    n.time_inject( self ) { |obj, i| obj.push( (yield obj, i) ) }
  end unless method_defined? :time_push

  #--------------------------------------------------------------------------#
  # * new-method :time_push!
  #--------------------------------------------------------------------------#
  def time_push!( n, &block )
    self.concat( time_push( n, &block ) )
  end unless method_defined? :time_push!

end

#==============================================================================#
# ** Array
#==============================================================================#
class Array

  #--------------------------------------------------------------------------#
  # * new method :rotate
  #--------------------------------------------------------------------------#
  def rotate( n=1 ) ; dup.rotate!( n ) ; end unless method_defined? :rotate

  #--------------------------------------------------------------------------#
  # * new method :rotate!
  #--------------------------------------------------------------------------#
  def rotate!( n=1 )
    return self if empty?
    n %= size
    concat( slice!( 0, n ) )
  end unless method_defined? :rotate!

  #--------------------------------------------------------------------------#
  # * new method :randomize
  #--------------------------------------------------------------------------#
  def randomize()
    dup.randomize!()
  end unless method_defined? :randomize

  #--------------------------------------------------------------------------#
  # * new method :randomize!
  #--------------------------------------------------------------------------#
  def randomize!()
    return self if empty?()
    arra = sort_by { rand }
    self.clear() ; self.concat arra
  end unless method_defined? :randomize!

  #--------------------------------------------------------------------------#
  # * new method :randomise/! (for spelling)
  #--------------------------------------------------------------------------#
  def randomise() ; randomize  ; end
  def randomise!(); randomize! ; end

  #--------------------------------------------------------------------------#
  # * new method :any_match?
  #--------------------------------------------------------------------------#
  def any_match?( match_array )
    match_array.each { |e| return true if include?(e) } ; return false
  end unless method_defined? :any_match?

  #--------------------------------------------------------------------------#
  # * new method :all_match?
  #--------------------------------------------------------------------------#
  def all_match?( match_array )
    return true if self == match_array
    match_array.each { |e| return false unless include?(e) } ; return true
  end unless method_defined? :all_match?

  #--------------------------------------------------------------------------#
  # * new method :count_match
  #--------------------------------------------------------------------------#
  def count_match( match_array )
    return match_array.inject(0) { |result, e| result + 1 if include?(e) ; result }
  end unless method_defined? :count_match

  #--------------------------------------------------------------------------#
  # * new method :return_if
  #--------------------------------------------------------------------------#
  def return_if()
    each { |e| return e if yield e } ; return nil
  end unless method_defined? :return_if

  #--------------------------------------------------------------------------#
  # * new method :filter
  #--------------------------------------------------------------------------#
  def filter()
    return inject([]) { |result, e| result << e if yield e ; result }
  end unless method_defined? :filter

  #--------------------------------------------------------------------------#
  # * new method :filter!
  #--------------------------------------------------------------------------#
  def filter!( &block )
    result = filter( &block ) ; self.clear ; self.concat result
  end unless method_defined? :filter!

  #--------------------------------------------------------------------------#
  # * new method :build_from
  #--------------------------------------------------------------------------#
  def build_from()
    return inject([]) { |result, element| result.push(yield element) }
  end unless method_defined? :build_from

  #--------------------------------------------------------------------------#
  # * new method :build_from!
  #--------------------------------------------------------------------------#
  def build_from!( &block )
    bi = build_from( &block ) ; self.clear() ; self.concat(bi)
  end unless method_defined? :build_from!

  #--------------------------------------------------------------------------#
  # * new method :count
  #--------------------------------------------------------------------------#
  def count()
    return inject(0) { |result, element| result + 1 if yield e ; result }
  end unless method_defined? :count

  #--------------------------------------------------------------------------#
  # * new method :get_nth
  #--------------------------------------------------------------------------#
  def get_nth( n )
    inject(0) { |c, e| c + 1 if yield e ; return e if c == n ; c } ; return nil
  end unless method_defined? :get_nth

  #--------------------------------------------------------------------------#
  # * new method :get_nth_index
  #--------------------------------------------------------------------------#
  def get_nth_index( n )
    c = 0
    for i in 0...size
      e = self[i]
      c += 1 if yield e ; return i if c == n
    end
    return nil
  end unless method_defined? :get_nth_index

  #--------------------------------------------------------------------------#
  # * new method :add_all
  #--------------------------------------------------------------------------#
  def add_all()
    return inject(0) { |result, e| result + e }
  end unless method_defined? :add_all

  #--------------------------------------------------------------------------#
  # * new method :average
  #--------------------------------------------------------------------------#
  def average()
    if block_given?()
      return (self.inject(0) { |result, e| result + (yield e) }) / [size, 1].max
    else
      return add_all() / [size, 1].max
    end
  end unless method_defined? :average

  #--------------------------------------------------------------------------#
  # * new method :sync_sort
  #--------------------------------------------------------------------------#
  def sync_sort( sync_array )
    old_array = clone
    return self.sort.inject([]) { |r, e| r << sync_array[old_array.index(e)] }
  end unless method_defined? :sync_sort

  #--------------------------------------------------------------------------#
  # * new method :sync_sort!
  #--------------------------------------------------------------------------#
  def sync_sort!( sync_array )
    old_array = clone ; self.sort!
    res = inject([]) { |r, e| r << sync_array[old_array.index(e)] }
    sync_array.clear() ; sync_array.concat( res )
  end unless method_defined? :sync_sort!

end

#=*==========================================================================*=#
# ** END OF FILE
#=*==========================================================================*=#