payshares-xdr 0.0.2

data/lib/xdr/opaque.rb

@@ -0,0 +1,28 @@
+class XDR::Opaque
+  include XDR::Concerns::ConvertsToXDR
+  include XDR::Concerns::StringConverter
+
+  singleton_class.send(:alias_method, :[], :new)
+
+  def initialize(length)
+    @length = length
+    @padding = padding_for length
+  end
+
+  def read(io)
+    # read and return @length bytes
+    # throw away @padding bytes
+    read_bytes(io, @length).tap{ read_bytes(io, @padding) }
+  end
+
+  def write(val,io)
+    length = val.bytesize
+    
+    if val.length != @length
+      raise XDR::WriteError, "Value length is #{length}, must be #{@length}" 
+    end
+
+    io.write val
+    io.write "\x00" * @padding
+  end
+end

data/lib/xdr/option.rb

@@ -0,0 +1,30 @@
+class XDR::Option
+  include XDR::Concerns::ConvertsToXDR
+
+  singleton_class.send(:alias_method, :[], :new)
+
+  attr_reader :child_type
+
+  def initialize(child_type)
+    #TODO, raise an error if child_type is not ConvertToXDR
+    @child_type = child_type
+  end
+
+  def write(val, io)
+    if val.present?
+      XDR::Bool.write(true, io)
+      @child_type.write(val, io)
+    else
+      XDR::Bool.write(false, io)
+    end
+  end
+
+  def read(io)
+    present = XDR::Bool.read(io)
+    @child_type.read(io) if present
+  end
+
+  def valid?(val)
+    val.nil? || @child_type.valid?(val)
+  end
+end

data/lib/xdr/quadruple.rb

@@ -0,0 +1,5 @@
+module XDR::Quadruple
+  extend XDR::Concerns::ConvertsToXDR
+
+  # No support for quads, so we don't overide read/write
+end

data/lib/xdr/rpc.rb

@@ -0,0 +1,6 @@
+module XDR::RPC
+  extend ActiveSupport::Autoload
+
+  autoload :Record
+  autoload :RecordReader
+end

data/lib/xdr/rpc/record.rb

@@ -0,0 +1,7 @@
+XDR::RPC::Record = Struct.new(:last, :length, :content)
+
+XDR::RPC::Record.class_eval do
+  def last?
+    self.last
+  end
+end

data/lib/xdr/rpc/record_reader.rb

@@ -0,0 +1,16 @@
+class XDR::RPC::RecordReader
+  include XDR::Concerns::ReadsBytes
+
+  LAST_MASK   = 0x80000000
+  LENGTH_MASK = 0x7FFFFFFF
+
+  def read(io)
+    header      = read_bytes(io, 4).unpack("L>").first
+    length      = header & LENGTH_MASK
+    last        = (header & LAST_MASK) > 0
+    raw_content = read_bytes(io, length)
+    content     = StringIO.new(raw_content)
+    
+    XDR::RPC::Record.new(last, length, content)
+  end
+end

data/lib/xdr/string.rb

@@ -0,0 +1,36 @@
+class XDR::String
+  include XDR::Concerns::ConvertsToXDR
+  include XDR::Concerns::StringConverter
+
+  singleton_class.send(:alias_method, :[], :new)
+  
+  def initialize(length=XDR::MAX_SIZE)
+    @length = length
+  end
+
+  def write(val, io)
+    length = val.bytesize
+
+    if length > @length
+      raise XDR::WriteError, "Value length #{length} exceeds max #{@length}"
+    end
+
+    XDR::Int.write(length, io)
+    io.write val
+    io.write "\x00" * padding_for(length)
+  end
+
+  def read(io)
+    length = XDR::Int.read(io)
+
+    if length > @length
+      raise XDR::ReadError, "String length #{length} is greater than max"
+    end
+
+    padding = padding_for length
+
+    # read and return length bytes
+    # throw away padding bytes
+    read_bytes(io, length).tap{ read_bytes(io, padding) }
+  end
+end

data/lib/xdr/struct.rb

