protojson 0.1.0

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in protojson.gemspec
+gemspec
+
+gem 'ruby_protobuf', '~>0.4.10'
+gem 'activesupport', '~>3.0.5'
+gem 'i18n', '~>0.5.0'
+

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2011 Juan de Bravo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,61 @@
+
+# Introduction
+
+A Ruby gem for Google's Protocol Buffers messages using three different encodings JSON based syntax instead of the
+original binary protocol.
+
+This gem extends the *ruby_protobuf* gem [1] to allow these new encodings in a protocol buffer message:
+
+- [1] ruby_protobuf gem: [link to github project](https://github.com/macks/ruby-protobuf)
+
+- [2] [ProtoJson specification](https://github.com/drslump/ProtoJson) by [DrSlump](https://github.com/drslump)
+
+# Installation
+
+    gem install protojson
+
+# Supported formats
+
+- *Hashmap*: A tipical JSON message, with key:value pairs where the key is a string representing the field name.
+
+- *Tagmap*: Very similar to Hashmap, but instead of having the field name as key it has the field tag number
+as defined in the proto definition. This can save much space when transferring the messages, since usually field names
+are longer than numbers.
+
+- *Indexed*: Takes the Tagmap format a further step and optimizes the size needed for tag numbers by packing all of them
+as a string, where each character represents a tag, and placing it as the first element of an array.
+
+
+# How to use
+
+## Serialize a message
+
+    require 'addressbook.pb'
+    require 'protojson'
+    person = Tutorial::Person.new
+    person.parse_from_file ARGV[0]
+
+    Protobuf::Message::encoding = Protobuf::Message::EncodingType::INDEXED
+
+    value = person.serialize_to_string
+
+    puts value
+
+## Parse a message
+
+    require 'addressbook.pb'
+    require 'protojson'
+
+    person = Tutorial::Person.new
+    person.parse_from_file ARGV[0]
+
+    Protobuf::Message::encoding = Protobuf::Message::EncodingType::INDEXED
+
+    value = person.serialize_to_string
+
+    person = Tutorial::Person.new
+
+    person.parse_from_string(value)
+
+    p person
+

data/Rakefile

@@ -0,0 +1,20 @@
+require 'bundler'
+require 'rake/rdoctask'
+require 'rake/clean'
+
+Bundler::GemHelper.install_tasks
+
+desc "Show the different encodings using a test file"
+namespace :test do
+  task :person do
+    sh "ruby spec/main.rb spec/person"
+  end
+end
+
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.md"
+  rd.rdoc_files.include("README.md", "LICENSE", "lib/**/*.rb")
+  rd.title = 'ProtoJson'
+end
+

data/lib/extensions/protobuf/message.rb

@@ -0,0 +1,262 @@
+require 'active_support/core_ext'
+
+#
+# This is an extension of Protobud::Message class
+# which aims to support both JSON and INDEXED formats.
+#
+# Author:: Juan de Bravo  (juandebravo@gmail.com, juan@pollinimini.net)
+# Author:: Ivan -DrSlump- Montes (drslump@pollinimini.net)
+# License::  --
+#
+module Protobuf
+
+  class Message
+
+    # Enum type that defines the supported encodings
+    #  - Binary
+    #  - Hashmap
+    #  - Indexed
+    #  - Indexed
+    module EncodingType
+      BINARY = 0,
+      HASHMAP = 1,
+      TAGMAP = 2,
+      INDEXED = 3
+    end
+
+    # static variable to define the specific encoding to be used.
+    # By default, use the primitive encoding type (BINARY)
+    @@encoding = Protobuf::Message::EncodingType::BINARY
+
+    # encoding setter
+    def self.encoding=(encoding)
+      @@encoding = encoding
+    end
+
+    # encoding getter
+    def self.encoding
+      @@encoding
+    end
+
+    # Encode the message to a hash object defined as a collection for key/values
+    # where each element has:
+    # - key: field tag
+    # - value:
+    #  - if field.is_a? message_field => field.value.serialized_to_hash
+    #  - if field.is_a? enum_field    => field.value.value
+    #  - else                         => field.value
+    #    
+    # @return [Hash] a specific Message encoded in an Hash object
+    def serialize_to_hash(encoding_key = :tag)
+      raise NotInitializedError unless self.initialized?
+      # var to store the encoded message fields
+      result = {}
+
+      # lambda function that extract the field tag and value
+      # it's called recursively if value is a MessageField
+      field_value_to_string = lambda { |field, value|
+        field_value = \
+          if field.optional? && !self.has_field?(field.name)
+                                  ''
+          else
+            case field
+              when Field::MessageField
+                if value.nil?
+                  nil
+                else
+                  value.serialize_to_hash(encoding_key)
+                end
+              when Field::EnumField
+                if value.is_a?(EnumValue)
+                  value.value
+                else
+                  value.to_i
+                end
+              else
+                value
+            end
+          end
+        return field.send(encoding_key), field_value
+      }
+
+      # per each message field create a new element in result var with
+      # key = field.tag and value = field.value
+      self.each_field do |field, value|
+        # create a vector if field is repeated
+        if field.repeated? && !value.empty?
+          key_value = []
+          key = nil
+          value.each do |v|
+            key, val = field_value_to_string.call(field, v) # always return the same key
+            key_value.push val
+          end
+          # field is not repeated but is not empty
+        elsif !field.repeated?
+          key, key_value = field_value_to_string.call(field, value)
+          # empty field, discard
+        else
+          next
+        end
+        # new element in result Hash
+        result[key.to_s] = key_value
+      end
+      result
+    end
+
+    # allow new serialization, not only binary
+    alias :serialize_to_string_old :serialize_to_string
+
+    # This method is used to serialize the message to a specific format
+    # based on the class variable *encoding*
+    def serialize_to_string(string='')
+      case @@encoding
+        when EncodingType::BINARY # primitive format
+          serialize_to_string_old(string)
+        when EncodingType::HASHMAP # JSON format with key = field.name
+          serialize_to_json(:name)
+        when EncodingType::TAGMAP # JSON format with key = field.tag
+          serialize_to_json(:tag)
+        when EncodingType::INDEXED # INDEXED format
+          serialize_to_indexed
+        else
+          raise ArgumentError, "Invalid encoding type"
+      end
+    end
+
+    # This method serializes the message in JSON format
+    def serialize_to_json(encoding_key = :tag)
+      serialize_to_hash(encoding_key).to_json
+    end
+
+    # This method serializes the message in INDEXED format
+    def serialize_to_indexed
+      data = serialize_to_hash
+      self.class.serialize_hash_to_indexed(data).to_json
+    end
+
+    # This class method serializes a Hash
+    def self.serialize_hash_to_indexed(value)
+      !value.is_a?(Hash) and raise ArgumentError, "value must be a hash"
+      # index value
+      index = ""
+      index.respond_to?(:force_encoding) and index.force_encoding("UTF-8") # 1.9.2
+      # field values
+      result = []
+      value.each_pair { |key, value|
+        index << key.to_i+48 # ASCII integer. 1 => 49, ...
+        # recursive call if value is a Hash
+        if value.is_a?(Hash)
+          value = self.class.serialize_hash_to_indexed(value)
+          # array => serializes each element
+        elsif value.is_a?(Array)
+          value.map! { |val|
+            if val.is_a?(Hash)
+              serialize_hash_to_indexed(val)
+            else
+              val
+            end
+          }
+        end
+        # insert encoded value in Array
+        result.push value
+      }
+      # include index as first element
+      result.unshift(index)
+    end
+
+    # This method parses a JSON encoded message to the self.class object
+    def parse_from_json(data, decoding_key = :tag)
+      # decode if data is JSON
+      data.is_a?(String) and data = ActiveSupport::JSON.decode(data)
+
+      # per each hash element:
+      data.each_pair { |key, value|
+        key = decoding_key.eql?(:tag) ? key.to_i : key.to_s
+
+        #  get the field object using the key (field tag)
+        #field = self.get_field_by_tag(key.to_i)
+        field = self.send("get_field_by_#{decoding_key}".to_sym, key)
+
+        if field.nil?
+          # ignore unknown field
+        elsif field.repeated?
+          # create the element
+          array = self.__send__(field.name)
+          value.each { |val|
+          # if value is a complex field, create the object and parse the content
+            if field.is_a?(Protobuf::Field::MessageField)
+              instance = field.type.new
+              val = instance.parse_from_json(val, decoding_key)
+            end
+            # include each element in the parent element field
+            array.push(val)
+          }
+        else
+          # if value is a complex field, create the object and parse the content
+          if field.is_a?(Protobuf::Field::MessageField)
+            instance = field.type.new
+            value = instance.parse_from_json(value, decoding_key)
+          end
+          # set the message field
+          self.__send__("#{field.name}=", value)
+        end
+      }
+      self
+    end
+
+    # This method parses a INDEXED encoded message to a hash using
+    # klass message as model.
+    # We need to know the specific klass to decode to differenciate between
+    # vectors and message fields
+    def self.parse_indexed_to_hash(data, klass)
+      values = {}
+      index = data.shift
+      index.each_codepoint { |tag|
+        tag = tag-48
+        field = klass.get_field_by_tag(tag)
+        val = data.shift
+
+        if val.is_a?(Array) && field.is_a?(Protobuf::Field::MessageField)
+          if field.repeated?
+            val.map! { |v|
+              v = self.parse_indexed_to_hash(v, field.type)
+            }
+          else
+            val = self.parse_indexed_to_hash(val, field.type)
+          end
+        end
+        values[tag.to_s] = val
+      }
+      values
+    end
+
+    # This method parses a INDEXED encoded message to a hash using
+    # self.class message as model.
+    def parse_from_indexed(data)
+      # decode if data is JSON
+      data.is_a?(String) and data = ActiveSupport::JSON.decode(data)
+      values = self.class.parse_indexed_to_hash(data, self)
+      parse_from_json(values)
+    end
+
+    # allow new parsing, not only binary
+    alias :parse_from_string_old :parse_from_string
+
+    # This method is used to parse the message from a specific format
+    # based on the class variable *encoding*
+    def parse_from_string(string)
+      case @@encoding
+        when EncodingType::BINARY
+          parse_from_string_old(string)
+        when EncodingType::HASHMAP
+          parse_from_json(string, :name)
+        when EncodingType::TAGMAP
+          parse_from_json(string, :tag)
+        when EncodingType::INDEXED
+          parse_from_indexed(string)
+        else
+          raise ArgumentError, "Invalid encoding type"
+      end
+    end
+  end
+end

data/lib/protojson/version.rb

@@ -0,0 +1,3 @@
+module Protojson
+  VERSION = "0.1.0"
+end

data/lib/protojson.rb

@@ -0,0 +1,6 @@
+require 'protobuf/message/message'
+require 'extensions/protobuf/message'
+
+module Protojson
+  # Your code goes here...
+end

data/protojson.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "protojson/version"
+
+Gem::Specification.new do |s|
+  s.name        = "protojson"
+  s.version     = Protojson::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Juan de Bravo", "Ivan -DrSlump- Montes"]
+  s.email       = ["juandebravo@gmail.com", "drslump@pollinimini.net"]
+  s.homepage    = ""
+  s.summary     = %q{Ruby extension to ruby-protobuf to enable three new encodings}
+  s.description = %q{A Ruby gem for Google's Protocol Buffers messages using three different encodings JSON
+                    based syntax instead of the original binary protocol. Supported formats
+
+                    - Hashmap: A tipical JSON message, with key:value pairs where the key is a string representing
+                        the field name.
+
+                    - Tagmap: Very similar to Hashmap, but instead of having the field name as key it has the
+                        field tag number as defined in the proto definition.
+
+                    - Indexed: Takes the Tagmap format a further step and optimizes the size needed for
+                        tag numbers by packing all of them as a string, where each character represents a tag,
+                        and placing it as the first element of an array.}
+
+  s.rubyforge_project = "protojson"
+
+  s.files         = `git ls-files`.split("\n")
+  s.files.delete("Gemfile.lock")
+  s.files.delete(".gitignore")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/addressbook.pb.rb

@@ -0,0 +1,56 @@
+### Generated by rprotoc. DO NOT EDIT!
+### <proto file: examples/addressbook.proto>
+# package tutorial;
+# 
+# message Person {
+#   required string name = 1;
+#   required int32 id = 2;
+#   optional string email = 3;
+# 
+#   enum PhoneType {
+#     MOBILE = 0;
+#     HOME = 1;
+#     WORK = 2;
+#   }
+# 
+#   message PhoneNumber {
+#     required string number = 1;
+#     optional PhoneType type = 2 [default = HOME];
+#   }
+# 
+#   repeated PhoneNumber phone = 4;
+# }
+# 
+# message AddressBook {
+#   repeated Person person = 1;
+# }
+
+require 'protobuf/message/message'
+require 'protobuf/message/enum'
+require 'protobuf/message/service'
+require 'protobuf/message/extend'
+
+module Tutorial
+  class Person < ::Protobuf::Message
+    defined_in __FILE__
+    required :string, :name, 1
+    required :int32, :id, 2
+    optional :string, :email, 3
+    class PhoneType < ::Protobuf::Enum
+      defined_in __FILE__
+      MOBILE = 0
+      HOME = 1
+      WORK = 2
+    end
+    class PhoneNumber < ::Protobuf::Message
+      defined_in __FILE__
+      required :string, :number, 1
+      optional :PhoneType, :type, 2, :default => :HOME
+    end
+    repeated :PhoneNumber, :phone, 4
+  end
+  class AddressBook < ::Protobuf::Message
+    defined_in __FILE__
+    repeated :Person, :person, 1
+  end
+end

data/spec/main.rb

@@ -0,0 +1,55 @@
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+$:.unshift File.join(File.dirname(__FILE__),'.')
+
+require 'rubygems'
+require 'addressbook.pb'
+require 'protojson'
+
+unless ARGV.size == 1
+  puts "Usage: #{$0} ADDRESS_BOOK_FILE"
+  exit
+end
+
+person = Tutorial::Person.new
+person.parse_from_file ARGV[0]
+
+puts ""
+puts "Person data"
+puts "..........."
+p person
+
+Protobuf::Message::encoding = Protobuf::Message::EncodingType::INDEXED
+
+value = person.serialize_to_string
+
+puts ""
+puts "Indexed encoding"
+puts "................"
+puts value
+
+Protobuf::Message::encoding = Protobuf::Message::EncodingType::TAGMAP
+
+value = person.serialize_to_string
+
+puts ""
+puts "Tagmap encoding"
+puts "..............."
+puts value
+
+Protobuf::Message::encoding = Protobuf::Message::EncodingType::HASHMAP
+
+value = person.serialize_to_string
+
+puts ""
+puts "Hashmap encoding"
+puts "................"
+puts value
+puts ""
+
+#Protobuf::Message::encoding = Protobuf::Message::EncodingType::BINARY
+
+#value = person.serialize_to_string
+
+#puts value
+

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification 
+name: protojson
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Juan de Bravo
+- Ivan -DrSlump- Montes
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-28 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: |-
+  A Ruby gem for Google's Protocol Buffers messages using three different encodings JSON
+                      based syntax instead of the original binary protocol. Supported formats
+  
+                      - Hashmap: A tipical JSON message, with key:value pairs where the key is a string representing
+                          the field name.
+  
+                      - Tagmap: Very similar to Hashmap, but instead of having the field name as key it has the
+                          field tag number as defined in the proto definition.
+  
+                      - Indexed: Takes the Tagmap format a further step and optimizes the size needed for
+                          tag numbers by packing all of them as a string, where each character represents a tag,
+                          and placing it as the first element of an array.
+email: 
+- juandebravo@gmail.com
+- drslump@pollinimini.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/extensions/protobuf/message.rb
+- lib/protojson.rb
+- lib/protojson/version.rb
+- protojson.gemspec
+- spec/addressbook.pb.rb
+- spec/main.rb
+- spec/person
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: protojson
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Ruby extension to ruby-protobuf to enable three new encodings
+test_files: 
+- spec/addressbook.pb.rb
+- spec/main.rb
+- spec/person