steamd 0.1.0

data/lib/steamd/generator/ruby/serializable_variable.rb

@@ -0,0 +1,85 @@
+
+# frozen_string_literal: true
+# Represents a Serialized var
+class SerizableVariable
+  attr_reader :name, :type, :size, :modifier, :modifier_size, :value
+  attr_accessor :flag
+
+  # Initialize a SteamSerializable from a hash
+  def initialize(var)
+    @name = var[:name]
+    @value = var[:value]
+    @modifier = var[:modifier]
+    @modifier_size = var[:modifier_size]
+    @type = Type.new(var[:type])
+  end
+
+  # Serialize the object
+  def serialize
+    if type.primitive?
+      serialize_primitive
+    elsif type.encodable?
+      serialize_encodable
+    else
+      serialize_object
+    end
+  end
+
+  # Serialize the object
+  #
+  # @param io [:read]
+  def deserialize(io)
+    @value = if type.primitive?
+               deserialize_primitive(io)
+             elsif type.encodable?
+               deserialize_encodable(io)
+             else
+               deserialize_object(io)
+             end
+  end
+
+  private
+
+  # @api private
+  def deserialize_object(io)
+    type = Type.new(self.type.klass::DATA_TYPE)
+    io.read(type.bytesize).unpack(type.bytedirective).first
+  end
+
+  # @api private
+  def deserialize_encodable(io)
+    raise NotImplementedError if flag.nil? || modifier_size.nil?
+    type.klass.decode(io.read(flag.value))
+  end
+
+  # @api private
+  def deserialize_primitive(io)
+    io.read(type.bytesize).unpack(type.bytedirective).first
+  end
+
+  # @api private
+  def serialize_object
+    type = Type.new(self.type.klass::DATA_TYPE)
+    [value].pack(type.bytedirective)
+  end
+
+  # @api private
+  def serialize_encodable
+    raise NotImplementedError unless value.respond_to?(:encode)
+    value.encode
+  end
+
+  # @api private
+  def serialize_primitive
+    if flag
+      [flag.value.encode.length].pack('<l')
+    else
+      [value].pack(type.bytedirective)
+    end
+  end
+
+  # @api private
+  def validate
+    raise NotImplementedError unless @var[:size].nil?
+  end
+end

data/lib/steamd/generator/ruby/steam_serializable.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+require 'steamd/generator/ruby/serializable_type'
+require 'steamd/generator/ruby/serializable_variable'
+require 'steamd/generator/ruby/serializable_constant'
+
+# Included in each Generated Ruby class. Provides access to methods on the class
+# as well as serialization options.
+module SteamSerializable
+  # Variables in this class
+  attr_reader :variables
+
+  # Variables in this class
+  attr_reader :constants
+
+  # Sets the variables and constants of this Steam object
+  def initialize(vars, consts = [])
+    @variables = vars.each_with_object({})   { |v, m| m[v[:name]] = v }
+    @constants = consts.each_with_object({}) { |v, m| m[v[:name]] = v }
+  end
+
+  # Encode to a given IO stream
+  #
+  # @param io [:read]
+  def encode_to(io)
+    io.write(serialize)
+  end
+
+  # Serialize the constants and variables into a stream
+  #
+  # @return [String] the byte representation
+  def serialize
+    stream = StringIO.new
+    stream.set_encoding('BINARY')
+    stream.write((consts + vars).map(&:serialize).join)
+    stream.string
+  end
+  alias encode serialize
+
+  # Deserialize the object using an IO stream
+  #
+  # @param io [:read] The io stream to deserialize
+  def deserialize(io)
+    (consts + vars).each { |v| send("#{v.name}=", v.deserialize(io)) }
+    self
+  end
+  alias decode deserialize
+  alias decode_from deserialize
+
+  # Returns a list of SerizableConstant objects. Allowing you to
+  # serialize each constant
+  #
+  # @return [Array<SerizableConstant>] the constants
+  def consts
+    constants.values.map { |const| SerizableConstant.new(const) }
+  end
+
+  # Returns a list of SerializedVariable objects. Allowing you to
+  # serialize each constant
+  #
+  # @return [Array<SerializedVariable>] the constants
+  def vars
+    vars = variables.values.map do |v|
+      SerizableVariable.new(v)
+    end
+
+    vars.map do |var|
+      var.flag = flag(vars, var)
+      var
+    end
+  end
+
+  # Looks up the variable flag. This is used for when variables
+  # are of a defined length
+  #
+  # ie:
+  #   int header_len;
+  #   proto<header_len> ProtoBuf name;
+  #
+  # The flag in the case of serialization would be the "name" variable as it
+  # would need to write that before it can write header len.
+  #
+  # The flag in the case of deserialization would be the "header_len" variable
+  # because it defines how many bytes to read so we can read the "name"
+  # variable
+  def flag(vars, var)
+    (vars.select { |v| v.modifier_size == var.name } +
+            vars.select { |v| v.name == var.modifier_size }).first
+  end
+end

