protobuf 2.8.0.beta9 → 2.8.0

data/lib/protobuf/generators/enum_generator.rb

@@ -0,0 +1,31 @@
+require 'protobuf/generators/base'
+
+module Protobuf
+  module Generators
+    class EnumGenerator < Base
+
+      def compile
+        run_once(:compile) do
+          tags = []
+
+          print_class(descriptor.name, :enum) do
+            descriptor.value.each do |enum_value_descriptor|
+              tags << enum_value_descriptor.number
+              puts build_value(enum_value_descriptor)
+            end
+          end
+
+          self.class.validate_tags(fully_qualified_type_namespace, tags)
+        end
+      end
+
+      def build_value(enum_value_descriptor)
+        name = enum_value_descriptor.name
+        number = enum_value_descriptor.number
+        return "define :#{name}, #{number}"
+      end
+
+    end
+  end
+end
+

data/lib/protobuf/generators/extension_generator.rb

@@ -0,0 +1,28 @@
+require 'protobuf/generators/base'
+require 'protobuf/generators/group_generator'
+
+module Protobuf
+  module Generators
+    class ExtensionGenerator < Base
+
+      def initialize(message_type, field_descriptors, indent_level)
+        super(nil, indent_level)
+        @message_type = modulize(message_type)
+        @field_descriptors = field_descriptors
+      end
+
+      def compile
+        run_once(:compile) do
+          print_class(@message_type, :message) do
+            group = GroupGenerator.new(current_indent)
+            group.add_extension_fields(@field_descriptors)
+            group.order = [ :extension_field ]
+            print group.to_s
+          end
+        end
+      end
+
+    end
+  end
+end
+

data/lib/protobuf/generators/field_generator.rb

@@ -0,0 +1,132 @@
+require 'protobuf/generators/base'
+
+module Protobuf
+  module Generators
+    class FieldGenerator < Base
+
+      ##
+      # Constants
+      #
+      PROTO_INFINITY_DEFAULT          = /^inf$/i.freeze
+      PROTO_NEGATIVE_INFINITY_DEFAULT = /^-inf$/i.freeze
+      PROTO_NAN_DEFAULT               = /^nan$/i.freeze
+      RUBY_INFINITY_DEFAULT           = '::Float::INFINITY'.freeze
+      RUBY_NEGATIVE_INFINITY_DEFAULT  = '-::Float::INFINITY'.freeze
+      RUBY_NAN_DEFAULT                = '::Float::NAN'.freeze
+
+      ##
+      # Attributes
+      #
+      attr_reader :field_options
+
+      def applicable_options
+        @applicable_options ||= field_options.map { |k, v| ":#{k} => #{v}" }
+      end
+
+      def default_value
+        @default_value ||= begin
+                             if defaulted?
+                               case descriptor.type.name
+                               when :TYPE_ENUM then
+                                 enum_default_value
+                               when :TYPE_STRING, :TYPE_BYTES then
+                                 string_default_value
+                               when :TYPE_FLOAT, :TYPE_DOUBLE then
+                                 float_double_default_value
+                               else
+                                 verbatim_default_value
+                               end
+                             end
+                           end
+      end
+
+      def defaulted?
+        descriptor.respond_to_has_and_present?(:default_value)
+      end
+
+      def deprecated?
+        descriptor.options.try(:deprecated?) { false }
+      end
+
+      def extension?
+        descriptor.respond_to_has_and_present?(:extendee)
+      end
+
+      def compile
+        run_once(:compile) do
+          field_definition = [ "#{label} #{type_name}", name, number, applicable_options ]
+          puts field_definition.flatten.compact.join(', ')
+        end
+      end
+
+      def label
+        @label ||= descriptor.label.name.to_s.downcase.sub(/label_/, '') # required, optional, repeated
+      end
+
+      def name
+        @name ||= ":#{descriptor.name}"
+      end
+
+      def number
+        @number ||= descriptor.number
+      end
+
+      def field_options
+        @field_options ||= begin
+                             opts = {}
+                             opts[:default] = default_value if defaulted?
+                             opts[:packed] = 'true' if packed?
+                             opts[:deprecated] = 'true' if deprecated?
+                             opts[:extension] = 'true' if extension?
+                             opts
+                           end
+      end
+
+      def packed?
+        descriptor.options.try(:packed?) { false }
+      end
+
+      # Determine the field type
+      def type_name
+        @type_name ||= begin
+                         case descriptor.type.name
+                         when :TYPE_MESSAGE, :TYPE_ENUM, :TYPE_GROUP then
+                           type_name = modulize(descriptor.type_name)
+                         else
+                           type_name = descriptor.type.name.to_s.downcase.sub(/type_/, '')
+                           type_name = "::Protobuf::Field::#{modulize(type_name)}Field"
+                         end
+                       end
+      end
+
+      private
+
+      def enum_default_value
+        "#{type_name}::#{verbatim_default_value}"
+      end
+
+      def float_double_default_value
+        case verbatim_default_value
+        when PROTO_INFINITY_DEFAULT then
+          RUBY_INFINITY_DEFAULT
+        when PROTO_NEGATIVE_INFINITY_DEFAULT then
+          RUBY_NEGATIVE_INFINITY_DEFAULT
+        when PROTO_NAN_DEFAULT then
+          RUBY_NAN_DEFAULT
+        else
+          verbatim_default_value
+        end
+      end
+
+      def string_default_value
+        %Q{"#{verbatim_default_value.gsub(/'/, '\\\\\'')}"}
+      end
+
+      def verbatim_default_value
+        descriptor.default_value
+      end
+
+    end
+  end
+end
+

