xdr 2.0.0 → 3.0.3

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,31 +0,0 @@
-require 'spec_helper'
-
-class TestReader
-  include XDR::Concerns::ReadsBytes
-  public :read_bytes
-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

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

data/spec/lib/xdr/dsl/enum_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-
-describe XDR::DSL::Enum, "#member" do
-  subject do
-    Class.new(XDR::Enum) do
-      member :one, 1
-      member :two, 2
-    end
-  end
-
-  it "adds to the members collection of the class" do
-    expect(subject.members.length).to eq(2)
-    expect(subject.members[:one]).to eq(subject.one)
-    expect(subject.members[:two]).to eq(subject.two)
-  end
-
-  it "raises ArgumentError if a non-integer value is used" do
-    expect {
-      Class.new(XDR::Enum) do
-        member :one, "hi!"
-      end
-    }.to raise_error(ArgumentError)
-  end
-end
-
-describe XDR::DSL::Enum, "#seal" do
-  subject do
-    Class.new(XDR::Enum) do
-      member :one, 1
-      member :two, 2
-      seal
-    end
-  end
-
-  it "marks the class as sealed" do
-    expect(subject.sealed).to eq(true)
-  end
-
-  it "prevents you from adding members after being sealed" do
-    expect{ subject.member :three, 3 }.to raise_error(ArgumentError)
-  end
-
-end

data/spec/lib/xdr/dsl/struct_spec.rb

@@ -1,29 +0,0 @@
-require 'spec_helper'
-
-
-describe XDR::DSL::Struct, "#attribute" do
-  subject do
-    Class.new(XDR::Struct) do
-      attribute :attr1, XDR::Int
-      attribute :attr2, XDR::String[]
-    end
-  end
-
-
-  it "adds to the fields collection of the class" do
-    expect(subject.fields.length).to eq(2)
-    expect(subject.fields[:attr1]).to eq(XDR::Int)
-    expect(subject.fields[:attr2]).to be_a(XDR::String)
-  end
-
-
-
-  it "raises ArgumentError if a non-convertible type is used" do
-    expect do
-      Class.new(XDR::Struct) do
-        attribute :attr1, String
-      end
-    end.to raise_error(ArgumentError)
-  end
-
-end

data/spec/lib/xdr/dsl/union_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-
-describe XDR::DSL::Union, "#switch" do
-
-  it "allows symbols in switch declarations" do
-    expect do
-      klass = Class.new(XDR::Union) do
-        switch_on ResultType, :type
-        switch :ok
-      end
-
-      klass.new(:ok)
-    end.to_not raise_error
-  end
-
-  class ResultType < XDR::Enum
-    member :ok, 0
-    member :error, 1
-    seal
-  end
-end
-
-describe XDR::DSL::Union, "#switch_on" do
-  klass = nil
-
-  it "allows int types" do
-    expect do
-      klass = Class.new(XDR::Union) do
-        switch_on XDR::Int, :type
-        switch 0
-        switch 1
-      end
-    end.to_not raise_error
-
-    expect{ klass.new(0) }.to_not raise_error
-    expect{ klass.new(1) }.to_not raise_error
-    expect{ klass.new(2) }.to raise_error(XDR::InvalidSwitchError)
-  end
-
-  it "allows unsigned int types" do
-    expect do
-      klass = Class.new(XDR::Union) do
-        switch_on XDR::UnsignedInt, :type
-        switch 0
-        switch 1
-      end
-    end.to_not raise_error
-
-    expect{ klass.new(0) }.to_not raise_error
-    expect{ klass.new(1) }.to_not raise_error
-    expect{ klass.new(2) }.to raise_error(XDR::InvalidSwitchError)
-    expect{ klass.new(-1) }.to raise_error(XDR::InvalidSwitchError)
-  end
-
-  it "allows bool types", :focus do
-    klass = nil
-
-    expect do
-      klass = Class.new(XDR::Union) do
-        switch_on XDR::Bool, :type
-        switch true
-      end
-    end.to_not raise_error
-
-    expect{ klass.new(true) }.to_not raise_error
-    expect{ klass.new(false) }.to raise_error(XDR::InvalidSwitchError)
-  end
-end

data/spec/lib/xdr/enum_spec.rb

