payshares-xdr 0.0.2

data/lib/xdr.rb

@@ -0,0 +1,73 @@
+require "xdr/version"
+require "active_model"
+require "active_support/concern"
+require "active_support/dependencies/autoload"
+require "active_support/core_ext/object/blank"
+require "active_support/core_ext/object/try"
+require "active_support/core_ext/module/attribute_accessors"
+require "active_support/core_ext/class/attribute"
+require "active_support/core_ext/hash/indifferent_access"
+require "active_support/core_ext/string/inflections"
+require "active_support/logger"
+require "active_support/ordered_hash"
+require "backports/2.1.0"
+
+module XDR
+  extend ActiveSupport::Autoload
+
+  MAX_SIZE = 2**32 - 1
+
+  autoload :Namespace
+  autoload :RPC
+  autoload :DSL
+
+  # Compound Type
+  autoload :Struct
+  autoload :Union
+  autoload :Enum
+
+  # Primitive Types
+  autoload :Array
+  autoload :Option
+  autoload :Int
+  autoload :UnsignedInt
+  autoload :Hyper
+  autoload :UnsignedHyper
+  autoload :Float
+  autoload :Double
+  autoload :Quadruple
+  autoload :Bool
+  autoload :Opaque
+  autoload :VarOpaque
+  autoload :VarArray
+  autoload :String
+  autoload :Void
+
+  # Validators
+  autoload :StructValidator
+  autoload :UnionValidator
+
+  module Concerns
+    extend ActiveSupport::Autoload
+    autoload :ReadsBytes
+    autoload :ConvertsToXDR
+    autoload :IntegerConverter
+    autoload :FloatConverter
+    autoload :StringConverter
+    autoload :ArrayConverter
+  end
+
+  class Error < StandardError ; end
+  class ReadError < Error ; end
+  class EnumValueError < ReadError ; end
+  class EnumNameError < ReadError ; end
+  class WriteError < Error ; end
+
+  class InvalidSwitchError < Error ; end
+  class InvalidValueError < Error ; end
+  class ArmNotSetError < Error ; end
+
+  mattr_accessor :logger
+  self.logger = ActiveSupport::Logger.new(STDOUT)
+  self.logger.level = Logger::WARN
+end

data/lib/xdr/array.rb

@@ -0,0 +1,28 @@
+class XDR::Array
+  include XDR::Concerns::ConvertsToXDR
+  include XDR::Concerns::ArrayConverter
+
+  singleton_class.send(:alias_method, :[], :new)
+
+  def initialize(child_type, length)
+    @child_type = child_type
+    @length     = length
+  end
+
+  def write(val, io)
+    raise XDR::WriteError, "val is not array" unless val.is_a?(Array)
+    raise XDR::WriteError, "array must be #{@length} long, was #{val.length}" if val.length != @length
+
+    @length.times do |i|
+      @child_type.write val[i], io
+    end
+  end
+
+  def read(io)
+    @length.times.map{ @child_type.read(io) }
+  end
+
+  def valid?(val)
+    super(val) && val.length == @length
+  end
+end

data/lib/xdr/bool.rb

@@ -0,0 +1,24 @@
+module XDR::Bool
+  extend XDR::Concerns::ConvertsToXDR
+
+  def self.write(val, io)
+    case val
+    when true  ; XDR::Int.write(1, io)
+    when false ; XDR::Int.write(0, io)
+    else ; raise XDR::WriteError, "Invalid bool value: #{val}"
+    end
+  end
+
+  def self.read(io)
+    val = XDR::Int.read(io)
+    case val
+    when 0 ; false
+    when 1 ; true
+    else ; raise XDR::ReadError, "Invalid bool value: #{val}"
+    end
+  end
+
+  def self.valid?(val)
+    val == true || val == false
+  end
+end

data/lib/xdr/concerns/array_converter.rb

@@ -0,0 +1,5 @@
+module XDR::Concerns::ArrayConverter
+  def valid?(val)
+    val.is_a?(Array) && val.all?{|v| @child_type.valid?(v)}
+  end
+end

data/lib/xdr/concerns/converts_to_xdr.rb

