xdrgen 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 30ccfde98b0baa13f03916b4b2d89c774ed8119e373e23541ca8e46e87f1db06
-  data.tar.gz: abd5834683ef1d6e74e6decf61b7c3155a0cf1ef5fd03a4592acb43abd2e7446
+  metadata.gz: 838bb9438d35d145a409589e774549bf2e74ef83c25156abf40f410e2064a32b
+  data.tar.gz: 25488d84cb7c5c641c52308e915d8b2d4d63631c67aa7bcda22c18635fb0fd7b
 SHA512:
-  metadata.gz: '040408ad8434aaa992df6533dd66954c85c389cfe76130ca188c2008c1592a758e315c0036929e9064b48d3d49bcf18fdf902455f1a7fdd0522da91d76d6085e'
-  data.tar.gz: ec2721ba15cb25ec6aff042a5c1c3697b557d1dab85e6c61a2cc242b5be87c6af815e1e685b335e21e7da98b0ebe4156cc39444057141e8fb8521231b2444d7e
+  metadata.gz: 5bb40e6312ffc8c27febe50c367ab0b99141751b0b1b47c4a51c3cff7d33420b8a1410318175657756dbefc4ed20d7e9de5f37415692f423cd7043476e45842a
+  data.tar.gz: 33d7132dad38f3baedf34e17acc5704c688fdd280908864732f607821e831d6eca7e6544d258a80ff1575e547e50b38985131ed54d6a7286b05777942c2e729b

data/.github/workflows/ruby.yml

@@ -0,0 +1,23 @@
+name: Ruby
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.7', '3.0']
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@473e4d8fe5dd94ee328fdfca9f8c9c7afc9dae5e
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true # runs 'bundle install' and caches installed gems automatically
+    - name: Run Rspec tests
+      run: bundle exec rspec

data/README.md