@@ -0,0 +1,51 @@
+require 'base64'
+
+class XDR::Struct
+  include ActiveModel::Model
+  include ActiveModel::AttributeMethods
+
+  extend XDR::Concerns::ConvertsToXDR
+  extend XDR::DSL::Struct
+
+  class_attribute :fields
+  self.fields = ActiveSupport::OrderedHash.new
+
+  validates_with XDR::StructValidator
+
+  def self.read(io)
+    new.tap do |result|
+      fields.each do |name, type|
+        result.public_send("#{name}=", type.read(io))
+      end
+    end
+  end
+
+  def self.write(val, io)
+    fields.each do |name, type|
+      field_val = val.public_send(name)
+      type.write(field_val, io)
+    end
+  end
+  
+  def self.valid?(val)
+    val.is_a?(self)
+  end
+
+  # 
+  # Serializes struct to xdr, return a string of bytes
+  # 
+  # @param format=:raw [Symbol] The encoding used for the bytes produces, one of (:raw, :hex, :base64)
+  # 
+  # @return [String] The encoded bytes of this struct
+  def to_xdr(format=:raw)
+    raw = self.class.to_xdr(self)
+
+    case format
+    when :raw ;     raw
+    when :hex ;     raw.unpack("H*").first
+    when :base64 ;  Base64.strict_encode64(raw)
+    else ; 
+      raise ArgumentError, "Invalid format #{format.inspect}; must be :raw, :hex, or :base64"
+    end
+  end
+end

data/lib/xdr/struct_validator.rb

@@ -0,0 +1,6 @@
+class XDR::StructValidator < ActiveModel::Validator
+  def validate(struct)
+    # validate each field
+    # TODO
+  end
+end

data/lib/xdr/union.rb

@@ -0,0 +1,101 @@
+class XDR::Union
+  include ActiveModel::Model
+  include ActiveModel::AttributeMethods
+
+  extend XDR::Concerns::ConvertsToXDR
+  extend XDR::DSL::Union
+
+
+  class_attribute :arms
+  class_attribute :switches
+  class_attribute :switch_type
+  class_attribute :switch_name
+  attr_reader     :switch
+  attr_reader     :arm
+
+  self.arms        = ActiveSupport::OrderedHash.new
+  self.switches    = ActiveSupport::OrderedHash.new
+  self.switch_type = nil
+  self.switch_name = nil
+
+  attribute_method_suffix '!'
+
+  def self.arm_for_switch(switch)
+    raise XDR::InvalidSwitchError unless switch.is_a?(switch_type)
+
+    result = switches.fetch(switch, :switch_not_found)
+    result = switches.fetch(:default, :switch_not_found) if result == :switch_not_found
+
+    if result == :switch_not_found
+      raise XDR::InvalidSwitchError, "Bad switch: #{switch}"
+    end
+
+    result
+  end
+
+  def self.read(io)
+    switch   = switch_type.read(io)
+    arm      = arm_for_switch(switch)
+    arm_type = arms[arm] || XDR::Void
+    value    = arm_type.read(io)
+    new(switch, value)
+  end
+
+  def self.write(val, io)
+    switch_type.write(val.switch, io)
+    arm_type = arms[val.arm] || XDR::Void
+    arm_type.write(val.get,io)
+  end
+
+  def self.valid?(val)
+    val.is_a?(self)
+  end
+
+  def initialize(switch=nil, value=:void)
+    @switch   = nil
+    @arm      = nil
+    @value    = nil
+    set(switch, value) if switch
+  end
+
+  def to_xdr
+    self.class.to_xdr self
+  end
+
+  def set(switch, value=:void)
+    @switch = switch.is_a?(switch_type) ? switch : switch_type.from_name(switch)
+    @arm    = self.class.arm_for_switch @switch
+
+    raise XDR::InvalidValueError unless valid_for_arm_type(value, @arm)
+
+    @value = value
+  rescue XDR::EnumNameError
+    raise XDR::InvalidSwitchError, "Bad switch: #{switch}"
+  end
+
+  def value
+    @value unless @value == :void
+  end
+
+  alias get value
+
+  def attribute!(attr)
+    if @arm.to_s != attr
+      raise XDR::ArmNotSetError, "#{attr} is not the set arm"
+    end
+
+    get
+  end
+
+  private
+  def valid_for_arm_type(value, arm)
+    arm_type = arms[@arm]
+
+    return value == :void if arm_type.nil?
+
+    arm_type.valid?(value)
+  end
+end
+
+
+

data/lib/xdr/union_validator.rb

@@ -0,0 +1,7 @@
+class XDR::UnionValidator < ActiveModel::Validator
+  def validate(union)
+    # validate a discriminant is set
+    # validate the arm is compatible with the set discriminant
+    # TODO
+  end
+end