@@ -1,70 +0,0 @@
-require 'spec_helper'
-
-class TestColor < XDR::Enum
-  member :red, 0
-  member :green, 1
-  member :even_more_green, 3
-
-  seal
-end
-
-describe XDR::Enum, ".read" do
-  let(:zero) { "\x00\x00\x00\x00" }
-  let(:one) { "\x00\x00\x00\x01" }
-  let(:two) { "\x00\x00\x00\x02" }
-
-  subject{ TestColor }
-
-  it "decodes values correctly" do
-    expect( read zero ).to eq(TestColor.red)
-    expect( read one ).to eq(TestColor.green)
-  end
-
-  it "raises EnumValueError if the decoded value is not in the defined constants" do
-    expect{ read two }.to raise_error XDR::EnumValueError
-  end
-
-  def read(str)
-    io = StringIO.new(str)
-    subject.read(io)
-  end
-end
-
-describe XDR::Enum, ".write" do
-  subject{ TestColor }
-
-  it "encodes values correctly" do
-    expect( write TestColor.red ).to   eq("\x00\x00\x00\x00")
-    expect( write TestColor.green ).to eq("\x00\x00\x00\x01")
-  end
-
-  it "raises WriteError if value isn't a member" do
-    expect{ write 0 }.to raise_error XDR::WriteError
-    expect{ write 1 }.to raise_error XDR::WriteError
-  end
-
-  def write(val)
-    io = StringIO.new()
-    subject.write(val, io)
-    io.string
-  end
-end
-
-describe XDR::Enum, ".from_name" do
-  subject{ TestColor }
-
-  it "returns the correct value" do
-    expect(subject.from_name("red")).to eq(TestColor.red)
-  end
-
-  it "allows various casings, strings or symbols" do
-    expect(subject.from_name("even_more_green")).to eq(TestColor.even_more_green)
-    expect(subject.from_name("EVEN_MORE_GREEN")).to eq(TestColor.even_more_green)
-    expect(subject.from_name(:even_more_green)).to eq(TestColor.even_more_green)
-    expect(subject.from_name(:EVEN_MORE_GREEN)).to eq(TestColor.even_more_green)
-  end
-
-  it "raises EnumNameError when the name is not a member" do
-    expect{ subject.from_name("chartreuse")}.to raise_error(XDR::EnumNameError)
-  end
-end

data/spec/lib/xdr/float_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-
-describe XDR::Float, ".read" do
-  it "decodes values correctly" do
-    expect(read("\x00\x00\x00\x00")).to eq(0.0)
-    expect(read("\x80\x00\x00\x00")).to eq(-0.0)
-    expect(read("\x3F\x80\x00\x00")).to eq(1.0)
-    expect(read("\xBF\x80\x00\x00")).to eq(-1.0)
-  end
-
-  def read(str)
-    io = StringIO.new(str)
-    subject.read(io)
-  end
-end
-
-describe XDR::Float, ".write" do
-  it "encodes values correctly" do
-    expect(write(0.0)).to eq_bytes("\x00\x00\x00\x00")
-    expect(write(-0.0)).to eq_bytes("\x80\x00\x00\x00")
-    expect(write(1.0)).to eq_bytes("\x3F\x80\x00\x00")
-    expect(write(-1.0)).to eq_bytes("\xBF\x80\x00\x00")
-  end
-
-  it "raises a WriteError when the value is not Float" do
-    expect{ write 3 }.to raise_error(XDR::WriteError)
-    expect{ write "hello" }.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

data/spec/lib/xdr/hyper_spec.rb

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-
-describe XDR::Hyper, ".read" do
-
-  it "decodes values correctly" do
-    expect(read("\x00\x00\x00\x00\x00\x00\x00\x00")).to eq(0)
-    expect(read("\x00\x00\x00\x00\x00\x00\x00\x01")).to eq(1)
-    expect(read("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF")).to eq(-1)
-    expect(read("\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF")).to eq(2**63 - 1)
-    expect(read("\x80\x00\x00\x00\x00\x00\x00\x00")).to eq(-(2**63))
-  end
-
-  def read(str)
-    io = StringIO.new(str)
-    subject.read(io)
-  end
-end
-
-describe XDR::Hyper, ".write" do
-
-  it "decodes values correctly" do
-    expect(write 0).to eq_bytes("\x00\x00\x00\x00\x00\x00\x00\x00")
-    expect(write 1).to eq_bytes("\x00\x00\x00\x00\x00\x00\x00\x01")
-    expect(write -1).to eq_bytes("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF")
-    expect(write 2**63 - 1).to eq_bytes("\x7F\xFF\xFF\xFF\xFF\xFF\xFF\xFF")
-    expect(write -(2**63)).to eq_bytes("\x80\x00\x00\x00\x00\x00\x00\x00")
-  end
-
-  it "raises WriteError when an Integer isn't passed" do
-    expect{ write 1.0 }.to raise_error(XDR::WriteError)
-    expect{ write "hi" }.to raise_error(XDR::WriteError)
-  end
-
-  def write(val)
-    io = StringIO.new()
-    subject.write(val, io)
-    io.string
-  end
-end