@@ -0,0 +1,67 @@
+module XDR::Concerns::ConvertsToXDR
+  include XDR::Concerns::ReadsBytes
+
+  # 
+  # Serialized the provided `val` to xdr and writes it to `io`
+  # 
+  # @param val [Object] The object to serialize
+  # @param io [IO] an IO object to write to
+  # 
+  def write(val, io)
+    raise NotImplementedError, "implement in including class"
+  end
+
+  # 
+  # Reads from the provided IO an instance of the implementing class
+  # @param io [IO] the io to read from
+  # 
+  # @return [Object] the deserialized value
+  def read(io)
+    raise NotImplementedError, "implement in including class"
+  end
+
+  # 
+  # Returns true if the value provided is compatible with this serializer class
+  # 
+  # @param value [Object] the value to test
+  # 
+  # @return [Boolean] true if valid, false otherwise
+  def valid?(value)
+    raise NotImplementedError, "implement in including class"
+  end
+  
+  # 
+  # Serialized the provided val to xdr, returning a string
+  # of the serialized data
+  # 
+  # @param val [Object] the value to serialize
+  # 
+  # @return [String] the produced bytes
+  def to_xdr(val)
+    StringIO.
+      new.
+      tap{|io| write(val, io)}.
+      string.force_encoding("ASCII-8BIT")
+  end
+  
+  # 
+  # Deserializes an object from the provided string of bytes
+  # 
+  # @param string [String] the bytes to read from
+  # 
+  # @return [Object] the deserialized value
+  def from_xdr(string)
+    io = StringIO.new(string)
+    read(io)
+  end
+
+  private
+  def padding_for(length)
+    case length % 4
+    when 0 ; 0
+    when 1 ; 3
+    when 2 ; 2
+    when 3 ; 1
+    end
+  end
+end

data/lib/xdr/concerns/float_converter.rb

@@ -0,0 +1,5 @@
+module XDR::Concerns::FloatConverter
+  def valid?(val)
+    val.is_a?(Float)
+  end
+end

data/lib/xdr/concerns/integer_converter.rb

@@ -0,0 +1,5 @@
+module XDR::Concerns::IntegerConverter
+  def valid?(val)
+    val.is_a?(Integer)
+  end
+end

data/lib/xdr/concerns/reads_bytes.rb

@@ -0,0 +1,8 @@
+module XDR::Concerns::ReadsBytes
+  private
+  def read_bytes(io, length)
+    io.read(length).tap do |bytes|
+      raise EOFError if bytes.nil? || bytes.length != length
+    end
+  end
+end

data/lib/xdr/concerns/string_converter.rb

@@ -0,0 +1,5 @@
+module XDR::Concerns::StringConverter
+  def valid?(val)
+    val.is_a?(String)
+  end
+end

data/lib/xdr/double.rb

@@ -0,0 +1,14 @@
+module XDR::Double
+  extend XDR::Concerns::ConvertsToXDR
+  extend XDR::Concerns::FloatConverter
+
+  def self.write(val, io)
+    raise XDR::WriteError unless valid?(val)
+    io.write [val].pack("G")
+  end
+
+  def self.read(io)
+    read_bytes(io, 8).unpack("G").first
+  end
+
+end

data/lib/xdr/dsl.rb

@@ -0,0 +1,7 @@
+module XDR::DSL
+  extend ActiveSupport::Autoload
+
+  autoload :Struct
+  autoload :Union
+  autoload :Enum
+end

data/lib/xdr/dsl/enum.rb

@@ -0,0 +1,24 @@
+module XDR::DSL::Enum
+
+  def member(name, value)
+    raise ArgumentError, "#{self} is sealed" if self.sealed
+    raise ArgumentError, "#{value} is not Fixnum" unless value.is_a?(Fixnum)
+    raise ArgumentError, "#{value} is already used" unless 
+
+    name = name.to_s.underscore
+
+    instance = new(name, value)
+    self.members = self.members.merge(name => instance)
+    self.by_value = self.by_value.merge(instance.value => instance)
+
+    class_eval <<-EOS, __FILE__, __LINE__
+      def self.#{name}
+        members["#{name}"]
+      end
+    EOS
+  end
+
+  def seal
+    self.sealed = true
+  end
+end

data/lib/xdr/dsl/struct.rb