@@ -25,7 +25,8 @@ golang, and elixir:
 - golang: currently using a fork of go-xdr, but has complete support
 - elixir: support is experimental as the SDK is in early development. Generated
   code requires [:exdr](https://github.com/revelrylabs/exdr) in your deps
-
+- C#: complete support
+  
 Testing is _very_ sparse, but will improve over time.
 
 ## Usage as a binary

data/lib/xdrgen/cli.rb

@@ -5,7 +5,7 @@ module Xdrgen
     def self.run(args)
       args = args.dup
       opts = Slop.parse! args do
-        banner 'Usage: xdrgen -o OUTPUT_DIR INPUT --gen=ruby'
+        banner 'Usage: xdrgen -o OUTPUT_DIR INPUT --language=ruby'
         on 'o', 'output=', 'The output directory'
         on 'l', 'language=', 'The output language', default: 'ruby'
         on 'n', 'namespace=', '"namespace" to generate code within (language-specific)'
@@ -16,7 +16,7 @@ module Xdrgen
 
       compilation = Compilation.new(
         args,
-        output_dir: opts[:output], 
+        output_dir: opts[:output],
         language:   opts[:language].to_sym,
         namespace:  opts[:namespace]
       )
@@ -28,4 +28,4 @@ module Xdrgen
       exit(code)
     end
   end
-end
+end

data/lib/xdrgen/generators.rb

@@ -7,6 +7,7 @@ module Xdrgen::Generators
   autoload :Javascript
   autoload :Java
   autoload :Elixir
+  autoload :Csharp
 
   def self.for_language(language)
     const_get language.to_s.classify

data/lib/xdrgen/generators/csharp.rb

@@ -0,0 +1,580 @@
+module Xdrgen
+  module Generators
+    class Csharp < Xdrgen::Generators::Base
+      def generate
+        render_lib
+        render_definitions(@top)
+      end
+
+      def render_lib; end
+
+      def render_definitions(node)
+        node.namespaces.each { |n| render_definitions n }
+        node.definitions.each(&method(:render_definition))
+      end
+
+      def render_definition(defn)
+        case defn
+        when AST::Definitions::Struct
+          render_element 'public class', defn do |out|
+            render_struct defn, out
+            render_nested_definitions defn, out
+          end
+        when AST::Definitions::Enum
+          render_element 'public class', defn do |out|
+            render_enum defn, out
+          end
+        when AST::Definitions::Union
+          render_element 'public class', defn do |out|
+            render_union defn, out
+            render_nested_definitions defn, out
+          end
+        when AST::Definitions::Typedef
+          render_element 'public class', defn do |out|
+            render_typedef defn, out
+          end
+        end
+      end
+
+      def render_nested_definitions(defn, out)
+        return unless defn.respond_to? :nested_definitions
+        defn.nested_definitions.each do |ndefn|
+          case ndefn
+          when AST::Definitions::Struct
+            name = name ndefn
+            out.puts "public class #{name} {"
+            out.indent do
+              render_struct ndefn, out
+              render_nested_definitions ndefn, out
+            end
+            out.puts '}'
+          when AST::Definitions::Enum
+            name = name ndefn
+            out.puts "public class #{name} {"
+            out.indent do
+              render_enum ndefn, out
+            end
+            out.puts '}'
+          when AST::Definitions::Union
+            name = name ndefn
+            out.puts "public class #{name} {"
+            out.indent do
+              render_union ndefn, out
+              render_nested_definitions ndefn, out
+            end
+            out.puts '}'
+          when AST::Definitions::Typedef
+            name = name ndefn
+            out.puts "public class #{name} {"
+            out.indent do
+              render_typedef ndefn, out
+            end
+            out.puts '}'
+          end
+        end
+      end
+
+      def render_element(type, element, post_name = '')
+        path = element.name.camelize + '.cs'
+        name = name_string element.name
+        out  = @output.open(path)
+        render_top_matter out
+        render_source_comment out, element
+
+        out.puts "#{type} #{name} #{post_name} {"
+        out.indent do
+          yield out
+          out.unbreak
+        end
+        out.puts '}'
+        out.puts '}'
+      end
+
+      def render_enum(enum, out)
+        enumname = enum.name + 'Enum'
+
+        out.puts "public enum #{enumname} {"
+        out.balance_after /,[\s]*/ do
+          enum.members.each do |em|
+            out.puts "#{em.name} = #{em.value},"
+          end
+        end
+        out.puts "}\n"
+        out.puts <<-EOS.strip_heredoc
+            public #{enumname} InnerValue {get; set;} = default(#{enumname});
+
+            public static #{enum.name} Create(#{enumname} v)
+            {
+              return new #{enum.name} {
+                InnerValue = v
+              };
+            }
+
+            public static #{name_string enum.name} Decode(XdrDataInputStream stream) {
+              int value = stream.ReadInt();
+              switch (value) {
+            EOS
+        out.indent 2 do
+          enum.members.each do |em|
+            out.puts "case #{em.value}: return Create(#{enumname}.#{em.name});"
+          end
+        end
+        out.puts <<-EOS.strip_heredoc
+                default:
+                  throw new Exception("Unknown enum value: " + value);
+              }
+            }
+
+            public static void Encode(XdrDataOutputStream stream, #{name_string enum.name} value) {
+              stream.WriteInt((int)value.InnerValue);
+            }
+            EOS
+        out.break
+      end
+
+      def render_struct(struct, out)
+        out.puts "public #{name struct} () {}"
+        struct.members.each do |m|
+          out.puts <<-EOS.strip_heredoc
+                public #{decl_string(m.declaration)} #{m.name.camelize} {get; set;}
+              EOS
+        end
+        out.puts "\n"
+        out.puts "public static void Encode(XdrDataOutputStream stream, #{name struct} encoded#{name struct}) {"
+        struct.members.each do |m|
+          out.indent do
+            encode_member "encoded#{name struct}", m, out
+          end
+        end
+        out.puts '}'
+
+        out.puts <<-EOS.strip_heredoc
+              public static #{name struct} Decode(XdrDataInputStream stream) {
+                #{name struct} decoded#{name struct} = new #{name struct}();
+            EOS
+        struct.members.each do |m|
+          out.indent do
+            decode_member "decoded#{name struct}", m, out
+          end
+        end
+        out.indent do
+          out.puts "return decoded#{name struct};"
+        end
+        out.puts '}'
+
+        out.break
+      end
+
+      def render_typedef(typedef, out)
+        out.puts <<-EOS.strip_heredoc
+              public #{decl_string typedef.declaration} InnerValue {get; set;} = default(#{decl_string typedef.declaration});
+
+              public #{typedef.name.camelize}() {}
+
+              public #{typedef.name.camelize}(#{decl_string typedef.declaration} value)
+              {
+                InnerValue = value;
+              }
+
+            EOS
+        out.puts "public static void Encode(XdrDataOutputStream stream, #{name typedef}  encoded#{name typedef}) {"
+        encode_innervalue_member "encoded#{name typedef}", typedef, out
+        out.puts '}'
+
+        out.puts <<-EOS.strip_heredoc
+              public static #{name typedef} Decode(XdrDataInputStream stream) {
+                #{name typedef} decoded#{name typedef} = new #{name typedef}();
+            EOS
+        decode_innervalue_member "decoded#{name typedef}", typedef, out
+        out.indent do
+          out.puts "return decoded#{name typedef};"
+        end
+        out.puts '}'
+      end
+
+      def render_union(union, out)
+        has_inner_value = false
+
+        out.puts "public #{name union} () {}"
+        out.puts <<-EOS.strip_heredoc
+
+              public #{type_string union.discriminant.type} Discriminant { get; set; } = new #{type_string union.discriminant.type}();
+
+            EOS
+        union.arms.each do |arm|
+          next if arm.void?
+          out.puts <<-EOS.strip_heredoc
+                public #{decl_string(arm.declaration)} #{arm.name.camelize} {get; set;}
+              EOS
+        end
+
+        out.puts "public static void Encode(XdrDataOutputStream stream, #{name union} encoded#{name union}) {"
+        if union.discriminant.type.is_a?(AST::Typespecs::Int)
+          out.puts "stream.WriteInt((int)encoded#{name union}.Discriminant);"
+          out.puts "switch (encoded#{name union}.Discriminant) {"
+        # elsif [discriminant is AST::Definitions::Typedef]
+        #   out.puts "stream.writeInt(encoded#{name union}.getDiscriminant().get#{name union.discriminant.type}());"
+        else
+          has_inner_value = true
+          out.puts "stream.WriteInt((int)encoded#{name union}.Discriminant.InnerValue);"
+          out.puts "switch (encoded#{name union}.Discriminant.InnerValue) {"
+        end
+
+        union.arms.each do |arm|
+          case arm
+          when AST::Definitions::UnionDefaultArm
+            out.puts 'default:'
+          else
+            arm.cases.each do |kase|
+              if kase.value.is_a?(AST::Identifier)
+                out.puts "case #{type_string union.discriminant.type}.#{type_string union.discriminant.type}Enum.#{kase.value.name}:"
+              else
+                out.puts "case #{kase.value.value}:"
+              end
+            end
+          end
+          encode_member "encoded#{name union}", arm, out
+          out.puts 'break;'
+        end
+        out.puts "}\n}"
+
+        out.puts "public static #{name union} Decode(XdrDataInputStream stream) {"
+        out.puts "#{name union} decoded#{name union} = new #{name union}();"
+        if union.discriminant.type.is_a?(AST::Typespecs::Int)
+          out.puts 'int discriminant =  stream.ReadInt();'
+          out.puts "decoded#{name union}.Discriminant = discriminant;"
+          out.puts "switch (decoded#{name union}.Discriminant) {"
+        else
+          out.puts "#{name union.discriminant.type} discriminant = #{name union.discriminant.type}.Decode(stream);"
+          out.puts "decoded#{name union}.Discriminant = discriminant;"
+          out.puts "switch (decoded#{name union}.Discriminant.InnerValue) {"
+        end
+
+        union.arms.each do |arm|
+          case arm
+          when AST::Definitions::UnionDefaultArm
+            out.puts 'default:'
+          else
+            arm.cases.each do |kase|
+              if kase.value.is_a?(AST::Identifier)
+                out.puts "case #{type_string union.discriminant.type}.#{type_string union.discriminant.type}Enum.#{kase.value.name}:"
+              else
+                out.puts "case #{kase.value.value}:"
+              end
+            end
+          end
+          decode_member "decoded#{name union}", arm, out
+          out.puts 'break;'
+        end
+        out.puts "}\n"
+        out.indent do
+          out.puts "return decoded#{name union};"
+        end
+        out.puts '}'
+
+        out.break
+      end
+
+      def render_top_matter(out)
+        out.puts <<-EOS.strip_heredoc
+              // Automatically generated by xdrgen
+              // DO NOT EDIT or your changes may be overwritten
+              using System;
+
+              namespace #{@namespace} {
+            EOS
+        out.break
+      end
+
+      def render_source_comment(out, defn)
+        return if defn.is_a?(AST::Definitions::Namespace)
+
+        out.puts <<-EOS.strip_heredoc
+            // === xdr source ============================================================
+
+            EOS
+
+        out.puts '//  ' + defn.text_value.split("\n").join("\n//  ")
+
+        out.puts <<-EOS.strip_heredoc
+
+            //  ===========================================================================
+            EOS
+      end
+
+      def encode_innervalue_member(value, member, out)
+        case member.declaration
+        when AST::Declarations::Void
+          return
+        end
+
+        if member.type.sub_type == :optional
+          out.puts "if (#{value}.InnerValue != null) {"
+          out.puts 'stream.WriteInt(1);'
+        end
+
+        case member.declaration
+        when AST::Declarations::Opaque
+          out.puts "int #{member.name}size = #{value}.InnerValue.Length;"
+          unless member.declaration.fixed?
+            out.puts "stream.WriteInt(#{member.name.camelize}size);"
+          end
+          out.puts <<-EOS.strip_heredoc
+                stream.Write(#{value}.InnerValue, 0, #{member.name}size);
+              EOS
+        when AST::Declarations::Array
+          out.puts "int #{member.name}size = #{value}.InnerValue.Length;"
+          unless member.declaration.fixed?
+            out.puts "stream.WriteInt(#{member.name}size);"
+          end
+          out.puts <<-EOS.strip_heredoc
+                for (int i = 0; i < #{member.name}size; i++) {
+                  #{encode_type member.declaration.type, "#{value}.InnerValue[i]"};
+                }
+              EOS
+        else
+          out.puts "#{encode_type member.declaration.type, "#{value}.InnerValue"};"
+        end
+        if member.type.sub_type == :optional
+          out.puts '} else {'
+          out.puts 'stream.WriteInt(0);'
+          out.puts '}'
+        end
+      end
+
+      def encode_member(value, member, out)
+        case member.declaration
+        when AST::Declarations::Void
+          return
+        end
+
+        if member.type.sub_type == :optional
+          out.puts "if (#{value}.#{member.name.camelize} != null) {"
+          out.puts 'stream.WriteInt(1);'
+        end
+        case member.declaration
+        when AST::Declarations::Opaque
+          out.puts "int #{member.name}size = #{value}.#{member.name.camelize}.Length;"
+          unless member.declaration.fixed?
+            out.puts "stream.WriteInt(#{member.name.camelize}size);"
+          end
+          out.puts <<-EOS.strip_heredoc
+                stream.Write(#{value}.#{member.name.camelize}, 0, #{member.name}size);
+              EOS
+        when AST::Declarations::Array
+          out.puts "int #{member.name}size = #{value}.#{member.name.camelize}.Length;"
+          unless member.declaration.fixed?
+            out.puts "stream.WriteInt(#{member.name}size);"
+          end
+          out.puts <<-EOS.strip_heredoc
+                for (int i = 0; i < #{member.name}size; i++) {
+                  #{encode_type member.declaration.type, "#{value}.#{member.name.camelize}[i]"};
+                }
+              EOS
+        else
+          out.puts "#{encode_type member.declaration.type, "#{value}.#{member.name.camelize}"};"
+        end
+        if member.type.sub_type == :optional
+          out.puts '} else {'
+          out.puts 'stream.WriteInt(0);'
+          out.puts '}'
+        end
+      end
+
+      def encode_type(type, value)
+        case type
+        when AST::Typespecs::Int
+          "stream.WriteInt(#{value})"
+        when AST::Typespecs::UnsignedInt
+          "stream.WriteInt(#{value})"
+        when AST::Typespecs::Hyper
+          "stream.WriteLong(#{value})"
+        when AST::Typespecs::UnsignedHyper
+          "stream.WriteLong(#{value})"
+        when AST::Typespecs::Float
+          "stream.WriteFloat(#{value})"
+        when AST::Typespecs::Double
+          "stream.WriteDouble(#{value})"
+        when AST::Typespecs::Quadruple
+          raise 'cannot render quadruple in c#'
+        when AST::Typespecs::Bool
+          "stream.WriteInt(#{value} ? 1 : 0)"
+        when AST::Typespecs::String
+          "stream.WriteString(#{value})"
+        when AST::Typespecs::Simple
+          "#{name type.resolved_type}.Encode(stream, #{value})"
+        when AST::Concerns::NestedDefinition
+          "#{name type}.Encode(stream, #{value})"
+        else
+          raise "Unknown typespec: #{type.class.name}"
+        end
+      end
+
+      def decode_innervalue_member(value, member, out)
+        case member.declaration
+        when AST::Declarations::Void
+          return
+        end
+        if member.type.sub_type == :optional
+          out.puts <<-EOS.strip_heredoc
+                int #{member.name.camelize}Present = stream.ReadInt();
+                if (#{member.name.camelize}Present != 0) {
+              EOS
+        end
+        case member.declaration
+        when AST::Declarations::Opaque
+          if member.declaration.fixed?
+            out.puts "int #{member.name}size = #{member.declaration.size};"
+          else
+            out.puts "int #{member.name}size = stream.ReadInt();"
+          end
+          out.puts <<-EOS.strip_heredoc
+                #{value}.InnerValue = new byte[#{member.name}size];
+                stream.Read(#{value}.InnerValue, 0, #{member.name}size);
+              EOS
+        when AST::Declarations::Array
+          if member.declaration.fixed?
+            out.puts "int #{member.name}size = #{member.declaration.size};"
+          else
+            out.puts "int #{member.name}size = stream.ReadInt();"
+          end
+          out.puts <<-EOS.strip_heredoc
+                #{value}.InnerValue = new #{type_string member.type}[#{member.name}size];
+                for (int i = 0; i < #{member.name}size; i++) {
+                  #{value}.InnerValue[i] = #{decode_type member.declaration.type};
+                }
+              EOS
+        else
+          out.puts "#{value}.InnerValue = #{decode_type member.declaration.type};"
+        end
+        out.puts '}' if member.type.sub_type == :optional
+      end
+
+      def decode_member(value, member, out)
+        case member.declaration
+        when AST::Declarations::Void
+          return
+        end
+        if member.type.sub_type == :optional
+          out.puts <<-EOS.strip_heredoc
+                int #{member.name.camelize}Present = stream.ReadInt();
+                if (#{member.name.camelize}Present != 0) {
+              EOS
+        end
+        case member.declaration
+        when AST::Declarations::Opaque
+          if member.declaration.fixed?
+            out.puts "int #{member.name}size = #{member.declaration.size};"
+          else
+            out.puts "int #{member.name}size = stream.ReadInt();"
+          end
+          out.puts <<-EOS.strip_heredoc
+                #{value}.#{member.name.camelize} = new byte[#{member.name}size];
+                stream.Read(#{value}.#{member.name.camelize},0,#{member.name}size);
+              EOS
+        when AST::Declarations::Array
+          if member.declaration.fixed?
+            out.puts "int #{member.name}size = #{member.declaration.size};"
+          else
+            out.puts "int #{member.name}size = stream.ReadInt();"
+          end
+          out.puts <<-EOS.strip_heredoc
+                #{value}.#{member.name.camelize} = new #{type_string member.type}[#{member.name}size];
+                for (int i = 0; i < #{member.name}size; i++) {
+                  #{value}.#{member.name.camelize}[i] = #{decode_type member.declaration.type};
+                }
+              EOS
+        else
+          out.puts "#{value}.#{member.name.camelize} = #{decode_type member.declaration.type};"
+        end
+        out.puts '}' if member.type.sub_type == :optional
+      end
+
+      def decode_type(type)
+        case type
+        when AST::Typespecs::Int
+          'stream.ReadInt()'
+        when AST::Typespecs::UnsignedInt
+          'stream.ReadInt()'
+        when AST::Typespecs::Hyper
+          'stream.ReadLong()'
+        when AST::Typespecs::UnsignedHyper
+          'stream.ReadLong()'
+        when AST::Typespecs::Float
+          'stream.ReadFloat()'
+        when AST::Typespecs::Double
+          'stream.ReadDouble()'
+        when AST::Typespecs::Quadruple
+          raise 'cannot render quadruple in c#'
+        when AST::Typespecs::Bool
+          'stream.ReadInt() == 1 ? true : false'
+        when AST::Typespecs::String
+          'stream.ReadString()'
+        when AST::Typespecs::Simple
+          "#{name type.resolved_type}.Decode(stream)"
+        when AST::Concerns::NestedDefinition
+          "#{name type}.Decode(stream)"
+        else
+          raise "Unknown typespec: #{type.class.name}"
+        end
+      end
+
+      def decl_string(decl)
+        case decl
+        when AST::Declarations::Opaque
+          'byte[]'
+        when AST::Declarations::String
+          'String'
+        when AST::Declarations::Array
+          "#{type_string decl.type}[]"
+        when AST::Declarations::Optional
+          type_string(decl.type).to_s
+        when AST::Declarations::Simple
+          type_string(decl.type)
+        else
+          raise "Unknown declaration type: #{decl.class.name}"
+        end
+      end
+
+      def type_string(type)
+        case type
+        when AST::Typespecs::Int
+          'int'
+        when AST::Typespecs::UnsignedInt
+          'int'
+        when AST::Typespecs::Hyper
+          'long'
+        when AST::Typespecs::UnsignedHyper
+          'long'
+        when AST::Typespecs::Float
+          'float'
+        when AST::Typespecs::Double
+          'double'
+        when AST::Typespecs::Quadruple
+          'Tuple'
+        when AST::Typespecs::Bool
+          'bool'
+        when AST::Typespecs::Opaque
+          "Byte[#{type.size}]"
+        when AST::Typespecs::Simple
+          name type.resolved_type
+        when AST::Concerns::NestedDefinition
+          name type
+        else
+          raise "Unknown typespec: #{type.class.name}"
+        end
+      end
+
+      def name(named)
+        parent = name named.parent_defn if named.is_a?(AST::Concerns::NestedDefinition)
+        result = named.name.camelize
+
+        "#{parent}#{result}"
+      end
+
+      def name_string(name)
+        name.camelize
+      end
+    end
+  end
+end

data/lib/xdrgen/generators/elixir.rb

@@ -164,7 +164,7 @@ module Xdrgen
         parent = name named.parent_defn if named.is_a?(AST::Concerns::NestedDefinition)
 
         # NOTE: classify will strip plurality, so we restore it if necessary
-        plural = named.name.downcase.pluralize == named.name.downcase
+        plural = named.name.underscore.downcase.pluralize == named.name.underscore.downcase
         base   = named.name.underscore.classify
         result = plural ? base.pluralize : base
 

data/lib/xdrgen/generators/java.rb

@@ -305,33 +305,77 @@ module Xdrgen
         out.puts <<-EOS.strip_heredoc
           @Override
           public boolean equals(Object object) {
-            if (object == null || !(object instanceof #{type})) {
+            if (!(object instanceof #{type})) {
               return false;
             }
 
             #{type} other = (#{type}) object;
             return #{equalExpression};
           }
+
         EOS
 
+        out.puts "public static final class Builder {"
+        out.indent do
+          struct.members.map { |m|
+            out.puts "private #{decl_string(m.declaration)} #{m.name};"
+          }
+
+          struct.members.map { |m|
+            out.puts <<-EOS.strip_heredoc
+
+              public Builder #{m.name}(#{decl_string(m.declaration)} #{m.name}) {
+                this.#{m.name} = #{m.name};
+                return this;
+              }
+            EOS
+          }
+
+        end
+
+
+        out.indent do
+          out.break
+          out.puts "public #{name struct} build() {"
+          out.indent do
+            out.puts "#{name struct} val = new #{name struct}();"
+            struct.members.map { |m|
+              out.puts "val.set#{m.name.slice(0,1).capitalize+m.name.slice(1..-1)}(#{m.name});"
+            }
+            out.puts "return val;"
+          end
+          out.puts "}"
+        end
+        out.puts "}"
         out.break
       end
 
       def render_typedef(typedef, out)
         out.puts <<-EOS.strip_heredoc
           private #{decl_string typedef.declaration} #{typedef.name};
+
+          public #{typedef.name.camelize}() {}
+
+          public #{typedef.name.camelize}(#{decl_string typedef.declaration} #{typedef.name}) {
+            this.#{typedef.name} = #{typedef.name};
+          }
+
           public #{decl_string typedef.declaration} get#{typedef.name.slice(0,1).capitalize+typedef.name.slice(1..-1)}() {
             return this.#{typedef.name};
           }
+
           public void set#{typedef.name.slice(0,1).capitalize+typedef.name.slice(1..-1)}(#{decl_string typedef.declaration} value) {
             this.#{typedef.name} = value;
           }
-        EOS
 
+        EOS
 
         out.puts "public static void encode(XdrDataOutputStream stream, #{name typedef}  encoded#{name typedef}) throws IOException {"
-        encode_member "encoded#{name typedef}", typedef, out
+        out.indent do
+          encode_member "encoded#{name typedef}", typedef, out
+        end
         out.puts "}"
+        out.break
 
         out.puts <<-EOS.strip_heredoc
           public void encode(XdrDataOutputStream stream) throws IOException {
@@ -343,11 +387,12 @@ module Xdrgen
           public static #{name typedef} decode(XdrDataInputStream stream) throws IOException {
             #{name typedef} decoded#{name typedef} = new #{name typedef}();
         EOS
-        decode_member "decoded#{name typedef}", typedef, out
         out.indent do
+          decode_member "decoded#{name typedef}", typedef, out
           out.puts "return decoded#{name typedef};"
         end
         out.puts "}"
+        out.break
 
         hash_coder_for_decl =
           if is_decl_array(typedef.declaration)
@@ -360,6 +405,7 @@ module Xdrgen
           public int hashCode() {
             return #{hash_coder_for_decl}(this.#{typedef.name});
           }
+
         EOS
 
         equals_for_decl =
@@ -372,7 +418,7 @@ module Xdrgen
         out.puts <<-EOS.strip_heredoc
           @Override
           public boolean equals(Object object) {
-            if (object == null || !(object instanceof #{type})) {
+            if (!(object instanceof #{type})) {
               return false;
             }
 
@@ -405,6 +451,54 @@ module Xdrgen
             }
           EOS
         end
+        out.break
+
+        out.puts "public static final class Builder {"
+        out.indent do
+          out.puts "private #{type_string union.discriminant.type} discriminant;"
+          union.arms.each do |arm|
+            next if arm.void?
+            out.puts "private #{decl_string(arm.declaration)} #{arm.name};"
+          end
+          out.break
+
+          out.puts <<-EOS.strip_heredoc
+            public Builder discriminant(#{type_string union.discriminant.type} discriminant) {
+              this.discriminant = discriminant;
+              return this;
+            }
+          EOS
+
+          union.arms.each do |arm|
+            next if arm.void?
+            out.puts <<-EOS.strip_heredoc
+
+              public Builder #{arm.name}(#{decl_string(arm.declaration)} #{arm.name}) {
+                this.#{arm.name} = #{arm.name};
+                return this;
+              }
+            EOS
+          end
+        end
+
+        out.indent do
+          out.break
+          out.puts "public #{name union} build() {"
+          out.indent do
+            out.puts "#{name union} val = new #{name union}();"
+            out.puts "val.setDiscriminant(discriminant);"
+            union.arms.each do |arm|
+              next if arm.void?
+              out.puts "val.set#{arm.name.slice(0,1).capitalize+arm.name.slice(1..-1)}(#{arm.name});"
+            end
+            out.puts "return val;"
+          end
+          out.puts "}"
+        end
+        out.puts "}"
+        out.break
+
+
         out.puts "public static void encode(XdrDataOutputStream stream, #{name union} encoded#{name union}) throws IOException {"
         out.puts('//' + union.discriminant.type.class.to_s)
         out.puts("//" + type_string(union.discriminant.type))
@@ -543,7 +637,7 @@ module Xdrgen
         out.puts <<-EOS.strip_heredoc
           @Override
           public boolean equals(Object object) {
-            if (object == null || !(object instanceof #{type})) {
+            if (!(object instanceof #{type})) {
               return false;
             }
 

data/lib/xdrgen/generators/javascript.rb

@@ -178,7 +178,7 @@ module Xdrgen
         #  "BEGIN_SPONSORING_FUTURE_RESERVEs" == "BEGIN_SPONSORING_FUTURE_RESERVES"
         #  => false
         #
-        plural = named.name.downcase.pluralize == named.name.downcase
+        plural = named.name.underscore.downcase.pluralize == named.name.underscore.downcase
         base   = named.name.underscore.classify
         result = plural ? base.pluralize : base
 

data/lib/xdrgen/version.rb

@@ -1,3 +1,3 @@
 module Xdrgen
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: xdrgen
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Scott Fleckenstein
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-06 00:00:00.000000000 Z
+date: 2021-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: treetop
@@ -136,7 +136,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - scott@stellar.org
 executables:
@@ -144,8 +144,8 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ruby.yml"
 - ".gitignore"
-- ".travis.yml"
 - Gemfile
 - Guardfile
 - LICENSE.txt
@@ -209,6 +209,7 @@ files:
 - lib/xdrgen/compilation.rb
 - lib/xdrgen/generators.rb
 - lib/xdrgen/generators/base.rb
+- lib/xdrgen/generators/csharp.rb
 - lib/xdrgen/generators/elixir.rb
 - lib/xdrgen/generators/go.rb
 - lib/xdrgen/generators/java.rb
@@ -258,7 +259,7 @@ homepage: http://github.com/stellar/xdrgen
 licenses:
 - ISC
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -273,8 +274,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.15
+signing_key:
 specification_version: 4
 summary: An XDR code generator
 test_files:

data/.travis.yml

@@ -1,4 +0,0 @@
-language: ruby
-script: bundle exec rspec
-rvm:
-- 2.7.0