rfile 0.1.1 → 0.2.0

data/lib/rfile.rb

@@ -1,62 +1,137 @@
-# $Id: rfile.rb 46 2006-08-14 06:13:47Z cmaujean $
+# $Id: rfile.rb 54 2006-08-16 19:29:37Z cmaujean $
 #
-# See LICENSE for copyright information
-# 
-# This class is a line oriented "file" object that operates
+
+# This class is a line oriented file object that operates
 # without keeping the file in memory.
 # 
-# Enumerable is mixed in, so see Enumerable for more
+# Enumerable is mixed in, see Enumerable for more
 # information.
 # 
 class RFile
-	include Enumerable
-
-	# parses and indexes <i>filename</i>.
-	#--
-	# storing line information (offset and length)
-	#++
-	def initialize(filename)
-		@filename  = filename
-		@index     = []
-		@rndindex  = []
-		count      = 1
-		offset     = 1
-
-		File.open(@filename).each_line do |line|
-			@index[count] = [line.length, offset-1]
-			offset += line.length
-			count+=1
-		end
-		@rndindex = @index.clone
-	end
-
-	# returns a random line from the file. will not repeat lines. 
-	# returns nil when the file is exausted. note: does not modify file. 
-	def randomline
-		entry = nil
-		while entry.nil? and @rndindex.length > 0
-			entry = @rndindex.delete_at(rand(@rndindex.length))
-		end
+  include Enumerable
+  attr_accessor :recycle, :filename
+
+  # parses and indexes <i>filename</i>.
+  #
+  # if recycle == true, the randomline 
+  # method will reload the index (fast)
+  # when it runs out of unique lines to produce
+  #
+  # if sep_string is passed, "lines" will be determined
+  # by sep_string instead of $/
+  #--
+  # storing line information (length, offset, )
+  #++
+  def initialize(filename, recycle=false, sep_string=$/)
+    @filename  = filename
+    @recycle = recycle
+    @sep_string = sep_string
+    @index     = Array.new
+    @rndindex  = []
+    count      = 0
+    offset     = 1
+
+    File.open(@filename).each_line(@sep_string) do |line|
+      @index[count] = IndexElement.new([line.length, offset-1, count+1])     
+      offset += line.length
+      count+=1
+    end
+    @rndindex = RandomStack.new(@index.clone)
+  end
+
+  # returns a random line from the file. will not repeat lines. 
+  # returns nil when the file is exausted. note: does not modify file. 
+  def randomline
+    entry = nil
+    if @recycle and @rndindex.length == 0 
+      @rndindex = RandomStack.new(@index)
+    end
+    while(entry.nil? and @rndindex.length > 0)
+      entry = @rndindex.pop
+    end
     entry.nil? and return nil
-		entry.length == 2 and return IO.read(@filename, entry[0], entry[1]).chomp 
-	end
-
-	# returns the line at num
-	def line(num)
-		entry = @index[num]
-		return IO.read(@filename, entry[0], entry[1]).chomp 
-	end
-	
-	# yields each line in the file, in turn.
-	# 
-	# note: currently IO intensive as it will open and close the file
-	# for each line.
-	#  
-	def each # :yields:line
-		@index.each_with_index do |entry,i|
-			yield line(i) unless entry.nil?
-		end
-	end
+    return line(entry.linum) 
+  end
+
+  # return true if there are no lines left for randomline(s) ( only useful if
+  # recycle=true )
+  def r_eof?
+    return true if @rndindex.length == 0
+    false
+  end
+
+  # yields num random lines or returns them as an array. see randomline for details
+  def randomlines(num) #:yields:line
+    arr = Array.new
+    doyield = block_given?
+    num.times do |i|
+      rline = randomline()
+        yield rline if doyield
+        arr.push rline
+    end
+    arr if not doyield
+  end
+
+  # returns the number of lines available to randomline based methods
+  # in the current cycle. useful if you want to know how close you
+  # are to recycling the file, or how close to r_eof? == true
+  def length
+    @rndindex.length
+  end
+
+  # returns the line at num (provided num is greater than or equal to 1)
+  # returns nil if num is larger than the lines available
+  def line(num)
+    if (num < 1) or (num > @index.length)
+      raise "line number: #{num} is out of bounds"
+    end
+    entry = @index[num-1]
+    IO.read(@filename, entry.length, entry.offset).chomp(@sep_string)
+  end
+  
+  # yields each line in the file, in turn.
+  # 
+  # <i>note: currently IO intensive as it will open and close the file
+  # for each line.</i>
+  #  
+  def each # :yields:line
+    @index.each do |entry|
+      yield line(entry.linum) unless entry.nil?
+    end
+  end
+end
+
+# A randomizing stack
+class RandomStack
+  # incoming is an array that becomes the stack data
+  def initialize(incoming)
+    incoming.compact
+    @stack = incoming.sort_by { rand }.clone
+  end
+
+  # removes the top entry from the stack and returns it.
+  def pop
+    @stack.pop
+  end
+  
+  # returns the number of items left in the stack
+  def length
+    @stack.length
+  end
 end
 
+# length, offset and line number for an indexed chunk of file
+class IndexElement
+  attr_accessor :length, :offset, :linum
+  @length = 0
+  @offset = 0
+  @linum  = 0
+
+  def initialize(index_data=[])
+      (@length,@offset,@linum) = index_data
+  end
+end
+
+require 'rfile/version'
+
 # vi:sw=2 ts=2

