steamd 0.1.0

data/lib/steamd/generator.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module Steamd
+  # Handles code generation
+  module Generator
+  end
+end

data/lib/steamd/generator/generated_class.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+require 'ostruct'
+module Steamd
+  module Generator
+    # Represents an class variable from the Generator
+    class Variable
+      # The name of the Variable
+      attr_reader :name
+
+      # The variable Type
+      attr_reader :type
+
+      # The variable size
+      attr_reader :size
+
+      # The variable modifier
+      attr_reader :modifier
+
+      # The variable modifier size
+      attr_reader :modifier_size
+
+      # The variable value
+      attr_reader :value
+
+      # Create a new GeneratedClass
+      def initialize(opts)
+        @name = opts[:name]
+        @value = opts[:value]
+        @type = opts[:type]
+        @modifier = opts[:modifier]
+        @modifier_size = opts[:modifier_size]
+      end
+
+      # The name of the Variable
+      #
+      # @return [String] variable name, underscored
+      def name
+        @name.underscore
+      end
+
+      # The size of the variable modifier
+      #
+      # @return [String]
+      def modifier_size
+        if @modifier_size.is_a?(String)
+          @modifier_size.underscore
+        else
+          @modifier_size
+        end
+      end
+
+      # The type of the variable
+      def type
+        case @type
+        when 'SteamKit2.Internal.CMsgProtoBufHeader'
+          'Steamclient::CMsgProtoBufHeader'
+        when 'SteamKit2.GC.Internal.CMsgProtoBufHeader'
+          'Gc::CMsgProtoBufHeader'
+        else
+          @type
+        end
+      end
+
+      def value
+        if @value.is_a?(String)
+          parts = @value.split('::')
+          name = parts.last.underscore.upcase
+          [parts.first, name].join('::')
+        else
+          @value
+        end
+      end
+
+      # Return the variable as a hash
+      def to_hash
+        {
+          name: name,
+          type: type,
+          modifier: modifier,
+          value: value,
+          size: size,
+          modifier_size: modifier_size
+        }
+      end
+      alias to_h to_hash
+    end
+
+    # Class constant
+    class Constant < Variable
+      attr_reader :name, :value
+      def name
+        @name.underscore.upcase
+      end
+    end
+
+    # Represents an Class from the Generator
+    class GeneratedClass
+      # Create a Generated Class
+      def initialize(klass)
+        @klass = klass
+      end
+
+      # List of variables to be used in the class
+      def variables
+        @klass[:variables].select { |v| v[:modifier] != 'const' }.map do |var|
+          Variable.new(var)
+        end
+      end
+
+      # List of constants to be used in the class
+      def constants
+        @klass[:variables].select { |v| v[:modifier] == 'const' }.map do |const|
+          Constant.new(const)
+        end
+      end
+
+      # The class name
+      def name
+        @klass[:name]
+      end
+
+      # Binding for ERB
+      def erb_binding
+        binding
+      end
+    end
+  end
+end

data/lib/steamd/generator/generated_enum.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+module Steamd
+  module Generator
+    # Enum variable
+    class EnumVariable
+      attr_reader :name, :value, :flags
+      def initialize(name, value, flags)
+        @name = name
+        @value = value
+        @flags = flags
+      end
+
+      def name
+        @name.underscore.upcase
+      end
+
+      def value
+        if flags && @value.is_a?(String)
+          @value
+            .split('|')
+            .map(&:strip)
+            .map(&:underscore)
+            .map(&:upcase)
+            .join(' | ')
+        else
+          @value
+        end
+      end
+    end
+
+    # Represents an Enum from the Generator
+    class GeneratedEnum
+      def initialize(enum)
+        @enum = enum
+      end
+
+      # Type of Enum
+      def type
+        @enum[:type]
+      end
+
+      # Entries of enum
+      def variables
+        @enum[:variables].map do |v|
+          EnumVariable.new(v[:name], v[:value], @enum[:flags])
+        end
+      end
+
+      # Name of enum
+      def name
+        @enum[:name]
+      end
+
+      # Binding for ERB
+      def erb_binding
+        binding
+      end
+    end
+  end
+end