data/lib/steamd/nodes/block_node.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+# The root of the parsed tree
+class Block < Node
+  # Gets the statements in a Steam Language block
+  #
+  # @see ClassStatement
+  # @see ImportStatement
+  # @see EnumStatement
+  #
+  # @return Array
+  def statements
+    elements.map(&:statement)
+  end
+end

data/lib/steamd/nodes/class_statement_node.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+# A parsed class statement
+#
+# @example A class
+#   class Test { }
+#
+# Contains the variables, class name, type
+class ClassStatement < Node
+  # Returns the class object as a hash
+  #
+  # @return [Hash] hash representation of the class
+  def to_hash
+    {
+      name: name,
+      type: type,
+      variables: variables
+    }
+  end
+
+  # The name of the class
+  def name
+    class_name.text_value
+  end
+
+  # The class type
+  #
+  # ie class Test<EMsg::Blah> {}
+  def type
+    types = elements.select { |el| el.is_a?(ClassType) }
+    type = types.first
+    type&.value
+  end
+
+  # Returns a list of variables
+  #
+  # @return [Array] variables
+  def variables
+    declerations = [first_var] + other.elements.map(&:decleration)
+
+    variables = declerations.select do |node|
+      node.is_a?(Variable)
+    end
+
+    variables.map!(&:to_hash)
+  end
+end

data/lib/steamd/nodes/class_type_node.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+# Holds a class type, if it exists
+# This node may not always be in the tree
+class ClassType < Node
+  # The type of the class
+  #
+  # @return [String]
+  def value
+    type = text_value.strip
+    type.empty? ? nil : type
+  end
+end

data/lib/steamd/nodes/enum_statement_node.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+# Represents an Enum statement
+#
+# @example Enum Statement
+#   enum Test { Invalid = 1; }
+class EnumStatement < Node
+  # The name of the enum
+  #
+  # @return [String]
+  def name
+    enum_name.text_value
+  end
+
+  # The type of the enum
+  #
+  # @return [String]
+  def type
+    enum_type.type.text_value if enum_type.respond_to?(:type)
+  end
+
+  # Returns true if this enum uses bitmask flags
+  #
+  # @return [Bool]
+  def flags?
+    type == 'flags'
+  end
+
+  # Returns a list of EnumVariable objects
+  #
+  # @return Array
+  def variables
+    declerations = [first_var] + other.elements.map(&:enum_decleration)
+
+    variables = declerations.select do |node|
+      node.is_a?(EnumVariable)
+    end
+
+    variables.map!(&:to_hash)
+  end
+
+  # Hash representation of this Enum
+  def to_hash
+    {
+      name: name,
+      type: type,
+      flags: flags?,
+      variables: variables
+    }
+  end
+end

