core_ex 0.4.0 → 0.5.1.1

data/lib/version.rb

@@ -1,127 +1,367 @@
 # Copyright:: Copyright (c) 2004  Nicolas Despres. All rights reserved.
 # Author::    Nicolas Despres  <polrop@lrde.epita.fr>.
 # License::   Gnu General Public License.
-# Revision::  $Id: version.rb 334 2005-09-04 14:29:40Z ertai $
+# Revision::  $Id: /w/fey/ruby_ex/trunk/core_ex/lib/version.rb 22190 2006-02-23T17:21:00.661381Z pouillar  $
 
 
 class Version
+  yaml_as 'tag:feydakins.org,2006:version'
   include Comparable
 
-  attr_accessor :major, :minor, :build, :revision
+  attr_accessor :major, :minor, :tag, :category, :name, :release_name
+  # protected :major=, :minor=, :tag=,
+  #           :category=, :name=, :release_name=
 
-  def initialize(major, minor, build, revision)
-    @major = major
-    @minor = minor
-    @build = build
-    @revision = revision
+  def initialize ( major, minor, tag=nil, tag_offset=nil,
+                   category=nil, name=nil, release_name=nil )
+    @major    = major
+    @minor    = minor
+    @tag      = Tag[tag || :off, tag_offset || 0]
+    if @tag.offset.zero?
+      case @tag.name
+      when :p then raise ArgumentError, 'The patch level tag (p) needs an offset'
+      when :r then raise ArgumentError, 'The revision tag (r) needs an offset'
+      end
+    end
+    @category = category || ''
+    @name     = name || ''
+    @release_name = release_name || ''
   end
 