data/lib/rfile/version.rb

@@ -0,0 +1 @@
+RFile::VERSION = "0.2.0"

data/test/data/sep_string_test

@@ -0,0 +1,8 @@
+This is a test file for the rfile
+sep string test
+to see if we can -- load multiple "lines" - and use a different sep string than the $/ default one.
+--
+--
+so here we see if this is line 4 or not.
+
+--

data/test/data/testenummixin

@@ -0,0 +1,3 @@
+Line 1
+Line 2
+Line 3

data/test/tc_rfile.rb

@@ -1,5 +1,5 @@
-require 'rfile'
 require 'test/unit'
+require 'rfile'
 
 class TestRFile < Test::Unit::TestCase
   def setup
@@ -9,22 +9,26 @@ class TestRFile < Test::Unit::TestCase
   def test_rfile
     assert(@f.randomline.is_a?(String), "line is a string")
     testline = @f.randomline
-    assert((testline == "Line 1" or testline == "Line 2" or testline == "Line 3"), "Line is valid: #{testline}")
+    assert(valid_line(testline), "Line is valid: #{testline}")
     assert(@f.randomline) 
     assert(@f.line(1) == "Line 1", "line(1) returns Line 1: #{@f.line(1)}")
   end
 
   def test_enum_mixin
+    g = RFile.new("rfile/test/data/testenummixin")
     count = 0
-    @f.each_with_index do |l,i| 
-      case i
-      when 0
-        assert_equal(l, "Line 1")
+    g.each_with_index do |l,i|
+      case (i+1)
       when 1
-        assert_equal(l, "Line 2")
+        assert_equal "Line 1", l
       when 2
-        assert_equal(l, "Line 3")
+        assert_equal "Line 2", l
+      when 3
+        assert_equal "Line 3", l
+      else
+        flunk "bad index: #{i}"
       end
+      
       count+=1
     end
     assert count == 3, "EACH TEST: count should be 3 count is #{count}"
@@ -33,6 +37,88 @@ class TestRFile < Test::Unit::TestCase
     assert( @f.reject {|t| t == "Line 3"} == ["Line 1", "Line 2"], "Enum: testing reject { }" )
     assert( @f.collect {|t| "This is " + t } == ["This is Line 1", "This is Line 2", "This is Line 3"], "Enum: testing collect")
   end
+
+  def test_recycle
+    g = RFile.new("rfile/test/data/testfile", true)
+    5.downto 0 do
+    	g.randomline
+    end
+    assert valid_line(g.randomline), "Recycle failed"
+  end
+
+  def test_length
+    f = RFile.new("rfile/test/data/testfile")
+    f.randomline
+    assert_equal 2, f.length, "Length should be 2"
+  end
+
+  def test_r_eof
+    f = RFile.new("rfile/test/data/testfile")
+    3.downto 1 do
+      f.randomline
+    end
+    assert f.r_eof?, "length is #{f.length}"
+  end
+
+  def test_randomlines
+    f = RFile.new("rfile/test/data/testfile")
+
+    # test block form
+    f.randomlines(2) do |line|
+      assert(valid_line(line), "Randomlines block form: #{line}")
+    end
+
+    g = RFile.new("rfile/test/data/testfile")
+
+    # test array form
+    arr = g.randomlines(2)
+    arr.each do |line|
+      assert(valid_line(line), "Randomlines array form: #{line}")
+    end
+  end
+
+  def test_sep_string
+    f = RFile.new("rfile/test/data/sep_string_test", false, "--")
+    assert_equal "\nso here we see if this is line 4 or not.\n\n", f.line(4), "is: #{f.line(4)}"
+  end
+
+  def valid_line(line)
+    case line
+    when "Line 1"
+      true
+    when "Line 2"
+      true
+    when "Line 3"
+      true
+    else
+      false
+    end
+  end
+end
+
+class TestRandomStack < Test::Unit::TestCase
+  def setup
+    @rstack = RandomStack.new([ "foo", "bar", "baz" ])
+  end
+  def test_length_and_pop
+    [ 3, 2, 1, 0, 0 ].each do |i|
+      assert_equal i, @rstack.length, "length and pop, length test: i = #{i} and length = #{@rstack.length}"
+      popval = @rstack.pop
+
+      case popval
+      when "foo"
+        assert true, "Random value popped is valid"
+      when "bar"
+        assert true, "Random value popped is valid"
+      when "baz"
+        assert true, "Random value popped is valid"
+      when nil
+        assert true, "Random value popped is nil"
+      else
+        flunk "randomstack failed"
+      end
+    end
+  end
 end
 
 # vi:sw=2 ts=2

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: rfile
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
-date: 2006-08-13 00:00:00 -07:00
+  version: 0.2.0
+date: 2006-08-19 00:00:00 -07:00
 summary: a read only, line oriented, sparse file class
 require_paths: 
 - lib
@@ -30,10 +30,14 @@ authors:
 - Christopher Maujean
 files: 
 - lib/rfile.rb
+- lib/rfile
 - lib/LICENSE
-- test/data
+- lib/rfile/version.rb
 - test/tc_rfile.rb
+- test/data
 - test/data/testfile
+- test/data/sep_string_test
+- test/data/testenummixin
 test_files: 
 - test/tc_rfile.rb
 rdoc_options: []