protojson 0.1.0 → 0.2.0

data/examples/simple.proto

@@ -0,0 +1,7 @@
+package examples;
+
+message Simple {
+  required string foo = 1;
+  required int32 bar = 2;
+  optional string baz = 3;
+}

data/lib/protojson.rb

@@ -1,6 +1,84 @@
-require 'protobuf/message/message'
-require 'extensions/protobuf/message'
+%W(binary json hash json_indexed json_tag_map).each { |codec|
+  require "protojson/codec/#{codec}"
+}
 
 module Protojson
-  # Your code goes here...
+
+  class << self
+
+    # Key name - Codec value
+    def []=(codec_name = nil, codec = nil)
+      codec_name.is_a?(String) and codec_name.downcase!
+
+      unless codec_name.nil? # default codec
+        unless codec_name.is_a?(Symbol)
+          if codec_name.respond_to?(:to_sym)
+            codec_name = codec_name.to_sym
+          else
+            raise Exception, "Only symbols allowed as codec names"
+          end
+        end
+      end
+
+      if codec.nil? # unregister codec
+        codecs.delete(codec_name)
+      else # register codec
+        !codec.is_a? Protojson::Codec::CodecInterface and raise Exception, "codec should include Protojson::Codec::CodecInterface"
+        codecs[codec_name] = codec
+      end
+    end
+
+    # Returns the codec specified or the default one if no attribute is defined
+    def [](codec = nil)
+      codec.is_a?(Protojson::Codec::CodecInterface) and return codec
+      codec.is_a?(Symbol) or codec.nil? and return codecs[codec]
+      raise "Invalid codec #{codec}. It should either implement Protojson::Codec::CodecInterface or be a symbol"
+    end
+
+    # Initializes the codecs Hash
+    def codecs
+      @codecs ||= (
+          # While accessing the Hash, if the key does not exist, throws an exception
+      h = Hash.new { |hash, key|
+        hash.has_key?(key) and return hash[key]
+        !key.nil? and raise Exception, "Undefined codec #{key}"
+        h[nil] = Protojson::Codec::Binary
+      }
+      # default value is Binary codec
+      h[nil] = Protojson::Codec::Binary
+      h[:hash] = Protojson::Codec::Hash
+      h[:indexed] = Protojson::Codec::JsonIndexed
+      h[:json] = Protojson::Codec::Json
+      h[:tag_map] = Protojson::Codec::JsonTagMap
+      h
+      )
+    end
+
+    def set_default_codec(codec)
+      # fetch codec from Hash if codec name received
+      if codec.is_a?(Symbol) or codec.is_a?(String)
+        codec = Protojson[codec]
+      end
+
+      # set default codec
+      puts codec.is_a?(Protojson::Codec::CodecInterface)
+      if codec.is_a?(Protojson::Codec::CodecInterface)
+        codecs[nil] = codec
+      else
+        raise Exception, 'Codec must implement Protojson::Codec::CodecInterface'
+      end
+    end
+
+    def encode(message, codec = nil)
+      codec = send("[]".to_sym, codec)
+      codec.encode(message)
+    end
+
+    def decode(message, data, codec = nil)
+      codec = send("[]".to_sym, codec) # fetch default codec if none given
+      codec.decode(message, data)
+    end
+
+  end
+
 end

data/lib/protojson/codec/binary.rb

@@ -0,0 +1,21 @@
+require 'protojson/codec/codec_interface'
+
+module Protojson
+  module Codec
+    class Binary
+      extend Protojson::Codec::CodecInterface
+
+      class << self
+
+        def encode(message)
+          message.serialize_to_string
+        end
+
+        def decode(message, data)
+          message.new.parse_from_string(data)
+        end
+      end
+
+    end
+  end
+end

data/lib/protojson/codec/codec_interface.rb

@@ -0,0 +1,15 @@
+module Protojson
+  module Codec
+    module CodecInterface
+
+        def encode(message)
+          raise NotImplementedError, "#{self.class} should implement encode method"
+        end
+
+        def decode(message, data)
+          raise NotImplementedError, "#{self.class} should implement decode method"
+        end
+
+    end
+  end
+end

data/lib/protojson/codec/hash.rb