data/lib/steamd/generator/generated_import.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+module Steamd
+  module Generator
+    # Represents an import from the Generator
+    class GeneratedImport
+      def initialize(import)
+        @import = import
+      end
+
+      # Import filename
+      def filename
+        @import[:filename]
+      end
+
+      # ERB Binding
+      def erb_binding
+        binding
+      end
+    end
+  end
+end

data/lib/steamd/generator/implementation.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+require 'erb'
+require 'ostruct'
+
+require 'steamd/generator/generated_class'
+require 'steamd/generator/generated_enum'
+require 'steamd/generator/generated_import'
+
+module Steamd
+  module Generator
+    # The underlying Implementation of a generator.
+    #
+    # @example Making a generate
+    #   class MyGenerator
+    #     include Generator::Implementation
+    #
+    #     def generate
+    #       classes.each { |c| puts c.name }
+    #     end
+    #   end
+    module Implementation
+      # Instantiate the object with a given IO stream.
+      #
+      # @param io The IO object
+      def initialize(io)
+        @parser = Steamd::Parser.new
+        @buffer = ''
+        @io = io
+        self
+      end
+
+      # Run the generator. Load the parser, and parse the IO object.
+      #
+      # @return The parsed code
+      def run
+        @parser.load!
+        @parser.parse(@io)
+        generate
+        @buffer
+      end
+
+      # The classes parsed from the lanaguage
+      def classes
+        @parser.classes.map do |klass|
+          GeneratedClass.new(klass)
+        end
+      end
+
+      # The imports parsed from the language
+      def imports
+        @parser.imports.map do |import|
+          GeneratedImport.new(import)
+        end
+      end
+
+      # The enums parsed from the language
+      def enums
+        @parser.enums.map do |enum|
+          GeneratedEnum.new(enum)
+        end
+      end
+
+      private
+
+      # Generates the code
+      def generate(_io)
+        raise NotImplementedError
+      end
+
+      # @api private
+      def erb(template, vars)
+        ERB.new(template, nil, '-').result(vars.erb_binding)
+      end
+
+      # Append a string to the internal buffer
+      #
+      # @api private
+      def append(str)
+        @buffer += str
+      end
+    end
+  end
+end

data/lib/steamd/generator/ruby/class.erb

@@ -0,0 +1,39 @@
+# Class for the <%= name %> in the Steam Language.
+class <%= name %>
+  # Allows serialization and deserialization of the class
+  include SteamSerializable
+
+<% constants.each do |const| -%>
+  # <%= const.name -%> constant
+  <%= const.name -%> = <%= const.value %>
+<% end -%>
+  # Instantiate a <%= name -%> object
+  def initialize
+    super(<%= variables.map(&:to_h) -%>, <%= constants.map(&:to_h) -%>)
+<% variables.each do |var| -%>
+<% if var.value != nil -%>
+    self.<%= var.name -%> = <%= var.value %>
+<% end -%>
+<% if var.type.include?('CMsg') -%>
+    self.<%= var.name -%> = <%= var.type %>.new
+<% end -%>
+<% end -%>
+  end
+<% variables.each do |var| %>
+  # Gets the <%= var.name -%> variable.
+  #
+  # @note defaults to <%= var.value %>
+  # @return [<%= var.type -%>] the value of <%= var.name %>
+  def <%= var.name %>
+    @variables['<%= var.name -%>'][:value]
+  end
+
+  # Sets the <%= var.name -%> variable.
+  #
+  # @param value [<%= var.type -%>] the new value
+  def <%= var.name -%>=(value)
+    @variables['<%= var.name -%>'][:value] = value
+  end
+<% end %>
+end
+

data/lib/steamd/generator/ruby/enum.erb

