#--
# Version
#
# GPL Copyright (c) 2004-2005 Thomas Sawyer <transfire at gmail.com>
# GPL Copyright (c) 2000-2001 Minero Aoki <aamine at loveruby.net>
#
# This program is free software.
# You can distribute/modify this program under the terms of
# the GNU Lesser General Public License version 2 or later.
#
# ==========================================================================
#  Revision History
# ==========================================================================
#  2004.09.17  trans    Adapted to Mega.
# ==========================================================================
#++

#:title: Version
#
# A class for manipulating and storing conventional version numbers
# in the form of "1.0.0", i.e. major, minor, teeny.
#
# == Usage
#
#   VERSION = Version["1.2.3"]  # same as Version.new()
#
#   VERSION.major               #=> 1
#   VERSION.minor               #=> 2
#   VERSION.teeny               #=> 3
#
#   VERSION.teeny += 1          #=> 4
#
#   VERSION > Version(1,2,3)    #=> true
#   VERSION > Version("1.2.4")  #=> false
#
# == Author(s)
#
# * Minero Aoki (originator)
# * Thomas Sawyer
#

class Version
  include Comparable

  VERSION_EXP = /\d+(?:[.-]\d+)*/

  def self.[](*args)
    Version.new(*args)
  end

  def initialize( arg, *nums )
    set( arg, *nums )
  end

  def set( arg, *nums )
    if String === arg then
      unless m = VERSION_EXP.match( arg ) then
        raise ArgumentError, "wrong version string format '#{arg}'"
      end
      @num = m[0].split('.').collect {|i| i.to_i }
    else
      @num = [ arg, *(nums || []) ]
      #@num.unshift arg
    end
  end

  def dup
    self.class.new( *@nums )
  end

  def ==( other )
    @num == other.to_a
  end
  alias_method( :eql?, :== )

  def hash ; @num.hash ; end

  def to_s ; @num.join '.' ; end
  def to_a ; @num.dup ; end

  def inspect
    "\#<#{self.class} #{to_s}>"
  end

  def major       ; @num[0]     ; end
  def major=( i ) ; @num[0] = i ; end

  def minor       ; @num[1]     ; end
  def minor=( i ) ; @num[1] = i ; end

  def teeny       ; @num[2]     ; end
  def teeny=( i ) ; @num[2] = i ; end

  def weeny       ; @num[3]     ; end
  def weeny=( i ) ; @num[3] = i ; end

  def next_major!    
    (1..last_index).each{ |i| @num[i] = 0 } if last_index > 0
    @num[0] += 1
  end

  def next_minor!
    (2..last_index).each{ |i| @num[i] = 0 } if last_index > 1
    if @num[1]
      @num[1] += 1
    end
  end

  def next_teeny!
    (3..last_index).each{ |i| @num[i] = 0 } if last_index > 2
    if @num[2]
      @num[2] += 1
    end
  end

  def next_weeny!
    #(4..last_index).each{ |i| @num[i] = 0 } if last_index > 3
    if @num[3]
      @num[3] += 1
    end
  end

  def type
    case last_index
    when 0 then :major
    when 1 then :minor
    when 2 then :teeny
    when 3 then :weeny
    end
  end

  def <=>( other )
    return false unless self.class === other
    n = @num
    ret = nil; other.instance_eval { ret = (n <=> @num) }
    ret
  end

  private

  def last_index
    @num.length - 1
  end

end


#  _____         _
# |_   _|__  ___| |_
#   | |/ _ \/ __| __|
#   | |  __/\__ \ |_
#   |_|\___||___/\__|
#

=begin testing

require 'test/unit'

class TC_Version < Test::Unit::TestCase

  def setup
    @version0 = Version["1.2"]
    @version1 = Version["1.2.3"]
    @version2 = Version[1,2,4]
    @version3 = Version["10.3.5"]
  end

  def test_major
    assert_equal( 1, @version1.major )
    assert_equal( 1, @version2.major )
    assert_equal( 10, @version3.major )
  end

  def test_minor
    assert_equal( 2, @version1.minor ) 
    assert_equal( 2, @version2.minor ) 
    assert_equal( 3, @version3.minor ) 
  end

  def test_teeny
    assert_equal( 3, @version1.teeny )
    assert_equal( 4, @version2.teeny ) 
    assert_equal( 5, @version3.teeny ) 
  end

  def test_major_eq
    @version1.major = 2
    assert_equal( 2, @version1.major )
    @version2.major = 3
    assert_equal( 3, @version2.major )
    @version3.major = 9
    assert_equal( 9, @version3.major )
  end

  def test_minor_eq
    @version1.minor = 5
    assert_equal( 5, @version1.minor ) 
    @version2.minor = 5
    assert_equal( 5, @version2.minor ) 
    @version3.minor = 5
    assert_equal( 5, @version3.minor ) 
  end

  def test_teeny_eq
    @version1.teeny = 6
    assert_equal( 6, @version1.teeny ) 
    @version2.teeny = 6
    assert_equal( 6, @version2.teeny )
    @version3.teeny = 6
    assert_equal( 6, @version3.teeny ) 
  end

  def test_compare
    assert( @version1 < @version2 )
    assert( @version2 < @version3 )
    assert( @version3 > @version1 )
    assert( @version3 > @version2 )
  end

  def test_equal
    assert_equal( Version["1.2.3"], @version1 )
  end

  def test_next!
    @version1.next_teeny!
    assert_equal( Version[1,2,4], @version1 )
    @version1.next_minor!
    assert_equal( Version[1,3,0], @version1 )
    @version1.next_major!
    assert_equal( Version[2,0,0], @version1 )
  end

  def test_to_a
    assert_equal( [1,2,3], @version1.to_a )
    assert_equal( [1,2,4], @version2.to_a )
  end

  def test_to_s
    assert_equal( "1.2.3", @version1.to_s )
    assert_equal( "1.2.4", @version2.to_s )
  end

end

=end