-  def <=>(other)
-    if @major == other.major
-      if @minor == other.minor
-        if @build == other.build
-          @revision <=> other.revision
-        else
-          @build <=> other.build
-        end
-      else
-        @minor <=> other.minor
-      end
-    else
-      @major <=> other.major
+  def self.parse ( str )
+    re_cat_name = /([\w-]+\/)?([\w-]+)/
+    re_tag = /_(r|alpha|beta|pre|rc|off|p)(\d*)/
+    unless str =~ /^(#{re_cat_name}-)?([\d.]+)(#{re_tag})?(#.*)?$/
+      raise ArgumentError, "Cannot parse your version: #{str}"
     end
+    category, name, head, _, tag, offset, release_name = Regexp.last_match[2..8]
+    parts = head.split('.').map { |x| x.to_i }
+    raise ArgumentError, "Too many parts: #{head}" if parts.size > 2
+    major, minor = parts
+
+    # Remove now useless chars (/, #)
+    category[-1]    = '' if category
+    release_name[0] = '' if release_name
+
+    tag = (tag.nil?)? :off : tag.to_sym
+    new(major || 0, minor || 0, tag, offset.to_i,
+        category || '', name || '', release_name || '')
   end
 
-  def pp
-    "#{to_s} (Revision: #@revision)"
+  def self.yaml_new( klass, tag, val )
+    parse val
+  end
+
+  def <=>(other)
+    category_cmp = @category <=> other.category
+    return category_cmp unless category_cmp.zero?
+
+    name_cmp = @name <=> other.name
+    return name_cmp unless name_cmp.zero?
+
+    major_cmp = @major <=> other.major
+    return major_cmp unless major_cmp.zero?
+    
+    minor_cmp = @minor <=> other.minor
+    return minor_cmp unless minor_cmp.zero?
+    
+    @tag <=> other.tag
+  end
+
+  def official?
+    @tag.name == :off
+  end
+
+  def major_minor
+    "#@major.#@minor"
+  end
+
+  def tag_string
+    (official?)? '' : "_#{@tag.name}#{(@tag.offset.zero?)? '' : @tag.offset}"
+  end
+
+  def category_and_name
+    (@name.empty?)? '' : ((@category.empty?)? "#@name-" : "#@category/#@name-")
   end
 
   def to_s
-    "#@major.#@minor.#@build"
+    s = category_and_name + major_minor + tag_string
+    s << '#' << @release_name unless @release_name.empty?
+    s
+  end
+
+  def short_string
+    s = ''
+    s << @name << '-' unless @name.empty?
+    s << major_minor << tag_string
   end
 
   def inspect
-    "#@major.#@minor.#@build-r#@revision"
+    "#<Version: #{to_s}>"
+  end
+
+  def to_rubygems_version_string
+    to_positive_integers.join '.'
+  end
+
+  def to_yaml ( opts={} )
+    YAML::quick_emit nil, opts do |out|
+      out.scalar taguri, to_s, :plain
+    end
+  end
+
+  def pp
+    more = ''
+    more << " #@release_name" unless @release_name.empty?
+    "#{@tag.pp}: #{major_minor}#{more}"
   end
 
   def to_a
-    [ @major, @minor, @build, @revision ]
+    [ @major, @minor, @tag.name, @tag.offset ]
+  end
+
+  def to_positive_integers
+    [@major, @minor, @tag.rank + 5, @tag.offset]
   end
 
   def major_release
-    @major += 1
-    @minor = 0
-    @build = 0
-    @revision += 1
-    self
+    release do |r|
+      r.major += 1
+      r.minor = 0
+      r.tag = Tag[:alpha, 0]
+    end
   end
 
   def minor_release
-    @minor += 1
-    @build = 0
-    @revision += 1
-    self
+    release do |r|
+      r.minor += 1
+      r.tag = Tag[:alpha, 0]
+    end
   end
 
-  def build_release
-    @build += 1
-    @revision += 1
-    self
+  def new_tag_release ( new_tag )
+    release do |r|
+      r.tag = Tag[new_tag, (new_tag == :p)? 1 : 0]
+    end
   end
+  private :new_tag_release
 
-end # class Version
+  def incr_tag_release
+    raise ArgumentError, "Impossible it's an official release" if official?
+    release do |r|
+      r.tag.offset += 1
+    end
+  end
+  private :incr_tag_release
 
+  def tag_release ( tag )
+    return incr_tag_release if @tag.name == tag
 
-test_section __FILE__ do
+    dest = new_tag_release tag
+    off = new_tag_release :off
+    if self < dest and dest <= off
+      dest
+    elsif off <= self and self < dest
+      dest
+    elsif self < off and off < dest
+      raise ArgumentError,
+        "You need to be at least on an official release (not #{self}) to go on #{dest}"
+    elsif dest < self
+      raise ArgumentError, "You cannot downgrade (#{self} to #{dest})"
+    else
+      raise ArgumentError, "Unhandled case: self=#{self}, dest=#{dest}, off=#{off}"
+    end
+  end
+
+  def patch_level_release
+    tag_release :p
+  end
+
+  def official_release
+    tag_release :off
+  end
 
+  def release_candidate
+    tag_release :rc
+  end
+
+  def pre_release
+    tag_release :pre
+  end
+
+  def beta_release
+    tag_release :beta
+  end
+
+  def alpha_release
+    tag_release :alpha
+  end
+
+  def release ( &block )
+    x = dup
+    x.instance_eval { block[self] }
+    x
+  end
+
+  class Tag
+    attr_accessor :name, :descr, :rank, :offset
+
+    def initialize ( name, descr, rank, offset )
+      @name, @descr, @rank, @offset = name, descr, rank, offset
+    end
+    
+    def pp
+      (offset.zero?)? descr : "#{descr} ##{offset}"
+    end
+
+    def <=> ( other )
+      cmp = @rank <=> other.rank
+      return cmp unless cmp.zero?
+      @offset <=> other.offset
+    end
+
+    class << self
+      @@tags = {}
+      def [] ( name, offset )
+        f = @@tags[name]
+        raise ArgumentError, "Unknown tag ``#{name}''" if f.nil?
+        f[offset]
+      end
+      def tag ( name, descr, rank )
+        @@tags[name] = lambda { |offset| Tag.new(name, descr, rank, offset) } 
+      end
+    end
+
+    tag :r,     'Revision',                    -5
+    tag :alpha, 'Alpha Release',               -4
+    tag :beta,  'Beta Release',                -3
+    tag :pre,   'Pre Release',                 -2
+    tag :rc,    'Release Candidate',           -1
+    tag :off,   'Official Release',             0
+    tag :p,     'Official Release Patch Level', 1 # should always be followed by an int
+  end
+
+  module ShortCut
+    def ` ( arg )
+      Version.parse arg
+    end
+  end
+end # class Version
+
+test_section __FILE__ do
 
 class VersionTest < Test::Unit::TestCase
 
+
+  include Version::ShortCut
+
   def setup
-    @a = Version.new(0, 1, 2, 3)
-    @b = Version.new(2, 1, 0, 10)
-    @c = Version.new(0, 0, 0, 0)
+    @a = Version.new(0, 1)
+    @b = Version.new(2, 0)
+    @c = Version.new(0, 0)
+    @a_rc2 = Version.new(0, 1, :rc, 2)
+    @b_p3 = Version.new(2, 0, :p, 3)
+    @a_alpha = Version.new(0, 1, :alpha)
+    @a_pre4 = Version.new(0, 1, :pre, 4)
+    @a_beta2 = Version.new(0, 1, :beta, 2)
+    @a_r463 = Version.new(0, 1, :r, 463)
   end
 
-
-  def test_simple
-    assert(Version.new(0, 1, 2, 3) < Version.new(0, 1, 2, 4))
-    assert(Version.new(0, 1, 2, 4) > Version.new(0, 1, 2, 3))
-    assert(Version.new(0, 1, 2, 3) == Version.new(0, 1, 2, 3))
-    assert(Version.new(0, 1, 3, 3) > Version.new(0, 1, 2, 3))
-    assert(Version.new(0, 1, 2, 3) < Version.new(0, 1, 3, 3))
-    assert(Version.new(3, 2, 2, 3) > Version.new(3, 1, 2, 3))
-    assert(Version.new(0, 1, 2, 3) < Version.new(0, 2, 2, 3))
-    assert(Version.new(0, 3, 3, 3) < Version.new(1, 2, 2, 10))
+  def test_parse
+    assert_equal @a, Version.parse('0.1')
+    assert_equal @a_r463, Version.parse('0.1_r463')
+    assert_raise(ArgumentError) { Version.parse('0.1.2') }
+    assert_raise(ArgumentError) { Version.parse('0.1-r2') }
+    assert_raise(ArgumentError) { Version.parse('0.1.r2') }
+    assert_raise(ArgumentError) { Version.parse('0.1.3-r2') }
+    assert_raise(ArgumentError) { Version.parse('0.1.3.4') }
+    assert_equal @b, Version.parse('2.0')
+    assert_equal @c, Version.parse('0.0')
+    assert_equal @c, Version.parse('0')
+    assert_equal @a_rc2, Version.parse('0.1_rc2')
+    assert_equal @a_alpha, Version.parse('0.1_alpha')
+    assert_equal @a_alpha, Version.parse('0.1_alpha0')
+    assert_equal @b_p3, Version.parse('2.0_p3')
+    assert_equal @a_pre4, Version.parse('0.1_pre4')
+    assert_equal @a_beta2, Version.parse('0.1_beta2')
+    foo_bar = Version.new(1, 3, :r, 42144, 'dev-util', 'foo', 'bar')
+    assert_equal foo_bar, `dev-util/foo-1.3_r42144#bar`
+    foo_bar = Version.new(1, 3, :pre, 4, 'dev-util', 'foo', 'bar')
+    assert_equal foo_bar, `dev-util/foo-1.3_pre4#bar`
+    foo_bar = Version.new(1, 2, :pre, 4, '', 'foo', 'bar')
+    assert_equal foo_bar, `foo-1.2_pre4#bar`
+    foo = Version.new(1, 2, :pre, 4, '', 'foo')
+    assert_equal foo_bar, `foo-1.2_pre4#bar`
   end
 
-  def checker ( my, meth, *ref )
-    assert_equal(Version.new(*ref), my.send(meth), meth)
-    assert_equal(Version.new(*ref), my, meth)
+  def test_comparison
+    assert `2.3` < `2.4`
+    assert `2.4` > `2.3`
+    assert `2.3` == `2.3`
+    assert `3.3` > `2.3`
+    assert `2.3` < `3.3`
+    assert `1.2_rc` < `1.2`
+    assert `1.2_p1` > `1.2`
+    assert `1.2_alpha` < `1.2_beta`
+    assert `1.2_pre` != `1.2`
+    assert `1.2_rc` == `1.2_rc0`
+    assert `1.3_pre` > `1.2_p12`
+    assert `1.3_alpha` > `1.2`
+    assert `3.2` > `2.12_p42`
+    assert `1.2_pre4` != `dev-util/foo-1.2_pre4#bar`
+    assert `dev-util/foo-1.2_pre4` == `dev-util/foo-1.2_pre4#bar`
   end
 
   def test_major_release
-    checker(@a, :major_release, 1, 0, 0, 4)
-    checker(@b, :major_release, 3, 0, 0, 11)
-    checker(@c, :major_release, 1, 0, 0, 1)
+    assert_equal `1.0_alpha`,  @a.major_release
+    assert_equal `3.0_alpha`, @b.major_release
+    assert_equal `1.0_alpha`,  @c.major_release
+    assert_equal `1.0_alpha`,  @a_rc2.major_release
+    assert_equal `3.0_alpha`, @b_p3.major_release
+    assert_equal `1.0_alpha`,  @a_alpha.major_release
+    assert_equal `1.0_alpha`,  @a_beta2.major_release
   end
 
   def test_minor_release
-    checker(@a, :minor_release, 0, 2, 0, 4)
-    checker(@b, :minor_release, 2, 2, 0, 11)
-    checker(@c, :minor_release, 0, 1, 0, 1)
+    assert_equal `0.2_alpha`, @a.minor_release
+    assert_equal `2.1_alpha`, @b.minor_release
+    assert_equal `0.1_alpha`, @c.minor_release
+    assert_equal `0.2_alpha`, @a_rc2.minor_release
   end
 
-  def test_build_release
-    checker(@a, :build_release, 0, 1, 3, 4)
-    checker(@b, :build_release, 2, 1, 1, 11)
-    checker(@c, :build_release, 0, 0, 1, 1)
+  def test_tag_releases
+    assert_equal `0.2_p2`, `0.1`.minor_release.alpha_release.beta_release.
+                 beta_release.pre_release.release_candidate.release_candidate.
+                 official_release.patch_level_release.patch_level_release
+    assert_equal `0.2`, `0.1`.minor_release.official_release
+    assert_raise ArgumentError do
+      `0.1`.minor_release.official_release.official_release
+    end
+    assert_equal `1.0_rc1`, `0.9_p42`.major_release.alpha_release.
+                 beta_release.release_candidate.release_candidate
+    assert_equal `1.0_alpha2`, `1.0_alpha1`.alpha_release
   end
 
   def test_pp
-    assert_equal('0.1.2 (Revision: 3)', @a.pp)
-    assert_equal('2.1.0 (Revision: 10)', @b.pp)
-    assert_equal('0.0.0 (Revision: 0)', @c.pp)
+    assert_equal 'Revision #462: 0.1', `0.1_r462`.pp
+    assert_equal 'Official Release: 0.1', @a.pp
+    assert_equal 'Official Release: 2.0', @b.pp
+    assert_equal 'Official Release: 0.0', @c.pp
+    assert_equal 'Alpha Release: 0.1', @a_alpha.pp
+    assert_equal 'Official Release Patch Level #3: 2.0', @b_p3.pp
+    assert_equal 'Pre Release #4: 1.2 bar', `dev-util/foo-1.2_pre4#bar`.pp
+  end
+
+  def test_to_s
+    assert_equal '1.2_r3', `1.2_r3`.to_s
+    assert_equal '1.0_p5', `1_p5`.to_s
+    assert_equal 'dev-util/foo-1.2_pre4#bar', `dev-util/foo-1.2_pre4#bar`.to_s
+  end
+
+  def test_short_string
+    assert_equal '1.0', `1`.short_string
+    assert_equal '1.0_p5', `1_p5`.short_string
+    assert_equal 'foo-1.2_pre4', `dev-util/foo-1.2_pre4#bar`.short_string
   end
 
 end # class VersionTest

data/lib/yaml_extension.rb

@@ -1,7 +1,7 @@
 # Copyright:: Copyright (c) 2005  Nicolas Pouillard. All rights reserved.
 # Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
 # License::   Gnu General Public License.
-# Revision::  $Id: yaml_extension.rb 383 2005-10-02 16:48:09Z ertai $
+# Revision::  $Id: /w/fey/ruby_ex/trunk/core_ex/lib/yaml_extension.rb 7988 2005-10-02T16:48:09.029068Z ertai  $
 
 require 'yaml'
 

data/test/fixtures/lazy_loading/a_b/a/c.rb

@@ -0,0 +1,6 @@
+class A
+  class B
+    class C
+    end # class C
+  end # class B
+end # class A

data/test/fixtures/lazy_loading/a_b/a.rb

@@ -0,0 +1,2 @@
+class A
+end # class A

data/test/fixtures/lazy_loading/a_b/b/c.rb

@@ -0,0 +1,4 @@
+class B
+  class C
+  end # class C
+end # class B

data/test/fixtures/lazy_loading/a_b/b.rb

@@ -0,0 +1,2 @@
+class B
+end # class B

data/test/fixtures/lazy_loading/double/a/bouhou.rb

@@ -0,0 +1,2 @@
+class Bouhou
+end

data/test/fixtures/lazy_loading/double/a/foo_bar.rb

@@ -0,0 +1,5 @@
+class FooBar
+  def self.name
+    'FooBar in double/a'
+  end
+end

data/test/fixtures/lazy_loading/double/a/sub/a/suba.rb

@@ -0,0 +1,7 @@
+module Sub
+  module A
+    class Suba
+    end # class Suba
+  end # module A
+end # module Sub
+

data/test/fixtures/lazy_loading/double/b/root/sub/b.rb

@@ -0,0 +1,6 @@
+module Root
+  class Sub
+    module B
+    end # module B
+  end # class Sub
+end # module Root

data/test/fixtures/lazy_loading/double/b/root/sub.rb

@@ -0,0 +1,4 @@
+module Root
+  class Sub
+  end # module Sub
+end # module Root

data/test/fixtures/lazy_loading/double/b/root.rb

@@ -0,0 +1,2 @@
+module Root
+end # module Root

data/test/fixtures/lazy_loading/foo_bars/foo_bar.rb

@@ -0,0 +1,4 @@
+module FooBars
+  class FooBar
+  end
+end

data/test/fixtures/lazy_loading/foo_bars/mods/mod.rb

@@ -0,0 +1,6 @@
+module FooBars
+  module Mods
+    class Mod
+    end
+  end
+end

data/test/fixtures/lazy_loading/foo_bars/mods/sub_mod.rb

@@ -0,0 +1,6 @@
+module FooBars
+  module Mods
+    class SubMod < Mod
+    end
+  end
+end

data/test/fixtures/lazy_loading/foo_bars/mods/sub_sub_mod.rb

@@ -0,0 +1,7 @@
+module FooBars
+  module Mods
+    class SubSubMod < SubMod
+    end
+  end
+end
+

data/test/fixtures/lazy_loading/foo_bars/mods.rb

@@ -0,0 +1,4 @@
+module FooBars
+  module Mods
+  end
+end

data/test/fixtures/lazy_loading/foo_bars/sub_foo_bar.rb

@@ -0,0 +1,5 @@
+module FooBars
+  class SubFooBar < FooBar
+    FOO = 42
+  end
+end

data/test/fixtures/lazy_loading/foo_bars/titis/tutu.rb

@@ -0,0 +1,6 @@
+module FooBars
+  module Titis
+    class Tutu
+    end
+  end
+end

data/test/fixtures/lazy_loading/foo_bars/totos.rb

@@ -0,0 +1,6 @@
+module FooBars
+  module Totos
+    class Tata
+    end
+  end
+end

data/test/fixtures/lazy_loading/foo_bars.rb

@@ -0,0 +1,4 @@
+module FooBars
+  NAME = 'foo'
+  # p NAME
+end

data/test/lazy_loading/test_already_present_name_absolute.rb

@@ -0,0 +1,6 @@
+class FooBar
+end
+module FooBars
+  class Boo < ::FooBars::FooBar
+  end
+end

data/test/lazy_loading/test_already_present_name_relative.rb

@@ -0,0 +1,11 @@
+# This test does not load FooBars::FooBar, its a limitation.
+class A
+end
+class FooBar
+end
+module FooBars
+  class B < A
+  end
+  class Boo < FooBar
+  end
+end

data/test/lazy_loading/test_inside_another_module.rb

@@ -0,0 +1,5 @@
+module FooBars
+  module Youhou
+    X = SubFooBar
+  end
+end