@@ -0,0 +1,14 @@
+# Represents the <%= name -%> enum
+class <%= name %>
+  # Data type of <%= name %>
+<% if type -%>
+  DATA_TYPE = '<%= type %>'
+<% else -%>
+  DATA_TYPE = 'int'
+<% end -%>
+<% variables.each do |var| -%>
+  # Constant <%= var.name -%> for <%= name %>
+  <%= var.name %> = <%= var.value %>
+<% end -%>
+end
+

data/lib/steamd/generator/ruby/import.erb

@@ -0,0 +1 @@
+require_relative '<%= filename %>'

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

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+require 'steamd/generator/implementation'
+
+# frozen_string_literal: true
+module Steamd
+  module Generator
+    # Generates Ruby code
+    class Ruby
+      include Implementation
+
+      # Generate Ruby code for the Steam Language
+      def generate
+        classes.each do |klass|
+          append(erb(klass_template, klass))
+        end
+
+        imports.each do |import|
+          append(erb(import_template, import))
+        end
+
+        enums.each do |enum|
+          append(erb(enum_template, enum))
+        end
+      end
+
+      private
+
+      # @api private
+      def import_template
+        erb_file('import.erb').read
+      end
+
+      # @api private
+      def enum_template
+        erb_file('enum.erb').read
+      end
+
+      # @api private
+      def klass_template
+        erb_file('class.erb').read
+      end
+
+      # @api private
+      def erb_file(file)
+        File.open(File.expand_path("#{erb_template_root}/#{file}"))
+      end
+
+      # @api private
+      def erb_template_root
+        File.dirname(__FILE__)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+# Serializable const
+class SerizableConstant < SerizableVariable
+  # Override the type for constants, always integer
+  #
+  # @return [Type]
+  def type
+    Type.new('int')
+  end
+
+  # Serialize the constant
+  def serialize
+    serialize_primitive
+  end
+
+  # Deserialize the constant
+  def deserialize
+    @value = deserialize_primitive
+  end
+end

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

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+# Serializable type
+class Type
+  attr_reader :type
+
+  # Instantiate a Type
+  #
+  # @example Instantiate a Type
+  #   type = Type.new('int')
+  def initialize(type)
+    @type = type
+  end
+
+  # The String representation of the Type. If it is a SteamKit Internal type,
+  # the type is transformed into namespaces from the `steam-proto` repo.
+  #
+  # @return [String] the type
+  def type
+    case @type
+    when 'SteamKit2.Internal.CMsgProtoBufHeader'
+      'Steamclient::CMsgProtoBufHeader'
+    when 'SteamKit2.GC.Internal.CMsgProtoBufHeader'
+      'Gc::CMsgProtoBufHeader'
+    when *primitives
+      @type
+    else
+      Object.const_get(@type.to_s).to_s
+    end
+  end
+
+  # Is this type an encodable type?
+  #
+  # @return [Bool]
+  def encodable?
+    encodables.include?(type)
+  end
+
+  # Is this type an primitive type?
+  #
+  # @return [Bool]
+  def primitive?
+    primitives.include?(type)
+  end
+
+  # The byte directive for this type
+  #
+  # @return [String]
+  def bytedirective
+    {
+      'int' => 'l<',
+      'ushort' => 'S<',
+      'short' => 's<',
+      'byte' => 'c',
+      'uint' => 'L<',
+      'ulong' => 'Q<'
+    }[type]
+  end
+
+  # The size in bytes of this type
+  #
+  # @return [Integer]
+  def bytesize
+    case type
+    when 'uint', 'int'
+      4
+    when 'ushort', 'short'
+      2
+    when 'ulong', 'long'
+      8
+    when 'byte'
+      1
+    end
+  end
+
+  # The Class represented by this Type
+  #
+  # @return [Object]
+  def klass
+    type.constantize
+  end
+
+  private
+
+  # @api private
+  def primitives
+    %w(int short uint long ulong byte ushort)
+  end
+
+  # @api private
+  def encodables
+    ['Steamclient::CMsgProtoBufHeader', 'Gc::CMsgProtoBufHeader']
+  end
+end