protobuf 2.8.0.beta9 → 2.8.0

data/lib/protobuf/generators/message_generator.rb

@@ -0,0 +1,99 @@
+require 'protobuf/generators/base'
+require 'protobuf/generators/group_generator'
+
+module Protobuf
+  module Generators
+    class MessageGenerator < Base
+
+      def initialize(descriptor, indent_level, options = {})
+        super
+        @only_declarations = options.fetch(:declaration) { false }
+        @extension_fields = options.fetch(:extension_fields) { {} }
+      end
+
+      def compile
+        run_once(:compile) do
+          if @only_declarations
+            compile_declaration
+          else
+            compile_message
+          end
+        end
+      end
+
+      def compile_declaration
+        run_once(:compile_declaration) do
+          if is_printable?
+            print_class(descriptor.name, :message) do
+              group = GroupGenerator.new(current_indent)
+              group.add_enums(descriptor.enum_type, :namespace => type_namespace)
+              group.add_message_declarations(descriptor.nested_type)
+              print group.to_s
+            end
+          else
+            print_class(descriptor.name, :message)
+          end
+        end
+      end
+
+      def compile_message
+        run_once(:compile_message) do
+          if is_printable?
+            print_class(descriptor.name, nil) do
+              group = GroupGenerator.new(current_indent)
+              group.add_messages(descriptor.nested_type, :extension_fields => @extension_fields, :namespace => type_namespace)
+              group.add_message_fields(descriptor.field)
+              self.class.validate_tags(fully_qualified_type_namespace, descriptor.field.map(&:number))
+
+              group.add_comment(:extension_range, 'Extension Fields')
+              group.add_extension_ranges(descriptor.extension_range) do |extension_range|
+                "extensions #{extension_range.start}...#{extension_range.end}"
+              end
+
+              group.add_extension_fields(message_extension_fields)
+
+              group.order = [ :message, :field, :extension_range, :extension_field ]
+              print group.to_s
+            end
+          end
+        end
+      end
+
+      private
+
+      def has_extensions?
+        ! message_extension_fields.empty?
+      end
+
+      def has_fields?
+        descriptor.field.count > 0
+      end
+
+      def has_nested_enums?
+        descriptor.enum_type.count > 0
+      end
+
+      def has_nested_messages?
+        descriptor.nested_type.count > 0
+      end
+
+      def has_nested_types?
+        has_nested_enums? || has_nested_messages?
+      end
+
+      def is_printable?
+        if @only_declarations
+          has_nested_types?
+        else
+          has_fields? || has_nested_messages? || has_extensions?
+        end
+      end
+
+      def message_extension_fields
+        @extension_fields.fetch(fully_qualified_type_namespace) { [] }
+      end
+
+    end
+  end
+end
+

data/lib/protobuf/generators/printable.rb

