sparsam 0.1.4

data/lib/sparsam.rb

@@ -0,0 +1,10 @@
+# -*- coding: UTF-8 -*-
+require 'sparsam_native'
+
+require 'sparsam/types'
+require 'sparsam/exceptions'
+require 'sparsam/struct'
+require 'sparsam/union'
+require 'sparsam/deserializer'
+
+Sparsam.init!

data/lib/sparsam/base_class.rb

@@ -0,0 +1,97 @@
+require 'set'
+require 'sparsam/types'
+
+module Sparsam
+  class BaseClass
+    class AccessorNames < Struct.new(:reader, :writer); end
+
+    def self.generate_field_syms(klass)
+      field_syms = {}
+      klass::FIELDS.each do |_, field_info|
+        name = field_info[:name].to_sym
+        accessors = AccessorNames.new(name, :"#{name}=")
+        field_syms[name] = accessors
+        field_syms[name.to_s] = accessors
+      end
+
+      klass.const_set(
+        :FIELD_SYMS,
+        field_syms
+      )
+    end
+
+    def self.generate_accessors(klass)
+      klass::FIELDS.each do |field_key, field_info|
+        field_accessor(klass, field_key, field_info)
+        qmark_isset_method(klass, field_info)
+      end
+    end
+
+    # TODO(Ben Hughes): Do we ever use those, these are an unexpected
+    # definition of predicate accessors
+    def self.qmark_isset_method(klass, field_info)
+      field_name = field_info[:name]
+
+      klass.class_eval(<<-EOF, __FILE__, __LINE__)
+        def #{field_name}?
+          !#{field_name}.nil?
+        end
+      EOF
+    end
+
+    def self.generate_default_values(klass)
+      fields_with_default_values = {}
+      klass::FIELDS.each do |fid, field_def|
+        unless field_def[:default].nil?
+          fields_with_default_values[field_def[:name]] = field_def[:default].freeze
+        end
+      end
+
+      if fields_with_default_values.empty?
+        klass.const_set(
+          :DEFAULT_VALUES,
+          nil
+        )
+      else
+        klass.const_set(
+          :DEFAULT_VALUES,
+          fields_with_default_values
+        )
+      end
+    end
+
+    def self.init_thrift_struct(klass)
+      generate_accessors(klass)
+      generate_field_syms(klass)
+      Sparsam.cache_fields(klass)
+      generate_default_values(klass)
+      klass.class_eval(<<-EOF, __FILE__, __LINE__)
+        def struct_fields
+          FIELDS
+        end
+      EOF
+    end
+
+    def serialize(prot = Sparsam::CompactProtocol)
+      validate
+      s = Sparsam::Serializer.new(prot, "")
+      s.serialize(self.class, self)
+    end
+
+    def validate(mode = Sparsam::NORMAL)
+      Sparsam.validate(self.class, self, mode)
+    end
+
+    private
+
+    def name_to_accessors(name)
+      self.class::FIELD_SYMS[name]
+    end
+
+    def each_field
+      struct_fields.each do |fid, data|
+        yield fid, data
+      end
+    end
+  end
+end

data/lib/sparsam/deserializer.rb

@@ -0,0 +1,8 @@
+module Sparsam
+  module Deserializer
+    def self.deserialize(klass, serialized_string, prot = Sparsam::CompactProtocol)
+      s = Sparsam::Serializer.new(prot, serialized_string)
+      s.deserialize(klass)
+    end
+  end
+end

data/lib/sparsam/exceptions.rb

@@ -0,0 +1,33 @@
+# -*- coding: UTF-8 -*-
+
+module Sparsam
+  class Exception < StandardError
+    def initialize(msg)
+      super
+    end
+  end
+
+  class MissingMandatory < Exception
+    def initialize(msg)
+      super
+    end
+  end
+
+  class TypeMismatch < Exception
+    def initialize(msg)
+      super
+    end
+  end
+
+  class UnionException < Exception
+    def initialize(msg)
+      super
+    end
+  end
+
+  class UnknownTypeException < Exception
+    def initialize(msg)
+      super
+    end
+  end
+end

data/lib/sparsam/struct.rb