data/lib/xdr/unsigned_hyper.rb

@@ -0,0 +1,14 @@
+module XDR::UnsignedHyper
+  extend XDR::Concerns::ConvertsToXDR
+  extend XDR::Concerns::IntegerConverter
+
+  def self.write(val, io)
+    raise XDR::WriteError, "val is not Integer" unless val.is_a?(Integer)
+    # TODO: check bounds
+    io.write [val].pack("Q>")
+  end
+
+  def self.read(io)
+    read_bytes(io, 8).unpack("Q>").first
+  end
+end

data/lib/xdr/unsigned_int.rb

@@ -0,0 +1,14 @@
+module XDR::UnsignedInt
+  extend XDR::Concerns::ConvertsToXDR
+  extend XDR::Concerns::IntegerConverter
+
+  def self.write(val, io)
+    raise XDR::WriteError, "val is not Integer" unless val.is_a?(Integer)
+    # TODO: check bounds
+    io.write [val].pack("L>")
+  end
+
+  def self.read(io)
+    read_bytes(io, 4).unpack("L>").first
+  end
+end

data/lib/xdr/var_array.rb

@@ -0,0 +1,38 @@
+class XDR::VarArray
+  include XDR::Concerns::ConvertsToXDR
+  include XDR::Concerns::ArrayConverter
+
+  singleton_class.send(:alias_method, :[], :new)
+
+  def initialize(child_type, length=XDR::MAX_SIZE)
+    @child_type   = child_type
+    @length = length
+  end
+
+  def write(val, io)
+    length = val.length
+
+    if length > @length
+      raise XDR::WriteError, "Value length #{length} exceeds max #{@length}"
+    end
+
+    XDR::Int.write(length, io)
+    val.each do |member|
+      @child_type.write member, io
+    end
+  end
+
+  def read(io)
+    length = XDR::Int.read(io)
+
+    if length > @length
+      raise XDR::ReadError, "VarArray length #{length} is greater than max #{@length}"
+    end
+
+    length.times.map{ @child_type.read(io) }
+  end
+
+  def valid?(val)
+    super(val) && val.length <= @length
+  end
+end

data/lib/xdr/var_opaque.rb

@@ -0,0 +1,36 @@
+class XDR::VarOpaque
+  include XDR::Concerns::ConvertsToXDR
+  include XDR::Concerns::StringConverter
+
+  singleton_class.send(:alias_method, :[], :new)
+
+  def initialize(length=XDR::MAX_SIZE)
+    @length = length
+  end
+
+  def write(val, io)
+    length = val.bytesize
+
+    if length > @length
+      raise XDR::WriteError, "Value length #{length} exceeds max #{@length}"
+    end
+
+    XDR::Int.write(length, io)
+    io.write val
+    io.write "\x00" * padding_for(length)
+  end
+
+  def read(io)
+    length = XDR::Int.read(io)
+
+    if length > @length
+      raise XDR::ReadError, "VarOpaque length #{length}"
+    end
+
+    padding = padding_for length
+
+    # read and return length bytes
+    # throw away padding bytes
+    read_bytes(io, length).tap{ read_bytes(io, padding) }
+  end
+end

data/lib/xdr/version.rb

@@ -0,0 +1,3 @@
+module XDR
+  VERSION = "0.0.2"
+end

data/lib/xdr/void.rb

@@ -0,0 +1,14 @@
+module XDR::Void
+  extend XDR::Concerns::ConvertsToXDR
+
+  def self.write(val, io)
+  end
+
+  def self.read(io)
+    :void
+  end
+
+  def self.valid?(val)
+    val == :void
+  end
+end

data/payshares-xdr.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'xdr/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "payshares-xdr"
+  spec.version       = XDR::VERSION
+  spec.authors       = ["Kedia"]
+  spec.email         = ["support@payshares.org"]
+  spec.summary       = %q{Payshares XDR Helper Library}
+  spec.homepage      = "https://github.com/payshares/ruby-payshares-xdr"
+  spec.license       = "Apache 2.0"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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", "4.1.9"
+  spec.add_dependency "activemodel", "4.1.9"
+  spec.add_dependency "backports", "3.6.4"
+
+  spec.add_development_dependency "bundler", "1.17.3"
+  spec.add_development_dependency "rake", "10.4.2"
+  spec.add_development_dependency "rspec", "3.2.0"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "simplecov"
+end