data/lib/protobuf/generators/file_generator.rb

@@ -0,0 +1,140 @@
+require 'set'
+require 'protobuf/generators/base'
+require 'protobuf/generators/group_generator'
+
+module Protobuf
+  module Generators
+    class FileGenerator < Base
+
+      attr_reader :output_file
+
+      def initialize(*args)
+        super
+        @output_file = ::Google::Protobuf::Compiler::CodeGeneratorResponse::File.new(:name => file_name)
+        @extension_fields = Hash.new { |h, k| h[k] = [] }
+        @known_messages = []
+        @dangling_messages = {}
+      end
+
+      def file_name
+        convert_filename(descriptor.name, false)
+      end
+
+      def compile
+        run_once(:compile) do
+          map_extensions(descriptor, [ descriptor.package ])
+          extract_dangling_extensions
+
+          print_file_comment
+          print_generic_requires
+          print_import_requires
+
+          print_package do
+            group = GroupGenerator.new(current_indent)
+            group.add_enums(descriptor.enum_type, :namespace => [ descriptor.package ])
+            group.add_message_declarations(descriptor.message_type)
+            group.add_messages(descriptor.message_type, :extension_fields => @extension_fields, :namespace => [ descriptor.package ])
+            group.add_extended_messages(@unknown_extensions)
+            group.add_services(descriptor.service)
+
+            group.add_header(:enum, 'Enum Classes')
+            group.add_header(:message_declaration, 'Message Classes')
+            group.add_header(:message, 'Message Fields')
+            group.add_header(:extended_message, 'Extended Message Fields')
+            group.add_header(:service, 'Service Classes')
+            print group.to_s
+          end
+
+        end
+      end
+
+      def extract_dangling_extensions
+        @unknown_extensions = @extension_fields.select do |k, v|
+          ! @known_messages.include?(k)
+        end
+      end
+
+      def generate_output_file
+        compile
+        output_file.content = to_s
+        output_file
+      end
+
+      # Recursively map out all extensions known in this file.
+      # The key is the type_name of the message being extended, and
+      # the value is an array of field descriptors.
+      #
+      def map_extensions(descriptor, namespaces)
+        # Record all the message descriptor name's we encounter (should be the whole tree).
+        if descriptor.is_a?(::Google::Protobuf::DescriptorProto)
+          if fully_qualified_token?(descriptor.name)
+            @known_messages << descriptor.name
+          else
+            fully_qualified_namespace = ".#{namespaces.join('.')}"
+            @known_messages << fully_qualified_namespace
+          end
+        end
+
+        descriptor.extension.each do |field_descriptor|
+          @extension_fields[field_descriptor.extendee] << field_descriptor
+        end
+
+        if descriptor.respond_to_has_and_present?(:message_type)
+          descriptor.message_type.each do |message_descriptor|
+            map_extensions(message_descriptor, (namespaces + [ message_descriptor.name ]))
+          end
+        end
+
+        if descriptor.respond_to_has_and_present?(:nested_type)
+          descriptor.nested_type.each do |nested_descriptor|
+            map_extensions(nested_descriptor, (namespaces + [ nested_descriptor.name ]))
+          end
+        end
+      end
+
+      def print_file_comment
+        puts "##"
+        puts "# This file is auto-generated. DO NOT EDIT!"
+        puts "#"
+      end
+
+      def print_generic_requires
+        print_require("protobuf/message")
+        print_require("protobuf/rpc/service") if descriptor.service.count > 0
+        puts
+      end
+
+      def print_import_requires
+        if descriptor.dependency.count > 0
+          header "Imports"
+
+          descriptor.dependency.each do |dependency|
+            print_require(convert_filename(dependency))
+          end
+
+          puts
+        end
+      end
+
+      def print_package(&block)
+        final = lambda { block.call }
+        namespaces = descriptor.package.split('.')
+        namespaces.reverse.inject(final) { |previous, namespace|
+          lambda { print_module(namespace, &previous) }
+        }.call
+      end
+
+      private
+
+      def convert_filename(filename, for_require = true)
+        filename.sub(/\.proto/, (for_require ? '.pb' : '.pb.rb'))
+      end
+
+      def fully_qualified_token?(token)
+        token[0] == '.'
+      end
+
+    end
+  end
+end
+