@@ -0,0 +1,45 @@
+# -*- coding: UTF-8 -*-
+require 'sparsam/base_class'
+
+module Sparsam
+  class Struct < ::Sparsam::BaseClass
+    include ::Sparsam::StructInitialization
+
+    def ==(other)
+      return true if other.equal?(self)
+      return false unless other.instance_of?(self.class)
+
+      each_field do |fid, info|
+        reader = name_to_accessors(info[:name]).reader
+        return false unless send(reader) == other.send(reader)
+      end
+    end
+    alias_method :eql?, :==
+
+    def self.field_accessor(klass, field_key, field_info)
+      field_name = field_info[:name]
+      klass.class_eval(<<-EOF, __FILE__, __LINE__)
+        attr_accessor :'#{field_name}'
+      EOF
+    end
+
+    private
+
+    def assign_defaults(defaults)
+      defaults.each do |name, default_value|
+        accessors = name_to_accessors(name)
+        send(accessors.writer, default_value)
+      end
+    end
+
+    def assign_from_arg(d)
+      d.each do |name, value|
+        accessors = name_to_accessors(name)
+        unless accessors
+          raise Sparsam::Exception, "Unknown key given to #{self.class}.new: #{name}"
+        end
+        send(accessors.writer, value)
+      end
+    end
+  end
+end

data/lib/sparsam/types.rb

@@ -0,0 +1,108 @@
+# -*- coding: UTF-8 -*-
+require 'set'
+require 'sparsam/exceptions'
+
+module Sparsam
+  module Types
+    STOP = 0
+    VOID = 1
+    BOOL = 2
+    BYTE = 3
+    DOUBLE = 4
+    I16 = 6
+    I32 = 8
+    I64 = 10
+    STRING = 11
+    STRUCT = 12
+    MAP = 13
+    SET = 14
+    LIST = 15
+
+    COLLECTIONS = Set.new([
+      SET,
+      LIST,
+      MAP,
+    ]).freeze
+  end
+
+  # Deprecated type checking
+
+  def self.check_type(value, field, name, skip_nil = true)
+    return if value.nil? && skip_nil
+
+    valid =
+      case field[:type]
+      when Types::VOID
+        nil === value
+      when Types::BOOL
+        true === value || false === value
+      when Types::BYTE, Types::I16, Types::I32, Types::I64
+        Integer === value
+      when Types::DOUBLE
+        Float === value
+      when Types::STRING
+        String === value
+      when Types::STRUCT
+        Struct === value || Union === value
+      when Types::MAP
+        Hash === value
+      when Types::SET
+        Set === value
+      when Types::LIST
+        Array === value
+      else
+        false
+      end
+
+    unless valid
+      raise TypeMismatch, "Expected #{type_name(field[:type])}, " \
+        "received #{value.class} for field #{name}"
+    end
+
+    # check elements now
+    case field[:type]
+    when Types::MAP
+      # This is still allocations per MAP, but better than per map entry
+      key_str = "#{name}.key"
+      value_str = "#{name}.value"
+
+      value.each_pair do |k, v|
+        check_type(k, field[:key], key_str, false)
+        check_type(v, field[:value], value_str, false)
+      end
+    when Types::SET, Types::LIST
+      element_str = "#{name}.element"
+
+      value.each do |el|
+        check_type(el, field[:element], element_str, false)
+      end
+    when Types::STRUCT
+      unless field[:class] == value.class
+        raise TypeMismatch, "Expected #{field[:class]}, received #{value.class} for field #{name}"
+      end
+    end
+  end
+
+  TYPE_NAME_SYM_MAPPING = Types.constants.each_with_object({}) do |const, h|
+    h[Types.const_get(const)] = const.to_sym
+  end
+
+  TYPE_NAME_MAPPING = TYPE_NAME_SYM_MAPPING.each_with_object({}) do |(k, const), h|
+    h[k] = "Types::#{const}".freeze
+  end.freeze
+
+  def self.type_name_sym(type)
+    TYPE_NAME_SYM_MAPPING[type]
+  end
+
+  def self.type_name(type)
+    TYPE_NAME_MAPPING[type]
+  end
+
+  module MessageTypes
+    CALL = 1
+    REPLY = 2
+    EXCEPTION = 3
+    ONEWAY = 4
+  end
+end

data/lib/sparsam/union.rb