@@ -0,0 +1,161 @@
+module Protobuf
+  module Generators
+    module Printable
+
+      PARENT_CLASS_MESSAGE = "::Protobuf::Message".freeze
+      PARENT_CLASS_ENUM    = "::Protobuf::Enum".freeze
+      PARENT_CLASS_SERVICE = "::Protobuf::Rpc::Service".freeze
+
+      # Initialize the printer.
+      # Must be called by any class/module that includes the Printable module.
+      #
+      def init_printer(indent_level)
+        @io = ::StringIO.new
+        @_indent_level = indent_level.to_i || 0
+      end
+
+      private
+
+      # Print a one-line comment.
+      #
+      def comment(message)
+        puts "# #{message}"
+      end
+
+      def current_indent
+        @_indent_level
+      end
+
+      # Print a "header" comment.
+      #
+      #   header("Lorem ipsum dolor")
+      #   ##
+      #   # Lorem ipsum dolor
+      #   #
+      def header(message)
+        puts
+        puts "##"
+        puts "# #{message}"
+        puts "#"
+      end
+
+      # Increase the indent level. An outdent will only occur if given a block
+      # (after the block is finished).
+      #
+      def indent
+        @_indent_level += 1
+        yield
+        outdent
+      end
+
+      # Take a string and upcase the first character of each namespace.
+      # Due to the nature of varying standards about how class/modules are named
+      # (e.g. CamelCase, Underscore_Case, SCREAMING_SNAKE_CASE), we only want
+      # to capitalize the first character to ensure ruby will treat the value
+      # as a constant. Otherwise we do not attempt to change the
+      # token's definition.
+      #
+      #   modulize("foo.bar.Baz") -> "::Foo::Bar::Baz"
+      #   modulize("foo.bar.baz") -> "::Foo::Bar::Baz"
+      #   modulize("foo.bar.BAZ") -> "::Foo::Bar::BAZ"
+      #
+      def modulize(name)
+        name = name.gsub(/\./, '::')
+        name = name.gsub(/(^(?:::)?[a-z]|::[a-z])/) { |match| match.upcase }
+        name
+      end
+
+      # Decrease the indent level. Cannot be negative.
+      #
+      def outdent
+        @_indent_level -= 1 unless @_indent_level == 0
+      end
+
+      # Return the parent class for a given type.
+      # Valid types are :message, :enum, and :service, otherwise an error
+      # will be thrown.
+      #
+      def parent_class(type)
+        case type
+        when :message then
+          PARENT_CLASS_MESSAGE
+        when :enum then
+          PARENT_CLASS_ENUM
+        when :service then
+          PARENT_CLASS_SERVICE
+        else
+          raise "Unknown parent class type #{type}: #{caller[0..5].join("\n")}"
+        end
+      end
+
+      # Print a class or module block, indicated by type.
+      # If a class, can be given a parent class to inherit from.
+      # If a block is given, call the block from within an indent block.
+      # Otherwise, end the block on the same line.
+      #
+      def print_block(name, parent_klass, type, &block)
+        name = modulize(name)
+        block_def = "#{type} #{name}"
+        block_def += " < #{parent_class(parent_klass)}" if parent_klass
+
+        if block_given?
+          puts block_def
+          indent { block.call }
+          puts "end"
+          puts
+        else
+          block_def += "; end"
+          puts block_def
+        end
+      end
+
+      # Use print_block to print a class, with optional parent class
+      # to inherit from. Accepts a block for use with print_block.
+      #
+      def print_class(name, parent_klass, &block)
+        print_block(name, parent_klass, :class, &block)
+      end
+
+      # Use print_block to print a module.
+      # Accepts a block for use with print_block.
+      #
+      def print_module(name, &block)
+        print_block(name, nil, :module, &block)
+      end
+
+      # Print a file require.
+      #
+      #   print_require('foo/bar/baz') -> "require 'foo/bar/baz'"
+      #
+      def print_require(file)
+        puts "require '#{file}'"
+      end
+
+      # Puts the given message prefixed by the indent level.
+      # If no message is given print a newline.
+      #
+      def puts(message = nil)
+        if message
+          @io.puts(("  " * @_indent_level) + message)
+        else
+          @io.puts
+        end
+      end
+
+      # Print the given message raw, no indent.
+      #
+      def print(contents)
+        @io.print(contents)
+      end
+
+      # Returns the contents of the underlying StringIO object.
+      #
+      def print_contents
+        @io.rewind
+        @io.read
+      end
+
+    end
+  end
+end
+

data/lib/protobuf/generators/service_generator.rb

@@ -0,0 +1,27 @@
+require 'protobuf/generators/base'
+
+module Protobuf
+  module Generators
+    class ServiceGenerator < Base
+
+      def compile
+        run_once(:compile) do
+          print_class(descriptor.name, :service) do
+            descriptor.method.each do |method_descriptor|
+              puts build_method(method_descriptor)
+            end
+          end
+        end
+      end
+
+      def build_method(method_descriptor)
+        name = method_descriptor.name
+        request_klass = modulize(method_descriptor.input_type)
+        response_klass = modulize(method_descriptor.output_type)
+        return "rpc :#{name.underscore}, #{request_klass}, #{response_klass}"
+      end
+
+    end
+  end
+end
+

data/lib/protobuf/lifecycle.rb

@@ -9,16 +9,20 @@ module Protobuf
       lifecycle_events[ event_name ] << blk
     end
 
-    def self.trigger( event_name )
+    def self.trigger( event_name, *args )
       event_name = normalized_event_name( event_name )
 
       if lifecycle_events.has_key?( event_name )
         lifecycle_events[ event_name ].each do |block|
-          block.call
+          if ! args.empty? && block.arity != 0
+            block.call(*args)
+          else
+            block.call
+          end
         end
       end
     end
-    
+
     def self.normalized_event_name( event_name )
       return "#{event_name}".downcase
     end

data/lib/protobuf/message.rb

@@ -1,3 +1,4 @@
+require 'stringio'
 require 'set'
 require 'protobuf/field'
 require 'protobuf/enum'
