filter_io 0.1.6 → 0.2.0

data/.gitignore

@@ -1,4 +1,4 @@
-*.gemspec
+Gemfile.lock
 pkg
 coverage
 .bundle

data/Gemfile

@@ -1,6 +1,2 @@
-source :gemcutter
-
-gem 'jeweler'
-gem 'activesupport', '>=2.3.9'
-gem 'i18n', '>=0.4.1'
-gem 'test-unit'
+source 'https://rubygems.org/'
+gemspec

data/README.markdown

@@ -11,37 +11,41 @@
 
 You can install the gem by running:
 
-    gem install filter_io
+``` sh
+gem install filter_io
+```
 
 ### Example Usage
 
 #### A Simple Example: ROT-13
 
-    io = FilterIO.new io do |data|
-      data.tr "A-Za-z", "N-ZA-Mn-za-m"
-    end
+``` ruby
+io = FilterIO.new io do |data|
+  data.tr "A-Za-z", "N-ZA-Mn-za-m"
+end
+```
 
 #### A Useful Example: Line Ending Normalisation
 
 A common usage of `filter_io` is to normalise line endings before parsing CSV data:
 
-    # open source stream
-    File.open(filename) do |io|
-      
-      # apply filter to stream
-      io = FilterIO.new(io) do |data, state|
-        # grab another chunk if the last character is a delimiter
-        raise FilterIO::NeedMoreData if data =~ /[\r\n]\z/ && !state.eof?
-        # normalise line endings to LF
-        data.gsub /\r\n|\r|\n/, "\n"
-      end
-      
-      # process resulting stream normally
-      FasterCSV.parse(io) do |row|
-        pp row
-      end
-      
-    end
+``` ruby
+# open source stream
+File.open(filename) do |io|
+  # apply filter to stream
+  io = FilterIO.new(io) do |data, state|
+    # grab another chunk if the last character is a delimiter
+    raise FilterIO::NeedMoreData if data =~ /[\r\n]\z/ && !state.eof?
+    # normalise line endings to LF
+    data.gsub /\r\n|\r|\n/, "\n"
+  end
+  
+  # process resulting stream normally
+  FasterCSV.parse(io) do |row|
+    pp row
+  end
+end
+```
 
 ### Reference
 
@@ -66,16 +70,18 @@ If your block is unable to process the whole chunk of data immediately, it can r
 
 Here's an example which processes whole lines and prepends the line length to the beginning of each line.
 
-    io = FilterIO.new io do |data, state|
-      output = ''
-      # grab complete lines until we hit EOF
-      while data =~ /(.*)\n/ || (state.eof? && data =~ /(.+)/)
-        output << "#{$1.size} #{$1}\n"
-        data = $'
-      end
-      # `output` contains the processed lines, `data` contains any left over partial line
-      [output, data]
-    end
+``` ruby
+io = FilterIO.new io do |data, state|
+  output = ''
+  # grab complete lines until we hit EOF
+  while data =~ /(.*)\n/ || (state.eof? && data =~ /(.+)/)
+    output << "#{$1.size} #{$1}\n"
+    data = $'
+  end
+  # `output` contains the processed lines, `data` contains any left over partial line
+  [output, data]
+end
+```
 
 #### Block Size
 

data/Rakefile

@@ -1,54 +1,6 @@
-require 'rubygems'
 require 'rake'
