snappy 0.0.14-java → 0.2.0-java

data/lib/snappy/reader.rb

@@ -1,41 +1,49 @@
+# frozen_string_literal: true
+
+require "snappy/shim"
+require "snappy/writer"
+
 module Snappy
   class Reader
     attr_reader :io, :magic, :default_version, :minimum_compatible_version
 
     def initialize(io)
-      @io = io
-      @io.set_encoding Encoding::ASCII_8BIT unless RUBY_VERSION =~ /^1\.8/
+      @io = Snappy.set_encoding io
       read_header!
       yield self if block_given?
     end
 
     def each
+      return to_enum unless block_given?
+
       until @io.eof?
         if @chunked
-          size = @io.read(4).unpack('N').first
-          yield Snappy.inflate(@io.read(size)) if block_given?
+          size = @io.read(4).unpack1("N")
+          yield Snappy.inflate(@io.read(size))
         else
-          yield Snappy.inflate @io.read if block_given?
+          yield Snappy.inflate(@io.read)
         end
       end
     end
 
     def read
-      @buff = StringIO.new
+      buff = StringIO.new
       each do |chunk|
-        @buff << chunk
+        buff << chunk
       end
-      @buff.string
+      buff.string
     end
 
-    def each_line(sep_string=$/)
+    def each_line(sep_string = $/)
+      return to_enum(:each_line, sep_string) unless block_given?
+
       last = ""
       each do |chunk|
         chunk = last + chunk
         lines = chunk.split(sep_string)
         last = lines.pop
         lines.each do |line|
-          yield line if block_given?
+          yield line
         end
       end
       yield last
@@ -46,7 +54,7 @@ module Snappy
     def read_header!
       header = @io.read Snappy::Writer::MAGIC.length
       if header.length == Snappy::Writer::MAGIC.length && header == Snappy::Writer::MAGIC
-        @magic, @default_version, @minimum_compatible_version = header, *@io.read(8).unpack('NN')
+        @magic, @default_version, @minimum_compatible_version = header, *@io.read(8).unpack("NN")
         @chunked = true
       else
         @io.rewind

data/lib/snappy/shim.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Snappy
+  module_function
+
+  if RUBY_VERSION[0..2] == "1.8"
+    def set_encoding(io)
+      io
+    end
+
+    def b(str)
+      str
+    end
+  else
+    def set_encoding(io)
+      io.set_encoding Encoding::ASCII_8BIT
+      io
+    end
+
+    if ::String.instance_methods.include? :b
+      def b(str)
+        str.b
+      end
+    else
+      def b(str)
+        str.force_encoding Encoding::ASCII_8BIT
+      end
+    end
+  end
+end

data/lib/snappy/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Snappy
-  VERSION = "0.0.14"
+  VERSION = "0.2.0"
 end

data/lib/snappy/writer.rb

@@ -1,10 +1,10 @@
+# frozen_string_literal: true
+
+require 'snappy/shim'
+
 module Snappy
   class Writer
-    if RUBY_VERSION[0..2] == '1.8'
-      MAGIC = "\x82SNAPPY\x0"
-    else
-      MAGIC = "\x82SNAPPY\x0".force_encoding Encoding::ASCII_8BIT
-    end
+    MAGIC = Snappy.b("\x82SNAPPY\x0")
     DEFAULT_VERSION = 1
     MINIMUM_COMPATIBLE_VERSION = 1
     DEFAULT_BLOCK_SIZE = 32 * 1024
@@ -13,9 +13,8 @@ module Snappy
 
     def initialize(io, block_size = DEFAULT_BLOCK_SIZE)
       @block_size = block_size
-      @buffer = ""
-      @io = io
-      @io.set_encoding Encoding::ASCII_8BIT unless RUBY_VERSION =~ /^1\.8/
+      @buffer = String.new
+      @io = Snappy.set_encoding io
       write_header!
       if block_given?
         yield self
