xdr 3.0.1 → 3.0.2

data/.gitignore

@@ -1,15 +0,0 @@
-/.bundle/
-/.yardoc
-/Gemfile.lock
-/_yardoc/
-/coverage/
-/doc/generated
-/pkg/
-/spec/reports/
-/tmp/
-*.bundle
-*.so
-*.o
-*.a
-mkmf.log
-.DS_Store

data/.travis.yml

@@ -1,9 +0,0 @@
-language: ruby
-rvm:
-- 2.2.6
-- 2.3.3
-- 2.4.0
-- jruby
-notifications:
-  slack:
-    secure: fXYggrDRoLB/4yvyW0kWwyrV5yWa/GC0btPyGu7Hx6ZOaXDC+ejiXSfx7nRyY+uZBs5UF12O4gkUXwBbnWDT5JtQRxzZd5s0cyeGQfAakALexI+FuR2jDcV1prCCaYI4IYoUt61MlfDmuCYVm8hGZ3qsgk/GPHHPnZ8a1FBd2ls=

data/.yardopts

@@ -1,7 +0,0 @@
---output-dir doc/generated
---protected
---no-private
---embed-mixin ClassMethods
-lib/**/*.rb
--
-doc/*.md

data/Gemfile

@@ -1,4 +0,0 @@
-source 'https://rubygems.org'
-
-# Specify your gem's dependencies in xdr.gemspec
-gemspec

data/Guardfile

@@ -1,5 +0,0 @@
-guard :rspec, cmd: 'bundle exec rspec' do
-  watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
-  watch('spec/spec_helper.rb')  { "spec" }
-end

data/Rakefile

@@ -1,9 +0,0 @@
-require "bundler/gem_tasks"
-
-begin
-  require 'rspec/core/rake_task'
-  RSpec::Core::RakeTask.new(:spec)
-  task :default => :spec
-rescue LoadError
-end
-

data/examples/enum.rb

@@ -1,30 +0,0 @@
-require 'xdr'
-
-class Color < XDR::Enum
-  member :red, 0
-  member :green, 1
-  member :blue, 2
-
-  seal
-end
-
-class ResultType < XDR::Enum
-  member :ok, 0
-  member :error, 1
-  seal
-end
-
-Color.members           # => {:red => 0, :green => 1, :blue => 2}
-Color.members.keys      # => [:red, :green, :blue]
-
-# string and symbol work
-# any casing that can be underscored to the correct value will work
-Color.from_name(:RED)   # => #<Color:... @name="red", @value=0>
-Color.from_name("RED")  # => #<Color:... @name="red", @value=0>
-Color.from_name("red")  # => #<Color:... @name="red", @value=0>
-Color.from_name(:red)  # => #<Color:... @name="red", @value=0>
-
-Color.from_xdr("\x00\x00\x00\x00") # => #<Color:... @name="red", @value=0>
-Color.to_xdr(Color.green) # => "\x00\x00\x00\x01"
-
-Color.red == ResultType.ok # => false

data/examples/struct.rb

@@ -1,24 +0,0 @@
-require 'xdr'
-
-class Signature < XDR::Struct
-  attribute :public_key, XDR::Opaque[32]
-  attribute :data, XDR::Opaque[32]
-end
-
-class Envelope < XDR::Struct
-  attribute :body,      XDR::VarOpaque[]
-  attribute :timestamp, XDR::Int
-  attribute :signature, Signature
-end
-
-sig            = Signature.new()
-sig.public_key = "\x01" * 32
-sig.data       = "\x00" * 32
-
-env = Envelope.new({
-  signature: sig,
-  body: "hello",
-  timestamp: Time.now.to_i
-})
-
-env.to_xdr

data/examples/union.rb

@@ -1,29 +0,0 @@
-require 'xdr'
-
-class ResultType < XDR::Enum
-  member :ok,       0
-  member :error,    1
-  member :nonsense, 2
-  seal
-end
-
-class Result < XDR::Union
-  switch_on ResultType, :type
-
-  switch :ok
-  switch :error, :message
-  switch :default
-
-  attribute :message, XDR::String[]
-end
-
-r = Result.new()
-r.set(:error, "hello")
-r.message! # => "hello"
-r.get # => "hello"
-
-r.set(:ok)
-r.get # => nil
-
-r.set(:nonsense)
-r.get # => nil

data/spec/lib/xdr/array_spec.rb

@@ -1,73 +0,0 @@
-require 'spec_helper'
-
-describe XDR::Array, "#read" do
-  let(:empty) { XDR::Array[XDR::Int, 0] }
-  let(:one)   { XDR::Array[XDR::Int, 1] }
-  let(:many)  { XDR::Array[XDR::Int, 2] }
-
-  it "decodes values correctly" do
-    expect( read empty, "" ).to eq([])
-    expect( read empty, "\x00\x00\x00\x00" ).to eq([])
-    expect( read one, "\x00\x00\x00\x00" ).to eq([0])
-    expect( read one, "\x00\x00\x00\x01" ).to eq([1])
-    expect( read many, "\x00\x00\x00\x00\x00\x00\x00\x01" ).to eq([0, 1])
-    expect( read many, "\x00\x00\x00\x01\x00\x00\x00\x01" ).to eq([1, 1])
-  end
-
-  it "raises EOFError the byte stream isn't large enough" do
-    expect{ read many, "\x00\x00\x00\x00" }.to raise_error(EOFError)
-  end
-
-  def read(reader, str)
-    io = StringIO.new(str)
-    reader.read(io)
-  end
-end
-
-describe XDR::Array, "#write" do
-  subject{ XDR::Array[XDR::Int, 2] }
-
-  it "encodes values correctly" do
-    expect(write [1,2]).to eq("\x00\x00\x00\x01\x00\x00\x00\x02")
-    expect(write [1,4]).to eq("\x00\x00\x00\x01\x00\x00\x00\x04")
-  end
-
-  it "raises a WriteError if the value is not the correct length" do
-    expect{ write nil     }.to raise_error(XDR::WriteError)
-    expect{ write []      }.to raise_error(XDR::WriteError)
-    expect{ write [1]     }.to raise_error(XDR::WriteError)
-    expect{ write [1,2,3] }.to raise_error(XDR::WriteError)
-  end
-
-  it "raises a WriteError if a child element is of the wrong type" do
-    expect{ write [nil]      }.to raise_error(XDR::WriteError)
-    expect{ write ["hi"]     }.to raise_error(XDR::WriteError)
-    expect{ write [1,2,"hi"] }.to raise_error(XDR::WriteError)
-  end
-
-  def write(val)
-    io = StringIO.new()
-    subject.write(val, io)
-    io.string
-  end
-end
-
-describe XDR::Array, "#valid?" do
-  subject{ XDR::Array[XDR::Int, 2] }
-
-  it "rejects an empty array" do
-    expect(subject.valid?([])).to be_falsey
-  end
-
-  it "accepts a filled array provided each element passes the child_type validator" do
-    expect(subject.valid?([1,2])).to be_truthy
-    expect(subject.valid?([2,3])).to be_truthy
-  end
-
-  it "rejects a filled array if any element is rejected by the child_type validator" do
-    expect(subject.valid?(["hello", "hello"])).to be_falsey
-    expect(subject.valid?([1, "hello"])).to be_falsey
-    expect(subject.valid?([1, nil])).to be_falsey
-    expect(subject.valid?([nil])).to be_falsey
-  end
-end

data/spec/lib/xdr/bool_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-
-describe XDR::Bool, ".read" do
-  subject{ XDR::Bool }
-
-  let(:false_s) {  "\x00\x00\x00\x00" }
-  let(:true_s)  {  "\x00\x00\x00\x01" }
-  let(:two)     {  "\x00\x00\x00\x02" }
-
-  it "decodes values correctly" do
-    expect(read(false_s)).to eq(false)
-    expect(read(true_s)).to eq(true)
-  end
-
-  it "raises ReadError if the decoded value is not 0 or 1" do
-    expect{ read two }.to raise_error XDR::ReadError
-  end
-
-  def read(str)
-    io = StringIO.new(str)
-    subject.read(io)
-  end
-end
-
-describe XDR::Bool, ".write" do
-  subject{ XDR::Bool }
-
-  it "encodes values correctly" do
-    expect(write false).to eq("\x00\x00\x00\x00")
-    expect(write true).to eq("\x00\x00\x00\x01")
-  end
-
-  it "raises WriteError if the value is boolean" do
-    expect{ write 1 }.to raise_error XDR::WriteError
-    expect{ write "hello" }.to raise_error XDR::WriteError
-  end
-
-  def write(val)
-    io = StringIO.new()
-    subject.write(val, io)
-    io.string
-  end
-end

data/spec/lib/xdr/concerns/converts_to_xdr_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-describe XDR::Concerns::ConvertsToXDR do
-  subject{ UnimplementedConvertible.new }
-
-  it "requires an implementation of #read" do
-    expect{ subject.read(StringIO.new) }.to raise_error(NotImplementedError)
-  end
-
-  it "requires an implementation of #write" do
-    expect{ subject.write(3, StringIO.new) }.to raise_error(NotImplementedError)
-  end
-
-  it "requires an implementation of #valid?" do
-    expect{ subject.valid?(3) }.to raise_error(NotImplementedError)
-  end
-end
-
-describe XDR::Concerns::ConvertsToXDR, "#to_xdr" do
-  subject{ ImplementedConvertible.new }
-
-  it "calls through to write" do
-    expect(subject).to receive(:write).with("hiya", kind_of(StringIO))
-    subject.to_xdr("hiya")
-  end
-
-  context "using an actual xdr type" do
-    subject{ XDR::Opaque.new(4) }
-
-    it "encodes to hex" do
-      r = subject.to_xdr("\x00\x01\x02\x03", "hex")
-      expect(r).to eql("00010203")
-    end
-
-    it "encodes to base64" do
-      r = subject.to_xdr("\x00\x01\x02\x03", "base64")
-      expect(r).to eql("AAECAw==")
-    end
-  end
-end
-
-describe XDR::Concerns::ConvertsToXDR, "#from_xdr" do
-  subject{ ImplementedConvertible.new }
-
-  it "calls through to read" do
-    allow(subject).to receive(:read).and_call_original
-    subject.from_xdr("hiya")
-    expect(subject).to have_received(:read).with(kind_of(StringIO))
-  end
-
-  context "using an actual xdr type" do
-    subject{ XDR::Opaque.new(4) }
-
-    it "decodes from hex" do
-      r = subject.from_xdr("00010203", "hex")
-      expect(r).to eql("\x00\x01\x02\x03")
-    end
-
-    it "decodes from base64" do
-      r = subject.from_xdr("AAECAw==", "base64")
-      expect(r).to eql("\x00\x01\x02\x03")
-    end
-
-    it "raises an ArgumentError if the input is not fully consumed" do
-      expect{ subject.from_xdr("\x00\x00\x00\x00\x00") }.to raise_error(ArgumentError)
-    end
-  end
-end
-
-class UnimplementedConvertible
-  include XDR::Concerns::ConvertsToXDR
-end
-
-class ImplementedConvertible
-  include XDR::Concerns::ConvertsToXDR
-
-  def read(io)
-    read_bytes(io, 4)
-  end
-
-  def write(val, io)
-    io.write(val)
-  end
-
-  def valid?(val)
-    true
-  end
-end

data/spec/lib/xdr/concerns/reads_bytes_spec.rb

@@ -1,57 +0,0 @@
-require 'spec_helper'
-
-class TestReader
-  include XDR::Concerns::ReadsBytes
-  public :read_bytes
-  public :read_zeros
-end
-
-
-describe XDR::Concerns::ReadsBytes, "#read_bytes"  do
-  subject{ TestReader.new }
-
-  it "raises EOFError when the requested length goes beyond the length of the stream" do
-    expect{ read("", 1) }.to raise_error(EOFError)
-    expect{ read("", 2) }.to raise_error(EOFError)
-    expect{ read("", 10) }.to raise_error(EOFError)
-    expect{ read("\x00\x01\x02", 4) }.to raise_error(EOFError)
-    expect{ read("\x00\x01\x02", 10) }.to raise_error(EOFError)
-  end
-
-  it "returns the read data" do
-    expect(read("", 0)).to eq("")
-    expect(read("\x00", 1)).to eq("\x00")
-    expect(read("\x01", 1)).to eq("\x01")
-    expect(read("\x00\x01\x02", 3)).to eq("\x00\x01\x02")
-  end
-
-  def read(str, length)
-    io = StringIO.new(str)
-    subject.read_bytes(io, length)
-  end
-end
-
-
-describe XDR::Concerns::ReadsBytes, "#read_zeros"  do
-  subject{ TestReader.new }
-
-  it "raises XDR::ReadError when the bytes read do not equal zero" do
-    expect{ read("\x01", 1) }.to raise_error(XDR::ReadError)
-  end
-
-  it "succeeds when all the bytes read are zero" do
-    expect{ read("\x00\x00\x00\x00", 1) }.to_not raise_error
-    expect{ read("\x00\x00\x00\x00", 2) }.to_not raise_error
-    expect{ read("\x00\x00\x00\x00", 3) }.to_not raise_error
-    expect{ read("\x00\x00\x00\x00", 4) }.to_not raise_error
-  end
-
-  it "raises EOFError when the requested length goes beyond the length of the stream" do
-    expect{ read("\x00\x00\x00\x00", 5) }.to raise_error(EOFError)
-  end
-
-  def read(str, length)
-    io = StringIO.new(str)
-    subject.read_zeros(io, length)
-  end
-end

data/spec/lib/xdr/double_spec.rb

@@ -1,38 +0,0 @@
-require 'spec_helper'
-
-
-describe XDR::Double, ".read" do
-
-  it "decodes values correctly" do
-    expect(read("\x00\x00\x00\x00\x00\x00\x00\x00")).to eq(0.0)
-    expect(read("\x80\x00\x00\x00\x00\x00\x00\x00")).to eq(-0.0)
-    expect(read("\x3F\xF0\x00\x00\x00\x00\x00\x00")).to eq(1.0)
-    expect(read("\xBF\xF0\x00\x00\x00\x00\x00\x00")).to eq(-1.0)
-  end
-
-  def read(str)
-    io = StringIO.new(str)
-    subject.read(io)
-  end
-end
-
-describe XDR::Double, ".write" do
-  it "encodes values correctly" do
-    expect(write 0.0).to  eq_bytes("\x00\x00\x00\x00\x00\x00\x00\x00")
-    expect(write -0.0).to eq_bytes("\x80\x00\x00\x00\x00\x00\x00\x00")
-    expect(write 1.0).to  eq_bytes("\x3F\xF0\x00\x00\x00\x00\x00\x00")
-    expect(write -1.0).to eq_bytes("\xBF\xF0\x00\x00\x00\x00\x00\x00")
-  end
-
-  it "raises a WriteError when the value is not Float" do
-    expect{ write 3 }.to      raise_error(XDR::WriteError)
-    expect{ write "hi" }.to   raise_error(XDR::WriteError)
-    expect{ write "1.0" }.to  raise_error(XDR::WriteError)
-  end
-
-  def write(val)
-    io = StringIO.new()
-    subject.write(val, io)
-    io.string
-  end
-end