@@ -0,0 +1,72 @@
+# -*- coding: UTF-8 -*-
+require 'sparsam/base_class'
+
+module Sparsam
+  class Union < ::Sparsam::BaseClass
+    def initialize(name = nil, value = nil)
+      if name
+        if name.is_a? Hash
+          if name.size > 1
+            raise ::Sparsam::UnionException,
+              "#{self.class} cannot be instantiated with more than one field!"
+          end
+          value = name.values.first
+          name = name.keys.first
+        end
+      end
+
+      if name
+        accessors = name_to_accessors(name)
+        unless accessors
+          raise Sparsam::Exception, "Unknown key given to #{self.class}.new: #{name}"
+        end
+
+        send(accessors.writer, value)
+      end
+    end
+
+    def ==(other)
+      other.equal?(self) ||
+      other.instance_of?(self.class) &&
+      @setfield == other.get_set_field &&
+      get_value == other.get_value
+    end
+    alias_method :eql?, :==
+
+    def hash
+      [self.class.name, @setfield, get_value].hash
+    end
+
+    def get_set_field
+      @setfield
+    end
+
+    def get_value
+      if @setfield
+        send(name_to_accessors(@setfield).reader)
+      end
+    end
+
+    def self.field_accessor(klass, field_key, field_info)
+      field_name = field_info[:name]
+      klass.class_eval(<<-EOF, __FILE__, __LINE__)
+        def #{field_name}
+          if :'#{field_name}' == @setfield
+            instance_variable_get(:'@#{field_name}')
+          else
+            raise ::Sparsam::UnionException, "#{field_name} is not union's set field"
+          end
+        end
+
+        def #{field_name}=(value)
+          if @setfield
+            remove_instance_variable(:"@\#{@setfield}")
+          end
+
+          @setfield = :'#{field_name}'
+          instance_variable_set(:'@#{field_name}', value)
+        end
+      EOF
+    end
+  end
+end

data/spec/gen-ruby/user_constants.rb

@@ -0,0 +1,9 @@
+#
+# Autogenerated by Thrift Compiler (0.1.0)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+
+require 'sparsam'
+require 'user_types'
+

data/spec/gen-ruby/user_types.rb