@@ -0,0 +1,13 @@
+module XDR::DSL::Struct
+  def attribute(name, type)
+
+    unless type.is_a?(XDR::Concerns::ConvertsToXDR)
+      raise ArgumentError, "#{type} does not convert to xdr" 
+    end
+
+    self.fields = self.fields.merge(name => type)
+
+    attr_accessor name
+    define_attribute_methods name
+  end
+end

data/lib/xdr/dsl/union.rb

@@ -0,0 +1,32 @@
+module XDR::DSL::Union
+  def switch_on(type, name)
+    raise ArgumentError if self.switch_type.present?
+    self.switch_type = type
+    self.switch_name = name
+
+    alias_method name, :switch
+  end
+
+  def switch(switch, arm=nil)
+    raise ArgumentError, "`switch_on` not defined yet" if self.switch_type.nil?
+
+    switch = normalize_switch(switch)
+    self.switches = self.switches.merge(switch => arm)
+  end
+
+  def attribute(name, type)
+    raise ArgumentError, "#{type} does not convert to xdr" unless type.is_a?(XDR::Concerns::ConvertsToXDR)
+
+    self.arms = self.arms.merge(name => type)
+    define_attribute_methods name
+  end
+
+  private
+  def normalize_switch(switch)
+    case switch
+    when self.switch_type ; switch
+    when :default ;         switch
+    else ;                  self.switch_type.from_name(switch)
+    end
+  end
+end

data/lib/xdr/enum.rb

@@ -0,0 +1,48 @@
+class XDR::Enum
+  extend XDR::Concerns::ConvertsToXDR
+  extend XDR::DSL::Enum
+
+  class_attribute :members
+  class_attribute :by_value
+  class_attribute :sealed
+  self.members = ActiveSupport::OrderedHash.new.with_indifferent_access
+  self.by_value = ActiveSupport::OrderedHash.new
+  self.sealed  = false
+
+  def self.write(val, io)
+    raise XDR::WriteError, "Invalid enum value: #{val.inspect}" unless val.is_a?(self)
+
+    XDR::Int.write(val.value, io)
+  end
+
+  def self.read(io)
+    value = XDR::Int.read(io)
+    by_value[value].tap do |result|
+      raise XDR::EnumValueError, "Unknown #{name} member: #{value}" if result.blank?
+    end
+  end
+  
+  def self.valid?(val)
+    val.is_a?(self)
+  end
+
+  def self.from_name(name)
+    normalized = name.to_s.underscore
+    members[normalized].tap do |r|      
+      raise XDR::EnumNameError, "#{name} is not a member of #{self.name}" if r.blank?
+    end
+  end
+
+  attr_reader :name
+  attr_reader :value
+
+  def initialize(name, value)
+    raise ArgumentError, "#{self.class} is sealed" if self.sealed
+    @name  = name
+    @value = value
+  end
+
+  def to_s
+    "#{self.class.name}.#{@name}(#{@value})"
+  end
+end

data/lib/xdr/float.rb

@@ -0,0 +1,14 @@
+module XDR::Float
+  extend XDR::Concerns::ConvertsToXDR
+  extend XDR::Concerns::FloatConverter
+
+  def self.write(val, io)
+    raise XDR::WriteError unless val.is_a?(Float)
+    io.write [val].pack("g")
+  end
+
+  def self.read(io)
+    read_bytes(io, 4).unpack("g").first
+  end
+
+end

data/lib/xdr/hyper.rb

@@ -0,0 +1,14 @@
+module XDR::Hyper
+  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/int.rb

@@ -0,0 +1,14 @@
+module XDR::Int
+  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/namespace.rb

@@ -0,0 +1,26 @@
+# 
+# A thin wrapper around ActiveSupport::Autoload configured to always eager_load
+# a child.  By calling `load_all!` on the namespace module, all children will
+# be eager loaded, allowing us to more easily operate in a multi-threaded
+# environment.
+# 
+module XDR::Namespace
+  extend ActiveSupport::Concern
+
+  included do
+    extend ActiveSupport::Autoload
+  end
+
+  module ClassMethods
+    def load_all!
+      constants.each do |const_name|
+        begin
+          const = const_get const_name
+          const.public_send :load_all! if const.respond_to? :load_all!
+        rescue NameError => e
+          raise e unless e.message =~ /uninitialized constant #{const_name}/
+        end
+      end
+    end
+  end
+end