@@ -0,0 +1,121 @@
+require 'protobuf/message/message'
+require 'protobuf/message/field'
+require 'protobuf/message/enum'
+
+module Protojson
+  module Codec
+    class Hash
+      extend Protojson::Codec::CodecInterface
+
+      class << self
+
+        # 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 encode(message, encoding_key = :name)
+          raise NotInitializedError unless message.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? && !message.has_field?(field.name)
+                                      ''
+          else
+            case field
+              when Protobuf::Field::MessageField
+                if value.nil?
+                  nil
+                else
+                  encode(value, encoding_key)
+                end
+              when Protobuf::Field::EnumField
+                if value.is_a?(Protobuf::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
+          message.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
+            unless key_value.nil? or (key_value.respond_to?(:empty?) and key_value.empty?)
+              result[key.to_s] = key_value
+            end
+          end
+          result
+        end
+
+        # This method parses a JSON encoded message to the message object
+        def decode(message, data, decoding_key = :name)
+
+          message = message.new
+
+          # 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 = message.get_field_by_tag(key.to_i)
+            field = message.send("get_field_by_#{decoding_key}".to_sym, key)
+
+            if field.nil?
+              # ignore unknown field
+            elsif field.repeated?
+              # create the element
+              array = message.__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
+                  val = decode(instance, 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
+                value = decode(instance, value, decoding_key)
+              end
+              # set the message field
+              message.__send__("#{field.name}=", value)
+            end
+          }
+          message
+        end
+      end
+    end
+  end
+end

data/lib/protojson/codec/json.rb

@@ -0,0 +1,24 @@
+require 'active_support/core_ext'
+
+require 'protojson/codec/codec_interface'
+
+module Protojson
+  module Codec
+    class Json
+      extend Protojson::Codec::CodecInterface
+
+      class << self
+
+        def encode(message)
+          Protojson::Codec::Hash.encode(message).to_json
+        end
+
+        def decode(message, data)
+          data.is_a?(String) and data = ActiveSupport::JSON.decode(data)
+          Protojson::Codec::Hash.decode(message, data)
+        end
+      end
+
+    end
+  end
+end

data/lib/protojson/codec/json_indexed.rb

@@ -0,0 +1,85 @@
+require 'active_support/core_ext'
+
+require 'protojson/codec/codec_interface'
+
+module Protojson
+  module Codec
+    class JsonIndexed
+      extend Protojson::Codec::CodecInterface
+
+      class << self
+
+        def encode(message)
+          data = Protojson::Codec::Hash.encode(message, :tag)
+          serialize_hash_to_indexed(data)
+        end
+
+        def decode(message, data)
+          data.is_a?(String) and data = ActiveSupport::JSON.decode(data)
+
+          values = parse_indexed_to_hash(message.new, data)
+          Protojson::Codec::Hash.decode(message, values, :tag)
+        end
+
+        # This class method serializes a Hash
+        def 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 = 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 INDEXED encoded message to a hash using
+        # message message as model.
+        # We need to know the specific message to decode to differenciate between
+        # vectors and message fields
+        def parse_indexed_to_hash(message, data)
+          values = {}
+          index = data.shift
+          index.each_codepoint { |tag|
+            tag = tag-48
+            field = message.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 = parse_indexed_to_hash(field.type, v)
+                }
+              else
+                val = parse_indexed_to_hash(field.type, val)
+              end
+            end
+            values[tag.to_s] = val
+          }
+          values
+        end
+      end
+
+
+    end
+  end
+end

data/lib/protojson/codec/json_tag_map.rb

@@ -0,0 +1,25 @@
+require 'active_support/core_ext'
+
+require 'protojson/codec/codec_interface'
+
+module Protojson
+  module Codec
+    class JsonTagMap
+      extend Protojson::Codec::CodecInterface
+
+      class << self
+
+        def encode(message)
+          Protojson::Codec::Hash.encode(message, :tag).to_json
+        end
+
+        def decode(message, data)
+          data.is_a?(String) and data = ActiveSupport::JSON.decode(data)
+          Protojson::Codec::Hash.decode(message, data, :tag)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/protojson/version.rb

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

data/protojson.gemspec

@@ -3,13 +3,13 @@ $:.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.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
 
@@ -25,10 +25,17 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = "protojson"
 
-  s.files         = `git ls-files`.split("\n")
+  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.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"]
+
+  s.add_dependency('ruby_protobuf', '~>0.4.10')
+  s.add_dependency('activesupport', '~>3.0.5')
+  s.add_dependency('i18n', '~>0.5.0')
+
+  s.add_development_dependency("rspec")
+
 end

data/spec/codec_binary_spec.rb