@@ -0,0 +1,106 @@
+#
+# Autogenerated by Thrift Compiler (0.1.0)
+#
+# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+#
+
+require 'sparsam'
+
+module Magic
+  Black = 0
+  White = 1
+  Red = 2
+  Blue = 3
+  Green = 4
+  VALUE_MAP = {0 => "Black", 1 => "White", 2 => "Red", 3 => "Blue", 4 => "Green"}
+  VALID_VALUES = Set.new([Black, White, Red, Blue, Green]).freeze
+end
+
+class US < ::Sparsam::Struct
+  FIELDS = {
+    1 => {:type => ::Sparsam::Types::I32, :name => 'id_i32', :optional => true},
+    2 => {:type => ::Sparsam::Types::STRING, :name => 'id_s', :default => %q"id_s default", :binary => true, :optional => true},
+    3 => {:type => ::Sparsam::Types::SET, :name => 'string_set', :element => {:type => ::Sparsam::Types::STRING}, :optional => true},
+    4 => {:type => ::Sparsam::Types::SET, :name => 'int_set', :element => {:type => ::Sparsam::Types::I32}, :optional => true}
+  }
+
+  init_thrift_struct(self)
+end
+
+class UN < ::Sparsam::Union
+  FIELDS = {
+    1 => {:type => ::Sparsam::Types::I32, :name => 'id_i32', :optional => true},
+    2 => {:type => ::Sparsam::Types::STRING, :name => 'id_s', :optional => true}
+  }
+
+  init_thrift_struct(self)
+end
+
+class SS < ::Sparsam::Struct
+  FIELDS = {
+    1 => {:type => ::Sparsam::Types::I32, :name => 'id_i32', :optional => true},
+    2 => {:type => ::Sparsam::Types::STRING, :name => 'id_s', :optional => true},
+    3 => {:type => ::Sparsam::Types::STRUCT, :name => 'us_i', :class => ::US, :optional => true},
+    4 => {:type => ::Sparsam::Types::SET, :name => 'us_s', :element => {:type => ::Sparsam::Types::STRUCT, :class => ::US}, :optional => true},
+    5 => {:type => ::Sparsam::Types::LIST, :name => 's_l', :element => {:type => ::Sparsam::Types::STRING}, :optional => true},
+    6 => {:type => ::Sparsam::Types::MAP, :name => 'mappy', :key => {:type => ::Sparsam::Types::I32}, :value => {:type => ::Sparsam::Types::STRING}, :optional => true},
+    7 => {:type => ::Sparsam::Types::BYTE, :name => 'byte_field', :optional => true},
+    8 => {:type => ::Sparsam::Types::STRUCT, :name => 'un_field', :class => ::UN, :optional => true},
+    9 => {:type => ::Sparsam::Types::I32, :name => 'magic_field', :optional => true, :enum_class => ::Magic},
+    10 => {:type => ::Sparsam::Types::MAP, :name => 'troll', :key => {:type => ::Sparsam::Types::I32}, :value => {:type => ::Sparsam::Types::MAP, :key => {:type => ::Sparsam::Types::I32}, :value => {:type => ::Sparsam::Types::I32}}, :optional => true}
+  }
+
+  init_thrift_struct(self)
+end
+
+class MiniRequired < ::Sparsam::Struct
+  FIELDS = {
+    1 => {:type => ::Sparsam::Types::I32, :name => 'id_i32'}
+  }
+
+  init_thrift_struct(self)
+end
+
+class EasilyInvalid < ::Sparsam::Struct
+  FIELDS = {
+    1 => {:type => ::Sparsam::Types::STRUCT, :name => 'tail', :class => ::EasilyInvalid, :optional => true},
+    2 => {:type => ::Sparsam::Types::SET, :name => 's_self', :element => {:type => ::Sparsam::Types::STRUCT, :class => ::EasilyInvalid}, :optional => true},
+    3 => {:type => ::Sparsam::Types::LIST, :name => 'l_self', :element => {:type => ::Sparsam::Types::STRUCT, :class => ::EasilyInvalid}, :optional => true},
+    4 => {:type => ::Sparsam::Types::MAP, :name => 'mappy1', :key => {:type => ::Sparsam::Types::STRUCT, :class => ::EasilyInvalid}, :value => {:type => ::Sparsam::Types::I32}, :optional => true},
+    5 => {:type => ::Sparsam::Types::MAP, :name => 'mappy2', :key => {:type => ::Sparsam::Types::I32}, :value => {:type => ::Sparsam::Types::STRUCT, :class => ::EasilyInvalid}, :optional => true},
+    6 => {:type => ::Sparsam::Types::MAP, :name => 'mappy3', :key => {:type => ::Sparsam::Types::STRUCT, :class => ::EasilyInvalid}, :value => {:type => ::Sparsam::Types::STRUCT, :class => ::EasilyInvalid}, :optional => true},
+    7 => {:type => ::Sparsam::Types::LIST, :name => 'sure', :element => {:type => ::Sparsam::Types::MAP, :key => {:type => ::Sparsam::Types::SET, :element => {:type => ::Sparsam::Types::I32}}, :value => {:type => ::Sparsam::Types::MAP, :key => {:type => ::Sparsam::Types::I32}, :value => {:type => ::Sparsam::Types::SET, :element => {:type => ::Sparsam::Types::LIST, :element => {:type => ::Sparsam::Types::MAP, :key => {:type => ::Sparsam::Types::STRUCT, :class => ::EasilyInvalid}, :value => {:type => ::Sparsam::Types::STRING}}}}}}, :optional => true},
+    8 => {:type => ::Sparsam::Types::STRUCT, :name => 'required_stuff', :class => ::MiniRequired, :optional => true},
+    9 => {:type => ::Sparsam::Types::I32, :name => 'id_i32', :optional => true}
+  }
+
+  init_thrift_struct(self)
+end
+
+class NotSS < ::Sparsam::Struct
+  FIELDS = {
+    1 => {:type => ::Sparsam::Types::STRING, :name => 'id_s', :optional => true},
+    3 => {:type => ::Sparsam::Types::I32, :name => 'id_i32', :optional => true}
+  }
+
+  init_thrift_struct(self)
+end
+
+class NotSS_plus < ::Sparsam::Struct
+  FIELDS = {
+    1 => {:type => ::Sparsam::Types::STRING, :name => 'id_s', :optional => true},
+    2 => {:type => ::Sparsam::Types::STRING, :name => 'id_s2', :optional => true},
+    3 => {:type => ::Sparsam::Types::I32, :name => 'id_i32', :optional => true}
+  }
+
+  init_thrift_struct(self)
+end
+
+class Nothing < ::Sparsam::Struct
+  FIELDS = {
+
+  }
+
+  init_thrift_struct(self)
+end
+