@@ -34,7 +33,7 @@ module Snappy
       compressed = Snappy.deflate(@buffer)
       @io << [compressed.size, compressed].pack("Na#{compressed.size}")
       @io.flush
-      @buffer = ""
+      @buffer.clear
     end
 
     alias_method :flush, :dump!

data/snappy.gemspec

@@ -1,56 +1,36 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+
+lib = File.expand_path("lib", __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'snappy/version'
+require "snappy/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "snappy"
   spec.version       = Snappy::VERSION
   spec.authors       = ["miyucy"]
   spec.email         = ["fistfvck@gmail.com"]
-  spec.description   = %q{libsnappy binding for Ruby}
-  spec.summary       = %q{libsnappy binding for Ruby}
+  spec.description   = "libsnappy binding for Ruby"
+  spec.summary       = "libsnappy binding for Ruby"
   spec.homepage      = "http://github.com/miyucy/snappy"
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files`.split($/)
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  spec.test_files    = `git ls-files -z -- test`.split("\x0")
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.files        -= spec.test_files
+  spec.files        -= ["vendor/snappy"]
+  spec.files        += Dir["vendor/snappy/**/*"].reject { |e| e.start_with? "vendor/snappy/testdata" }
+
   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"]
 
   if defined?(JRUBY_VERSION)
     spec.files += %w[lib/snappy_ext.jar]
-    spec.platform = 'java'
-    spec.add_dependency 'snappy-jars', '~> 1.1.0'
+    spec.platform = "java"
+    spec.add_dependency "snappy-jars", "~> 1.1.0"
   else
     spec.extensions = ["ext/extconf.rb"]
   end
-
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "minitest"
-
-  # get an array of submodule dirs by executing 'pwd' inside each submodule
-  `git submodule --quiet foreach pwd`.split($\).each do |submodule_path|
-    # for each submodule, change working directory to that submodule
-    Dir.chdir(submodule_path) do
-
-      # issue git ls-files in submodule's directory
-      submodule_files = `git ls-files`.split($\)
-
-      # prepend the submodule path to create absolute file paths
-      submodule_files_fullpaths = submodule_files.map do |filename|
-        "#{submodule_path}/#{filename}"
-      end
-
-      # remove leading path parts to get paths relative to the gem's root dir
-      # (this assumes, that the gemspec resides in the gem's root dir)
-      submodule_files_paths = submodule_files_fullpaths.map do |filename|
-        filename.gsub "#{File.dirname(__FILE__)}/", ""
-      end
-
-      # add relative paths to gem.files
-      spec.files += submodule_files_paths
-    end
-  end
 end

data/test/hadoop/snappy_hadoop_reader_test.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "stringio"
+
+class SnappyHadoopReaderTest < Test::Unit::TestCase
+  def setup
+    @buffer = StringIO.new
+    Snappy::Hadoop::Writer.new @buffer do |w|
+      w << "foo"
+      w << "bar"
+      w << "baz"
+      w << "quux"
+    end
+    @buffer.rewind
+  end
+
+  def subject
+    @subject ||= Snappy::Hadoop::Reader.new @buffer
+  end
+
+  sub_test_case "#initialize" do
+    test "should yield itself to the block" do
+      yielded = nil
+      returned = Snappy::Hadoop::Reader.new @buffer do |r|
+        yielded = r
+      end
+      assert_equal returned, yielded
+    end
+  end
+
+  sub_test_case "#io" do
+    test "should be a constructor argument" do
+      assert_equal @buffer, subject.io
+    end
+
+    test "should not receive `length' in initializing" do
+      dont_allow(@buffer).length
+      Snappy::Hadoop::Reader.new @buffer
+    end
+  end
+
+  sub_test_case "#each" do
+    def setup
+      @buffer = StringIO.new
+      Snappy::Hadoop::Writer.new @buffer do |w|
+        w << "foo"
+        w << "bar"
+        w.dump!
+        w << "baz"
+        w << "quux"
+      end
+      @buffer.rewind
+    end
+
+    test "should yield each chunk" do
+      chunks = []
+      subject.each do |chunk|
+        chunks << chunk
+      end
+      assert_equal %w[foobar bazquux], chunks
+    end
+  end
+
+  sub_test_case "#read" do
+    test "should return the bytes" do
+      assert_equal "foobarbazquux", subject.read
+    end
+  end
+
+  sub_test_case "#each_line" do
+    def setup
+      @buffer = StringIO.new
+      Snappy::Hadoop::Writer.new @buffer do |w|
+        w << "foo\n"
+        w << "bar"
+        w.dump!
+        w << "baz\n"
+        w << "quux\n"
+      end
+      @buffer.rewind
+    end
+
+    test "should yield each line" do
+      lines = []
+      subject.each_line do |line|
+        lines << line
+      end
+      assert_equal %w[foo barbaz quux], lines
+    end
+
+    test "should return enumerator w/o block" do
+      eacher = subject.each_line
+      assert_instance_of Enumerator, eacher
+      lines = []
+      loop { lines << eacher.next }
+      assert_equal %w[foo barbaz quux], lines
+    end
+
+    test "each_line split by sep_string" do
+      buffer = StringIO.new
+      Snappy::Hadoop::Writer.new buffer do |w|
+        w << %w[a b c].join(",")
+        w.dump!
+        w << %w[d e f].join(",")
+      end
+      buffer.rewind
+      reader = Snappy::Hadoop::Reader.new buffer
+      eacher = reader.each_line(",")
+      lines = []
+      loop { lines << eacher.next }
+      assert_equal %w[a b cd e f], lines
+    end
+  end
+end

data/test/hadoop/snappy_hadoop_writer_test.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "stringio"
+
+class SnappyHadoopWriterTest < Test::Unit::TestCase
+  def setup
+    @buffer = StringIO.new
+  end
+
+  def subject
+    @subject ||= Snappy::Hadoop::Writer.new @buffer
+  end
+
+  sub_test_case "#initialize" do
+    test "should yield itself to the block" do
+      yielded = nil
+      returned = Snappy::Hadoop::Writer.new @buffer do |w|
+        yielded = w
+      end
+      assert_equal returned, yielded
+    end
+
+    test "should write the header" do
+      Snappy::Hadoop::Writer.new @buffer do |w|
+        w << "foo"
+      end
+      assert_equal "\u0000\u0000\u0000\u0003\u0000\u0000\u0000\u0005\u0003\bfoo", @buffer.string
+    end
+  end
+
+  sub_test_case "#io" do
+    test "should be a constructor argument" do
+      io = StringIO.new
+      assert_equal io, Snappy::Hadoop::Writer.new(io).io
+    end
+  end
+
+  sub_test_case "#block_size" do
+    test "should default to DEFAULT_BLOCK_SIZE" do
+      assert_equal Snappy::Hadoop::Writer::DEFAULT_BLOCK_SIZE, subject.block_size
+    end
+
+    test "should be settable via the constructor" do
+      assert_equal 42, Snappy::Hadoop::Writer.new(StringIO.new, 42).block_size
+    end
+  end
+end

data/test/snappy_hadoop_test.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "stringio"
+
+class SnappyHadoopTest < Test::Unit::TestCase
+  T = [*"a".."z", *"A".."Z", *"0".."9"].freeze
+
+  def random_data(length = 1024)
+    Array.new(length) { T.sample }.join
+  end
+
+  test "well done" do
+    s = random_data
+    assert_equal s, Snappy::Hadoop.inflate(Snappy::Hadoop.deflate(s))
+  end
+
+  test "well done(pair)" do
+    s = random_data
+    [
+      %i[deflate inflate]
+    ].each do |(i, o)|
+      assert_equal s, Snappy::Hadoop.__send__(o, Snappy::Hadoop.__send__(i, s))
+    end
+  end
+end

data/test/snappy_reader_test.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "stringio"
+
+class SnappyReaderTest < Test::Unit::TestCase
+  def setup
+    @buffer = StringIO.new
+    Snappy::Writer.new @buffer do |w|
+      w << "foo"
+      w << "bar"
+      w << "baz"
+      w << "quux"
+    end
+    @buffer.rewind
+  end
+
+  def subject
+    @subject ||= Snappy::Reader.new @buffer
+  end
+
+  sub_test_case "#initialize" do
+    test "should yield itself to the block" do
+      yielded = nil
+      returned = Snappy::Reader.new @buffer do |r|
+        yielded = r
+      end
+      assert_equal returned, yielded
+    end
+
+    test "should read the header" do
+      assert_equal Snappy::Writer::MAGIC, subject.magic
+      assert_equal Snappy::Writer::DEFAULT_VERSION, subject.default_version
+      assert_equal Snappy::Writer::MINIMUM_COMPATIBLE_VERSION, subject.minimum_compatible_version
+    end
+  end
+
+  sub_test_case :initialize_without_headers do
+    def setup
+      @buffer = StringIO.new
+      @buffer << Snappy.deflate("HelloWorld" * 10)
+      @buffer.rewind
+    end
+
+    test "should inflate with a magic header" do
+      assert_equal "HelloWorld" * 10, subject.read
+    end
+
+    test "should not receive `length' in eaching" do
+      dont_allow(@buffer).length
+      subject.read
+    end
+  end
+
+  sub_test_case "#io" do
+    test "should be a constructor argument" do
+      assert_equal @buffer, subject.io
+    end
+
+    test "should not receive `length' in initializing" do
+      dont_allow(@buffer).length
+      Snappy::Reader.new @buffer
+    end
+  end
+
+  sub_test_case "#each" do
+    def setup
+      @buffer = StringIO.new
+      Snappy::Writer.new @buffer do |w|
+        w << "foo"
+        w << "bar"
+        w.dump!
+        w << "baz"
+        w << "quux"
+      end
+      @buffer.rewind
+    end
+
+    test "should yield each chunk" do
+      chunks = []
+      subject.each do |chunk|
+        chunks << chunk
+      end
+      assert_equal %w[foobar bazquux], chunks
+    end
+
+    test "should return enumerator w/o block" do
+      eacher = subject.each
+      assert_instance_of Enumerator, eacher
+      chunks = []
+      chunks << eacher.next
+      chunks << eacher.next
+      assert_raise(StopIteration) { eacher.next }
+      assert_equal %w[foobar bazquux], chunks
+    end
+  end
+
+  sub_test_case "#read" do
+    test "should return the bytes" do
+      assert_equal "foobarbazquux", subject.read
+    end
+  end
+
+  sub_test_case "#each_line" do
+    def setup
+      @buffer = StringIO.new
+      Snappy::Writer.new @buffer do |w|
+        w << "foo\n"
+        w << "bar"
+        w.dump!
+        w << "baz\n"
+        w << "quux\n"
+      end
+      @buffer.rewind
+    end
+
+    test "should yield each line" do
+      lines = []
+      subject.each_line do |line|
+        lines << line
+      end
+      assert_equal %w[foo barbaz quux], lines
+    end
+
+    test "should return enumerator w/o block" do
+      eacher = subject.each_line
+      assert_instance_of Enumerator, eacher
+      lines = []
+      loop { lines << eacher.next }
+      assert_equal %w[foo barbaz quux], lines
+    end
+
+    test "each_line split by sep_string" do
+      buffer = StringIO.new
+      Snappy::Writer.new buffer do |w|
+        w << %w[a b c].join(",")
+        w.dump!
+        w << %w[d e f].join(",")
+      end
+      buffer.rewind
+      reader = Snappy::Reader.new buffer
+      eacher = reader.each_line(",")
+      lines = []
+      loop { lines << eacher.next }
+      assert_equal %w[a b cd e f], lines
+    end
+  end
+end