@@ -22,6 +23,10 @@ module Protobuf
                       end
     end
 
+    def self.decode(bytes)
+      self.new.decode(bytes)
+    end
+
     # Define a field. Don't use this method directly.
     def self.define_field(rule, type, fname, tag, options)
       field_array = options[:extension] ? extension_fields : fields
@@ -46,6 +51,11 @@ module Protobuf
       end
     end
 
+    # Create a new object with the given values and return the encoded bytes.
+    def self.encode(values = {})
+      self.new(values).encode
+    end
+
     # Reserve field numbers for extensions. Don't use this method directly.
     def self.extensions(range)
       extension_fields.add_range(range)
@@ -92,7 +102,7 @@ module Protobuf
     # Find a field object by +tag+ number.
     def self.get_field_by_tag(tag)
       fields[tag]
-    rescue TypeError => e
+    rescue TypeError
       tag = tag.nil? ? 'nil' : tag.to_s
       raise FieldNotDefinedError.new("Tag '#{tag}' does not reference a message field for '#{self.name}'")
     end
@@ -144,6 +154,16 @@ module Protobuf
       copy_to(super, :clone)
     end
 
+    # Decode the given string bytes into this object.
+    def decode(string)
+      decode_from(::StringIO.new(string))
+    end
+
+    # Decode the given stream into this object.
+    def decode_from(stream)
+      Decoder.decode(stream, self)
+    end
+
     def dup
       copy_to(super, :dup)
     end
@@ -174,6 +194,28 @@ module Protobuf
       end
     end
 
+    def encode
+      stream = ""
+
+      each_field_for_serialization do |field, value|
+        if field.repeated?
+          if field.packed?
+            key = (field.tag << 3) | ::Protobuf::WireType::LENGTH_DELIMITED
+            packed_value = value.map { |val| field.encode(val) }.join
+            stream << ::Protobuf::Field::VarintField.encode(key)
+            stream << ::Protobuf::Field::VarintField.encode(packed_value.size)
+            stream << packed_value
+          else
+            value.each { |val| write_pair(stream, field, val) }
+          end
+        else
+          write_pair(stream, field, value)
+        end
+      end
+
+      return stream
+    end
+
     # Returns extension fields. See Message#fields method.
     def extension_fields
       self.class.extension_fields
@@ -209,14 +251,6 @@ module Protobuf
       to_hash.inspect
     end
 
-    def parse_from(stream)
-      Decoder.decode(stream, self)
-    end
-
-    def parse_from_string(string)
-      parse_from(StringIO.new(string))
-    end
-
     def respond_to_has?(key)
       self.respond_to?(key) && self.has_field?(key)
     end
@@ -226,28 +260,6 @@ module Protobuf
         (self.__send__(key).present? || [true, false].include?(self.__send__(key)))
     end
 
-    def serialize_to_string
-      stream = ""
-
-      each_field_for_serialization do |field, value|
-        if field.repeated?
-          if field.packed?
-            key = (field.tag << 3) | ::Protobuf::WireType::LENGTH_DELIMITED
-            packed_value = value.map { |val| field.encode(val) }.join
-            stream << ::Protobuf::Field::VarintField.encode(key)
-            stream << ::Protobuf::Field::VarintField.encode(packed_value.size)
-            stream << packed_value
-          else
-            value.each { |val| write_pair(stream, field, val) }
-          end
-        else
-          write_pair(stream, field, value)
-        end
-      end
-
-      return stream
-    end
-
     def set_field(tag, bytes)
       field = (get_field_by_tag(tag) || get_ext_field_by_tag(tag))
       field.set(self, bytes) if field
@@ -297,11 +309,16 @@ module Protobuf
     ##
     # Instance Aliases
     #
+    alias_method :parse_from_string, :decode
+    alias_method :deserialize, :decode
+    alias_method :parse_from, :decode_from
+    alias_method :deserialize_from, :decode_from
+    alias_method :to_s, :encode
+    alias_method :bytes, :encode
+    alias_method :serialize, :encode
+    alias_method :serialize_to_string, :encode
     alias_method :to_hash_value, :to_hash
     alias_method :to_proto_hash, :to_hash
-    alias_method :to_s, :serialize_to_string
-    alias_method :bytes, :serialize_to_string
-    alias_method :serialize, :serialize_to_string
     alias_method :responds_to_has?, :respond_to_has?
     alias_method :respond_to_and_has?, :respond_to_has?
     alias_method :responds_to_and_has?, :respond_to_has?