@@ -0,0 +1,150 @@
+# -*- coding: UTF-8 -*-
+
+#$:.unshift File.join(File.dirname(__FILE__), '..', 'lib')
+$:.unshift File.join(File.dirname(__FILE__), '..')
+
+require 'protojson'
+
+require 'examples/simple.pb'
+require 'examples/repeated.pb'
+require 'examples/addressbook.pb'
+
+describe Protojson::Codec::Binary do
+  before(:all) do
+    Protojson.set_default_codec(Protojson::Codec::Binary)
+  end
+
+  context "simple message" do
+
+    it "should encode properly when two required attributes provided" do
+      simple = Examples::Simple.new
+      simple.foo = "Foo"
+      simple.bar = 1000
+      decoded = Protojson.decode(Examples::Simple, Protojson.encode(simple))
+      decoded.foo.should eql("Foo")
+      decoded.bar.should eql(1000)
+    end
+
+    it "should encode properly when two required attributes and one optional attribute provided" do
+      simple = Examples::Simple.new
+      simple.foo = "Foo"
+      simple.bar = 1000
+      simple.baz = "Bazz"
+      decoded = Protojson.decode(Examples::Simple, Protojson.encode(simple))
+      decoded.foo.should eql("Foo")
+      decoded.bar.should eql(1000)
+      decoded.baz.should eql("Bazz")
+    end
+  end
+
+  context "repeated message" do
+
+    it "should encode properly when the string field has more than one value" do
+      repeated = Examples::Repeated.new
+      repeated.string << "one"
+      repeated.string << "two"
+      repeated.string << "three"
+      decoded = Protojson.decode(Examples::Repeated, Protojson.encode(repeated))
+      decoded.string.length.should eql(3)
+      decoded.string[0].should eql("one")
+      decoded.string[1].should eql("two")
+      decoded.string[2].should eql("three")
+    end
+
+    it "should encode properly when the int field has more than one value" do
+      repeated = Examples::Repeated.new
+      repeated.int << 1
+      repeated.int << 2
+      repeated.int << 3
+      decoded = Protojson.decode(Examples::Repeated, Protojson.encode(repeated))
+      decoded.int.length.should eql(3)
+      (0..2).each{|i|
+        decoded.int[i].should eql(i+1)
+      }
+    end
+
+    it "should encode properly when both int and string fields has more than one value" do
+      repeated = Examples::Repeated.new
+      repeated.string << "one"
+      repeated.string << "two"
+      repeated.string << "three"
+      repeated.int << 1
+      repeated.int << 2
+      repeated.int << 3
+      decoded = Protojson.decode(Examples::Repeated, Protojson.encode(repeated))
+      decoded.string.length.should eql(3)
+      decoded.string[0].should eql("one")
+      decoded.string[1].should eql("two")
+      decoded.string[2].should eql("three")
+      decoded.int.length.should eql(3)
+      (0..2).each{|i|
+        decoded.int[i].should eql(i+1)
+      }
+    end
+
+    it "should encode properly when the nested field has more than one value" do
+      repeated = Examples::Repeated.new
+      (1..3).each { |id|
+        nested = Examples::Repeated::Nested.new
+        nested.id = id
+        repeated.nested << nested
+      }
+      decoded = Protojson.decode(Examples::Repeated, Protojson.encode(repeated))
+      decoded.nested.length.should eql(3)
+      (0..2).each{|i|
+        decoded.nested[i].should be_instance_of Examples::Repeated::Nested
+        decoded.nested[i].id.should eql(i+1)
+      }
+    end
+
+  end
+
+  context "complex message" do
+    it "should work!! :)" do
+      book = Examples::AddressBook.new
+      person = Examples::Person.new
+      person.name = 'John Doe'
+      person.id = 2051
+      person.email = "john.doe@gmail.com"
+      phone = Examples::Person::PhoneNumber.new
+      phone.number = '1231231212'
+      phone.type = Examples::Person::PhoneType::HOME
+      person.phone << phone
+      phone = Examples::Person::PhoneNumber.new
+      phone.number = '55512321312'
+      phone.type = Examples::Person::PhoneType::MOBILE
+      person.phone << phone
+      book.person << person
+
+      person = Examples::Person.new
+      person.name = "Ivan Montes"
+      person.id = 23
+      person.email = "drslump@pollinimini.net"
+      phone = Examples::Person::PhoneNumber.new
+      phone.number = '3493123123'
+      phone.type = Examples::Person::PhoneType::WORK
+      person.phone << phone
+      book.person << person
+
+      person = Examples::Person.new
+      person.name = "Juan de Bravo"
+      person.id = 24
+      person.email = "juan@pollinimini.net"
+      phone = Examples::Person::PhoneNumber.new
+      phone.number = '3493123124'
+      phone.type = Examples::Person::PhoneType::WORK
+      person.phone << phone
+      book.person << person
+
+      decoded = Protojson.decode(Examples::AddressBook, Protojson.encode(book))
+
+      decoded.person.length.should eql 3
+      decoded.person[0].name.should eql "John Doe"
+      decoded.person[1].name.should eql "Ivan Montes"
+      decoded.person[2].name.should eql "Juan de Bravo"
+      decoded.person[0].phone[1].number.should eql "55512321312"
+    end
+
+  end
+
+end