data/lib/steamd/nodes/enum_variable_node.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+# Represents a variable declared in an Enum
+#
+# @example
+#   Invalid = 0
+class EnumVariable < Node
+  # The name of the EnumVariable
+  def name
+    enum_variable_name.text_value
+  end
+
+  # The value of the EnumVariable
+  def value
+    enum_variable_value.value
+  end
+
+  # Hash representation of the EnumVariable
+  def to_hash
+    {
+      name: name,
+      value: value
+    }
+  end
+end

data/lib/steamd/nodes/import_statement_node.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+# Represents an import statement
+#
+# ie: #import "test.steamd"
+class ImportStatement < Node
+  # The full name including the extension of the import file
+  #
+  # @return [String]
+  def name
+    filename.text_value
+  end
+
+  # The name not including the extension of the import file
+  #
+  # @return [String]
+  def filename_no_ext
+    File.basename(name, '.*')
+  end
+
+  # The hash representation
+  #
+  # @return [Hash]
+  def to_hash
+    { filename: filename_no_ext }
+  end
+end

data/lib/steamd/nodes/node.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+# Wrapper around a treetop node
+Node = Class.new(Treetop::Runtime::SyntaxNode)

data/lib/steamd/nodes/nodes.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'steamd/nodes/node'
+require 'steamd/nodes/block_node'
+require 'steamd/nodes/class_type_node'
+require 'steamd/nodes/class_statement_node'
+require 'steamd/nodes/variable_node'
+require 'steamd/nodes/enum_variable_node'
+require 'steamd/nodes/enum_statement_node'
+require 'steamd/nodes/import_statement_node'

data/lib/steamd/nodes/variable_node.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+# Base variable, each variable has a type and a name at the very least.
+class Variable < Node
+  # Returns the name of the variable
+  #
+  # @return [String] the variable name
+  def name
+    variable_name.text_value
+  end
+
+  # Returns the type of the variable
+  #
+  # @return [String] the variable type
+  def type
+    var_type.type.text_value
+  end
+
+  # Returns the size, if any of the variable. ie byte<6> y;
+  #
+  # @return [String/Integer/nil] the variable size
+  def size
+    return nil unless var_type && var_type.respond_to?(:size)
+
+    if var_type.size.text_value.empty?
+      nil
+    else
+      var_type.size.var_value.value
+    end
+  end
+
+  # Hash representation of this Variable Node
+  #
+  # @return [Hash]
+  def to_hash
+    {
+      name: name,
+      type: type,
+      modifier: nil,
+      value: nil,
+      size: size,
+      modifier_size: nil
+    }
+  end
+end
+
+# Variable with a modifier.
+#
+# ie: proto int x;
+class VariableWithModifier < Variable
+  # Determins if the modifier of this variable is sized.
+  #
+  # ie: proto<len> CMsgHeaderProtobuf x;
+  def sized?
+    var_modifier.respond_to?(:size) &&
+      !var_modifier.size.text_value.empty?
+  end
+
+  # The size of the variable modifier
+  def modifier_size
+    return nil if var_type.nil?
+
+    var_modifier.size.value if sized?
+  end
+end
+
+# A variable with a modifier but no value
+# ie: proto header hi;
+class VariableWithModifierNoValue < VariableWithModifier
+  # Hash representation of the VariableWithModifierNoValue
+  #
+  # @return [Hash]
+  def to_hash
+    hsh = super
+
+    hsh.merge!(
+      modifier: var_modifier.word.text_value,
+      modifier_size: modifier_size
+    )
+  end
+end
+
+# A variable with a modifier and a default value
+class VariableWithModifierWithValue < VariableWithModifierNoValue
+  # Hash representation of the VariableWithModifierWithValue
+  #
+  # @return [Hash]
+  def to_hash
+    hsh = super
+
+    hsh.merge!(
+      value: var_value.value
+    )
+  end
+end
+
+# Variable, no modifier with a value
+# ie: int x = 1;
+class VariableWithValue < Variable
+  # Hash representation of the VariableWithValue
+  #
+  # @return [Hash]
+  def to_hash
+    hsh = super
+    hsh.merge!(value: var_value.value)
+  end
+end