-require 'rake/testtask'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
-desc 'Default: run unit tests.'
-task :default => :test
-
-desc 'Test the filter_io plugin.'
-Rake::TestTask.new(:test) do |t|
-  t.libs << 'lib'
-  t.libs << 'test'
-  t.pattern = 'test/**/*_test.rb'
-  t.verbose = true
-end
-
-task :test => :check_dependencies
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "filter_io"
-    gem.summary = "Filter IO streams with a block. Ruby's FilterInputStream."
-    gem.email = "jason@jasoncodes.com"
-    gem.homepage = "http://github.com/jasoncodes/filter_io"
-    gem.authors = ["Jason Weathered"]
-    gem.has_rdoc = false
-    gem.add_dependency 'activesupport'
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
-
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |t|
-    t.libs << "test"
-    t.rcov_opts = [
-      "--exclude '^(?!lib)'"
-    ]
-    t.test_files = FileList[
-      'test/**/*_test.rb'
-    ]
-    t.output_dir = 'coverage'
-    t.verbose = true
-  end
-  task :rcov do
-    system "open coverage/index.html"
-  end
-rescue LoadError
-  task :rcov do
-    raise "You must install the 'rcov' gem"
-  end
-end
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/filter_io.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'filter_io/version'
+
+Gem::Specification.new do |spec|
+  spec.name = %q{filter_io}
+  spec.version = FilterIO::VERSION
+  spec.authors = ['Jason Weathered']
+  spec.email = ['jason@jasoncodes.com']
+  spec.summary = %q{Filter IO streams with a block. Ruby's FilterInputStream.}
+  spec.homepage = 'http://github.com/jasoncodes/filter_io'
+  spec.license = 'MIT'
+
+  spec.files = `git ls-files`.split($/)
+  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activesupport', '>= 2.3.9'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'rspec', '~> 2.13'
+end

data/lib/filter_io/version.rb

@@ -0,0 +1,3 @@
+class FilterIO
+  VERSION = '0.2.0'
+end

data/lib/filter_io.rb

@@ -4,12 +4,11 @@ require 'active_support/core_ext/array'
 require 'active_support/core_ext/hash'
 
 class FilterIO
-  
   DEFAULT_BLOCK_SIZE = 1024
-  
+
   class NeedMoreData < Exception
   end
-  
+
   class BlockState
     attr_reader :bof, :eof
     def initialize(bof, eof)
@@ -19,7 +18,7 @@ class FilterIO
     alias_method :bof?, :bof
     alias_method :eof?, :eof
   end
-  
+
   def initialize(io, options = nil, &block)
     @io = io
     @options = options || {}
@@ -29,75 +28,99 @@ class FilterIO
     @buffer_raw = empty_string_raw
     @options.assert_valid_keys :block_size
   end
-  
+
   def pos
     @pos
   end
-  
+
   def bof?
     @pos == 0
   end
-  
+
   def eof?
     @buffer.empty? && source_eof?
   end
-  
+
   def source_eof?
     @buffer_raw.empty? && @io.eof?
   end
-  
+
   def close
     @io.close
   end
-  
+
   def closed?
     @io.closed?
   end
-  
-  def readchar
-    raise EOFError, 'end of file reached' if eof?
-    if @io.respond_to? :external_encoding
-      data = empty_string_raw
-      begin
-        data << read(1).force_encoding(@io.internal_encoding || @io.external_encoding)
-      end until data.valid_encoding? or source_eof?
-      data.encode! @io.internal_encoding if @io.internal_encoding
-      data
+
+  def default_encoding
+    unless @default_encoding
+      c = @io.getc
+      @io.ungetc c
+      @default_encoding = c.encoding
+    end
+    @default_encoding
+  end
+
+  def internal_encoding
+    if @io.respond_to?(:internal_encoding)
+      @io.internal_encoding
     else
-      read(1).ord
+      default_encoding
     end
   end
-  
+
+  def external_encoding
+    if @io.respond_to?(:external_encoding)
+      @io.external_encoding
+    else
+      default_encoding
+    end
+  end
+
+  def readchar
+    raise EOFError, 'end of file reached' if eof?
+    data = empty_string_raw
+    begin
+      byte = read(1)
+      if internal_encoding || external_encoding
+        byte.force_encoding internal_encoding || external_encoding
+      end
+      data << byte
+    end until data.valid_encoding? or source_eof?
+    data.encode! internal_encoding if internal_encoding
+    data
+  end
+
   def getc
     readchar
   rescue EOFError
     nil
   end
-  
+
   def read(length = nil)
-    
     raise ArgumentError if length && length < 0
     return '' if length == 0
-    
+
     # fill the buffer up to the fill level (or whole input if length is nil)
-    while !source_eof? && (length.nil? || length > bytesize(@buffer))
+    while !source_eof? && (length.nil? || length > @buffer.bytesize)
       buffer_data @options[:block_size] || length
     end
-    
+
     # we now have all the data in the buffer that we need (or can get if EOF)
     case
-    when bytesize(@buffer) > 0
+    when @buffer.bytesize > 0
       # limit length to the buffer size if we were asked for it all or have ran out (EOF)
-      read_length = if length.nil? or length > bytesize(@buffer)
-        bytesize @buffer
+      read_length = if length.nil? or length > @buffer.bytesize
+        @buffer.bytesize
       else
         length
       end
       data = pop_bytes read_length
-      @pos += bytesize(data)
-      if length.nil? && @io.respond_to?(:external_encoding)
-        data.force_encoding @io.external_encoding
-        data.encode! @io.internal_encoding if @io.internal_encoding
+      @pos += data.bytesize
+      if length.nil?
+        data.force_encoding external_encoding if external_encoding
+        data.encode! internal_encoding if internal_encoding
       end
       data
     when source_eof?
@@ -106,15 +129,13 @@ class FilterIO
     else
       raise IOError, 'Read error'
     end
-    
   end
-  
+
   def rewind
     seek 0, IO::SEEK_SET
   end
-  
+
   def seek(offset, whence = IO::SEEK_SET)
-    
     new_pos = case whence
     when IO::SEEK_SET
       offset
@@ -125,7 +146,7 @@ class FilterIO
     else
       raise Errno::EINVAL
     end
-    
+
     case new_pos
     when pos
       # noop
@@ -137,26 +158,25 @@ class FilterIO
     else
       raise Errno::EINVAL, 'Random seek not supported'
     end
-    
+
     0
   end
-  
+
   def ungetc(char)
-    char = char.chr if char.respond_to? :chr
-    @pos -= bytesize(char)
+    char = char.chr
+    @pos -= char.bytesize
     @pos = 0 if @pos < 0
     @buffer = char + @buffer
   end
-  
+
   def gets(sep_string = $/)
-    
     return nil if eof?
     return read if sep_string.nil?
-    
+
     paragraph_mode = sep_string == ''
     sep_string = "\n\n" if paragraph_mode
     sep_string = sep_string.to_s unless sep_string.is_a? String
-    
+
     if paragraph_mode
       # consume any leading newlines
       char = getc
@@ -167,12 +187,12 @@ class FilterIO
         return nil # nothing left except newlines, bail out
       end
     end
-    
+
     # fill the buffer until it contains the separator sequence
     until source_eof? or @buffer.index(sep_string)
       buffer_data @options[:block_size]
     end
-    
+
     # calculate how much of the buffer to return
     length = if idx = @buffer.index(sep_string)
       # we found the separator, include it in our output
@@ -181,18 +201,18 @@ class FilterIO
       # no separator found (must be EOF). return everything we've got
       length = @buffer.size
     end
-    
+
     # increment the position and return the buffer fragment
     data = @buffer.slice!(0, length)
-    @pos += bytesize(data)
-    
+    @pos += data.bytesize
+
     data
   end
-  
+
   def readline(sep_string = $/)
     gets(sep_string) or raise EOFError, 'end of file reached'
   end
-  
+
   def each_line(sep_string = $/)
     unless block_given?
       klass = defined?(Enumerator) ? Enumerator : Enumerable::Enumerator
@@ -205,64 +225,55 @@ class FilterIO
   end
   alias :each :each_line
   alias :lines :each_line
-  
+
   def readlines(sep_string = $/)
     lines = []
     each_line(sep_string) { |line| lines << line }
     lines
   end
-  
+
   protected
-  
+
   def empty_string
     str = String.new
-    if @io.respond_to?(:internal_encoding)
-      str.force_encoding @io.internal_encoding || @io.external_encoding
+    if internal_encoding || external_encoding
+      str.force_encoding internal_encoding || external_encoding
     end
     str
   end
-  
+
   def empty_string_raw
     str = String.new
-    if @io.respond_to?(:external_encoding)
-      str.force_encoding @io.external_encoding
+    if external_encoding
+      str.force_encoding external_encoding
     end
     str
   end
-  
-  def bytesize(str)
-    str.respond_to?(:bytesize) ? str.bytesize : str.size
-  end
-  
+
   def pop_bytes(count)
     data = begin
-      if @io.respond_to?(:internal_encoding)
-        @buffer.force_encoding 'ASCII-8BIT'
-      end
+      org_encoding = @buffer.encoding
+      @buffer.force_encoding 'ASCII-8BIT'
       @buffer.slice!(0, count)
     ensure
-      if @io.respond_to?(:internal_encoding)
-        @buffer.force_encoding @io.internal_encoding || @io.external_encoding
-      end
+      @buffer.force_encoding org_encoding
     end
     data
   end
-  
+
   def buffer_data(block_size = nil)
-    
     block_size ||= DEFAULT_BLOCK_SIZE
-    
+
     data = unless @buffer_raw.empty?
-     @buffer_raw.slice! 0, bytesize(@buffer_raw)
+     @buffer_raw.slice! 0, @buffer_raw.bytesize
     else
      @io.read(block_size) or return
     end
-    
-    initial_data_size = bytesize(data)
+
+    initial_data_size = data.bytesize
     begin
-      
       data = process_data data, initial_data_size
-      
+
       # if no processed data was returned and there is unprocessed data...
       if data.is_a?(Array) && data.size == 2 && data[0].size == 0 && data[1].size > 0
         # restore the unprocessed data into the temporary buffer
@@ -270,52 +281,45 @@ class FilterIO
         # and add some more data to the buffer
         raise NeedMoreData
       end
-      
     rescue NeedMoreData => e
       raise EOFError, 'end of file reached' if @io.eof?
       data << @io.read(block_size)
       retry
     end
-    
+
     data = [data] unless data.is_a? Array
     raise 'Block must have 1 or 2 values' unless data.size <= 2
-    if @buffer.respond_to?(:encoding) && @buffer.encoding != data[0].encoding
+    if @buffer.encoding != data[0].encoding
       if [@buffer, data[0]].any? { |x| x.encoding.to_s == 'ASCII-8BIT' }
         data[0] = data[0].dup.force_encoding @buffer.encoding
       end
     end
     @buffer << data[0]
     if data[1]
-      if @io.respond_to?(:internal_encoding) && @io.internal_encoding
-        data[1].convert! @io.external_encoding
+      if internal_encoding
+        data[1].convert! external_encoding
       end
       @buffer_raw = data[1]
     end
-    
   end
-  
+
   def process_data(data, initial_data_size)
-    
-    if @io.respond_to? :external_encoding
-      org_encoding = data.encoding
-      data.force_encoding @io.external_encoding
-      additional_data_size = bytesize(data) - initial_data_size
-      unless data.valid_encoding? or source_eof? or additional_data_size >= 4
-        data.force_encoding org_encoding
-        raise NeedMoreData
-      end
-      data.encode! @io.internal_encoding if @io.internal_encoding
+    org_encoding = data.encoding
+    data.force_encoding external_encoding if external_encoding
+    additional_data_size = data.bytesize - initial_data_size
+    unless data.valid_encoding? or source_eof? or additional_data_size >= 4
+      data.force_encoding org_encoding
+      raise NeedMoreData
     end
-    
+    data.encode! internal_encoding if internal_encoding
+
     if data && @block
-      state = BlockState.new @io.pos == data.length, source_eof?
-      args = [data.dup, state]
-      args = args.first(@block.arity > 0 ? @block.arity : 1)
+      args = [data.dup]
+      args << BlockState.new(@io.pos == data.length, source_eof?) if @block.arity > 1
       data = @block.call(*args)
       raise IOError, 'Block returned nil' if data.nil?
     end
-    
+
     data
   end
-  
 end