data/lib/protobuf/generators/group_generator.rb

@@ -0,0 +1,113 @@
+require 'protobuf/generators/enum_generator'
+require 'protobuf/generators/extension_generator'
+require 'protobuf/generators/field_generator'
+require 'protobuf/generators/message_generator'
+require 'protobuf/generators/service_generator'
+
+module Protobuf
+  module Generators
+    class GroupGenerator
+      include ::Protobuf::Generators::Printable
+
+      attr_reader :groups, :indent_level
+      attr_writer :order
+
+      def initialize(indent_level = 0)
+        @groups = Hash.new { |h, k| h[k] = [] }
+        @headers = {}
+        @comments = {}
+        @handlers = {}
+        @indent_level = indent_level
+        @order = [ :enum, :message_declaration, :message, :extended_message, :service ]
+        init_printer(indent_level)
+      end
+
+      def add_enums(enum_descriptors, options)
+        enum_descriptors.each do |enum_descriptor|
+          @groups[:enum] << EnumGenerator.new(enum_descriptor, indent_level, options)
+        end
+      end
+
+      def add_comment(type, message)
+        @comments[type] = message
+      end
+
+      def add_extended_messages(extended_messages)
+        extended_messages.each do |message_type, field_descriptors|
+          @groups[:extended_message] << ExtensionGenerator.new(message_type, field_descriptors, indent_level)
+        end
+      end
+
+      def add_extension_fields(field_descriptors)
+        field_descriptors.each do |field_descriptor|
+          @groups[:extension_field] << FieldGenerator.new(field_descriptor, indent_level)
+        end
+      end
+
+      def add_extension_ranges(extension_ranges, &item_handler)
+        @groups[:extension_range] = extension_ranges
+        @handlers[:extension_range] = item_handler
+      end
+
+      def add_header(type, message)
+        @headers[type] = message
+      end
+
+      def add_message_declarations(descriptors)
+        descriptors.each do |descriptor|
+          @groups[:message_declaration] << MessageGenerator.new(descriptor, indent_level, :declaration => true)
+        end
+      end
+
+      def add_message_fields(field_descriptors)
+        field_descriptors.each do |field_descriptor|
+          @groups[:field] << FieldGenerator.new(field_descriptor, indent_level)
+        end
+      end
+
+      def add_messages(descriptors, options = {})
+        descriptors.each do |descriptor|
+          @groups[:message] << MessageGenerator.new(descriptor, indent_level, options)
+        end
+      end
+
+      def add_services(service_descriptors)
+        service_descriptors.each do |service_descriptor|
+          @groups[:service] << ServiceGenerator.new(service_descriptor, indent_level)
+        end
+      end
+
+      def compile
+        @order.each do |type|
+          items = @groups[type]
+          if items.count > 0
+            item_handler = @handlers[type]
+
+            item_header = @headers[type]
+            header(item_header) if item_header
+
+            item_comment = @comments[type]
+            comment(item_comment) if item_comment
+
+            items.each do |item|
+              if item_handler
+                puts item_handler.call(item)
+              else
+                print item.to_s
+              end
+            end
+
+            puts if type == :message_declaration
+          end
+        end
+      end
+
+      def to_s
+        compile
+        print_contents
+      end
+
+    end
+  end
+end
+