protopuffs 0.3.0

data/.gitignore

@@ -0,0 +1,4 @@
+.DS_Store
+/coverage/
+/pkg/
+/rdoc/

data/.specification

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification 
+name: protopuffs
+version: !ruby/object:Gem::Version 
+  version: 0.2.1
+platform: ruby
+authors: 
+- Chris Kampmeier
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-19 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: treetop
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: shoulda
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A new implementation of Protocol Buffers in Ruby
+email: chris@kampers.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE.txt
+files: 
+- LICENSE.txt
+- README.rdoc
+- VERSION.yml
+- lib/protopuffs
+- lib/protopuffs/message
+- lib/protopuffs/message/base.rb
+- lib/protopuffs/message/field.rb
+- lib/protopuffs/message/wire_type.rb
+- lib/protopuffs/parser
+- lib/protopuffs/parser/parser.rb
+- lib/protopuffs/parser/protocol_buffer.treetop
+- lib/protopuffs.rb
+- test/abstract_syntax_tree_test.rb
+- test/fixtures
+- test/fixtures/proto
+- test/fixtures/proto/person.proto
+- test/message_base_test.rb
+- test/message_field_test.rb
+- test/parse_tree_test.rb
+- test/protopuffs_test.rb
+- test/test_helper.rb
+- test/text_format_test.rb
+- test/wire_format_test.rb
+has_rdoc: true
+homepage: http://github.com/chrisk/protopuffs
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.4
+signing_key: 
+specification_version: 2
+summary: Sex, drugs, and protocol buffers
+test_files: []
+

data/LICENSE.txt

@@ -0,0 +1,18 @@
+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.rdoc

@@ -0,0 +1,74 @@
+= Protopuffs!
+
+A new implementation of Protocol Buffers in Ruby. 
+
+If you're not familiar with Protocol Buffers, start with Google's homepage:
+http://code.google.com/apis/protocolbuffers
+
+  Protocol buffers are Google's language-neutral, platform-neutral, extensible
+  mechanism for serializing structured data -- think XML, but smaller, faster,
+  and simpler.
+
+== Installation
+
+Rubyforge is cuckoo for protopuffs.
+
+  sudo gem install protopuffs
+
+== Usage
+
+Start with a +proto+ file, say, <tt>proto/animals.proto</tt>:
+
+  message Bird {
+    required string name = 1;
+    optional string species = 2;
+  }
+
+First, require Protopuffs and tell it where your +proto+ files are:
+
+  require 'protopuffs'
+  Protopuffs.proto_load_path << "proto"
+  Protopuffs.load_message_classes
+
+That makes the Bird message dynamically available in Ruby. Everything's
+namespaced under <tt>Protopuffs::Message</tt>, which should help with your OCD.
+
+  bird = Protopuffs::Message::Bird.new
+  bird.name = "Sonny"
+  bird.species = "Cuculus canorus"
+
+  # encode this message to the super-efficient binary wire format
+  binary_bird = bird.to_wire_format
+
+  # or encode to the human-friendly text format, for debugging
+  puts bird.inspect
+
+You can also decode incoming binary wire-format messages:
+
+  decoded_bird = Protopuffs::Message::Bird.new
+  decoded_bird.from_wire_format(binary_bird)
+  decoded_bird.name  # => "Sonny"
+
+=== Mass-assignment
+
+TODO: explain <tt>Message::Base.new</tt> with strings containing the wire format
+or hashes, as well as <tt>#attributes=</tt>
+
+== Missing functionality
+
+Protopuffs currently only supports a base set of the <tt>.proto</tt> file
+syntax. Here's what's missing:
+
+* the sfixed64 type
+* sint32 and sint64 types (due to lack of support for ZigZag encoding)
+* packed repeated fields (the <tt>[packed=true]</tt> option)
+* enumerations
+* importing definitions
+* nested message types
+* extensions
+* nested extensions
+* packages
+* services
+* built-in options
+* custom options
+* groups (deprecated)

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: UTF-8
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rcov/rcovtask'
+begin require 'metric_fu'; rescue LoadError; end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "protopuffs"
+    s.rubyforge_project = "protopuffs"
+    s.summary = %Q{Sex, drugs, and protocol buffers}
+    s.email = "chris@kampers.net"
+    s.homepage = "http://github.com/chrisk/protopuffs"
+    s.description = "A new implementation of Protocol Buffers in Ruby"
+    s.authors = ["Chris Kampmeier"]
+    s.add_dependency "treetop"
+    s.add_development_dependency "mocha"
+    s.add_development_dependency "shoulda"
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Protopuffs'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('LICENSE*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Rcov::RcovTask.new do |t|
+  t.libs << 'test'
+  t.rcov_opts << '--exclude "gems/*"'
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+task :default => :test

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 3
+:patch: 0

data/lib/protopuffs.rb

@@ -0,0 +1,31 @@
+# encoding: UTF-8
+
+require "rubygems"
+require "treetop"
+require "protopuffs/message/base"
+require "protopuffs/message/field"
+require "protopuffs/message/wire_type"
+require "protopuffs/parser/parser"
+
+
+module Protopuffs
+  class ParseError < StandardError; end
+
+  def self.proto_load_path
+    @proto_load_path ||= []
+  end
+
+  def self.proto_load_path=(paths)
+    @proto_load_path = paths
+  end
+
+  def self.load_message_classes
+    parser = Protopuffs::Parser::ProtocolBufferDescriptor.new
+
+    @proto_load_path.each do |path|
+      Dir.glob(File.join(path, "**/*.proto")) do |descriptor_path|
+        parser.parse(File.read(descriptor_path))
+      end
+    end
+  end
+end

data/lib/protopuffs/message/base.rb

@@ -0,0 +1,124 @@
+# encoding: UTF-8
+
+module Protopuffs
+  module Message
+
+    class Base
+
+      class << self
+        attr_reader :fields
+
+        def define_message_class(name, fields)
+          name = name.delete("_")
+          self.check_fields_for_errors(name, fields)
+          Message.send(:remove_const, name) if Message.const_defined?(name)
+          klass = Message.const_set(name, Class.new(self))
+          klass.instance_variable_set(:@fields, fields)
+          fields.each do |field|
+            klass.send(:attr_accessor, field.identifier)
+          end
+          klass
+        end
+
+        def check_fields_for_errors(name, fields)
+          tags = fields.map { |field| field.tag }
+          if tags.uniq.size != fields.size
+            raise ParseError, "A tag was reused in the descriptor for message #{name}. Please check that each tag is unique."
+          end
+
+          if tags.any? { |tag| tag < 1 || tag > 536_870_911 }
+            raise ParseError, "A tag is out of range in the descriptor for message #{name}. Please check that each tag is in the range 1 <= x <= 536,870,911."
+          end
+
+          if tags.any? { |tag| (19000..19999).include?(tag) }
+            raise ParseError, "A tag is invalid in the descriptor for message #{name}. Please check that each tag is not in the reserved range 19,000 <= x <= 19,999."
+          end
+        end
+      end
+
+      attr_reader :buffer
+
+      def initialize(field_values = nil)
+        if self.class == Base
+          raise "#{self.class} should not be instantiated directly. Use the factory #{self.class}.define_message_class instead."
+        end
+
+        if field_values.nil?
+          @buffer = StringIO.new
+          @buffer.set_encoding("BINARY") if @buffer.respond_to?(:set_encoding)
+        elsif field_values.respond_to?(:each_pair)
+          @buffer = StringIO.new
+          @buffer.set_encoding("BINARY") if @buffer.respond_to?(:set_encoding)
+          self.attributes = field_values
+        else
+          from_wire_format(field_values)
+        end
+      end
+
+      def to_wire_format
+        self.class.fields.sort_by { |f| f.tag }.each do |field|
+          value = send(field.identifier)
+          @buffer.write field.to_wire_format_with_value(value) unless value.nil?
+        end
+        @buffer.string
+      end
+
+      # Returns the protocol buffer text format, which is useful for debugging
+      def inspect
+        type = self.class.name.split("::").last.downcase
+        field_strings = self.class.fields.map { |f| "  #{f.identifier}: #{send(f.identifier).inspect}\n" }
+        "#{type} {\n#{field_strings.join}}"
+      end
+
+      def from_wire_format(buffer)
+        if !buffer.respond_to?(:read)
+          buffer.force_encoding("BINARY") if buffer.respond_to?(:force_encoding)
+          @buffer = StringIO.new(buffer)
+        else
+          @buffer = buffer
+        end
+        @buffer.set_encoding("BINARY") if @buffer.respond_to?(:set_encoding)
+
+        until @buffer.eof?
+          tag = MessageField.shift_tag(@buffer)
+          field = self.class.fields.find { |f| f.tag == tag }
+          next if field.nil?
+          value_bytes = field.class.shift(@buffer)
+
+          value = field.decode(value_bytes)
+          if field.repeated? && send(field.identifier).nil?
+            send("#{field.identifier}=", [value])
+          elsif field.repeated?
+            send(field.identifier) << value
+          else
+            send("#{field.identifier}=", value)
+          end
+        end
+        set_values_for_missing_optional_fields
+        self
+      end
+
+      def set_values_for_missing_optional_fields
+        self.class.fields.select { |field| field.optional? }.each do |field|
+          send("#{field.identifier}=", field.default) if send(field.identifier).nil?
+        end
+      end
+
+      def attributes=(attrs = {})
+        attrs.each_pair do |name, value|
+          self.send("#{name}=", value) if respond_to?("#{name}=")
+        end
+      end
+
+      def ==(other)
+        return false if self.class != other.class
+        self.class.fields.each do |field|
+          return false if send(field.identifier) != other.send(field.identifier)
+        end
+        true
+      end
+
+    end
+
+  end
+end

data/lib/protopuffs/message/field.rb

@@ -0,0 +1,226 @@
+# encoding: UTF-8
+
+module Protopuffs
+
+  class MessageField
+    attr_reader :identifier, :tag, :default
+
+    def self.factory(type, *args)
+      case type
+      when "int32"    then Int32.new(*args)
+      when "int64"    then Int64.new(*args)
+      when "uint32"   then UInt32.new(*args)
+      when "uint64"   then UInt64.new(*args)
+      when "bool"     then Bool.new(*args)
+      when "double"   then Double.new(*args)
+      when "fixed64"  then Fixed64.new(*args)
+      when "string"   then String.new(*args)
+      when "bytes"    then Bytes.new(*args)
+      when "float"    then Float.new(*args)
+      when "fixed32"  then Fixed32.new(*args)
+      when "sfixed32" then SFixed32.new(*args)
+      else Embedded.new(type, *args)
+      end
+    end
+
+    def initialize(modifier, identifier, tag, default)
+      raise "MessageField is an abstract base class" if self.class == MessageField
+      raise ArgumentError.new("Invalid modifier '#{modifier}'") unless
+        ["optional", "required", "repeated"].include?(modifier)
+      @modifier = modifier
+      @identifier = identifier
+      @tag = tag
+      @default = default
+    end
+    private :initialize
+
+    def key
+      (@tag << 3) | self.class.wire_type
+    end
+
+    def repeated?
+      @modifier == "repeated"
+    end
+
+    def optional?
+      @modifier == "optional"
+    end
+
+    def to_wire_format_with_value(value)
+      field_encoder = lambda { |val| VarInt.encode(key) + self.class.encode(val) }
+      if repeated?
+        value.map(&field_encoder).join
+      else
+        field_encoder.call(value)
+      end
+    end
+
+    def self.shift_tag(buffer)
+      bits = 0
+      bytes = VarInt.shift(buffer)
+      bytes.each_with_index do |byte, index|
+        byte &= 0b01111111
+        bits |= byte << (7 * index)
+      end
+      bits >> 3
+    end
+  end
+
+  class Bool < MessageField
+    def initialize(modifier, identifier, tag, default = nil)
+      super(modifier, identifier, tag, default || false)
+    end
+    def self.wire_type;     WireType::VARINT end
+    def self.shift(buffer); VarInt.shift(buffer) end
+    def decode(value_bytes)
+      value = VarInt.decode(value_bytes)
+      value = true  if value == 1
+      value = false if value == 0
+      value
+    end
+    def self.encode(value); VarInt.encode(value ? 1 : 0) end
+  end
+
+  class Numeric < MessageField
+    def initialize(modifier, identifier, tag, default = nil)
+      super(modifier, identifier, tag, default || 0)
+    end
+  end
+
+  class VarInt < Numeric
+    def self.wire_type; WireType::VARINT end
+    def self.shift(buffer)
+      bytes = []
+      begin
+        # Use #readbyte in Ruby 1.9, and #readchar in Ruby 1.8
+        byte = buffer.send(buffer.respond_to?(:readbyte) ? :readbyte : :readchar)
+        bytes << (byte & 0b01111111)
+      end while byte >> 7 == 1
+      bytes
+    end
+    def self.decode(bytes)
+      value = 0
+      bytes.each_with_index do |byte, index|
+        value |= byte << (7 * index)
+      end
+      value
+    end
+    def decode(bytes)
+      VarInt.decode(bytes)
+    end
+    def self.encode(value)
+      return [0].pack('C') if value.zero?
+      bytes = []
+      until value.zero?
+        byte = 0
+        7.times do |i|
+          byte |= (value & 1) << i
+          value >>= 1
+        end
+        byte |= 0b10000000
+        bytes << byte
+      end
+      bytes[-1] &= 0b01111111
+      bytes.pack('C*')
+    end
+  end
+
+  class Int32 < VarInt; end
+  class Int64 < VarInt; end
+  class UInt32 < VarInt; end
+  class UInt64 < VarInt; end
+
+  class Fixed32Base < Numeric
+    def self.wire_type;     WireType::FIXED32 end
+    def self.shift(buffer); buffer.read(4) end
+  end
+
+  class Fixed32 < Fixed32Base
+    def decode(bytes);      bytes.unpack('V').first end
+    def self.encode(value); [value].pack('V') end
+  end
+
+  class SFixed32 < Fixed32Base
+    def decode(bytes)
+      value = bytes.unpack('V').first
+      value >= 2**31 ? value -= 2**32 : value
+    end
+    def self.encode(value); [value].pack('V') end
+  end
+
+  class Float < Fixed32Base
+    def decode(bytes);      bytes.unpack('e').first end
+    def self.encode(value); [value].pack('e') end
+  end
+
+  class Fixed64Base < Numeric
+    def self.wire_type;     WireType::FIXED64 end
+    def self.shift(buffer); buffer.read(8) end
+  end
+
+  class Fixed64 < Fixed64Base
+    def decode(bytes);      bytes.unpack('Q').first end
+    def self.encode(value); [value].pack('Q') end
+  end
+
+  class Double < Fixed64Base
+    def decode(bytes);      bytes.unpack('E').first end
+    def self.encode(value); [value].pack('E') end
+  end
+
+  class LengthDelimited < MessageField
+    def self.wire_type; WireType::LENGTH_DELIMITED end
+    def self.shift(buffer)
+      bytes = VarInt.shift(buffer)
+      value_length = VarInt.decode(bytes)
+      buffer.read(value_length)
+    end
+    def decode(bytes); bytes end
+  end
+
+  class String < LengthDelimited
+    def initialize(modifier, identifier, tag, default = nil)
+      super(modifier, identifier, tag, default || "")
+    end
+    def self.encode(value)
+      value = value.to_s
+      value.force_encoding("UTF-8") if value.respond_to?(:force_encoding)
+      # Use #bytesize in Ruby 1.9, and #size in Ruby 1.8
+      size = value.respond_to?(:bytesize) ? value.bytesize : value.size
+      VarInt.encode(size) + value
+    end
+    def decode(bytes)
+      bytes.respond_to?(:force_encoding) ? bytes.force_encoding("UTF-8") : bytes
+    end
+  end
+
+  class Bytes < LengthDelimited
+    def initialize(modifier, identifier, tag, default = nil)
+      super
+    end
+    def self.encode(value)
+      VarInt.encode(value.size) + value
+    end
+    def decode(bytes)
+      bytes.respond_to?(:force_encoding) ? bytes.force_encoding("BINARY") : bytes
+    end
+  end
+
+  class Embedded < LengthDelimited
+    def initialize(type, modifier, identifier, tag, default = nil)
+      @type = type
+      super(modifier, identifier, tag, default)
+    end
+    def decode(bytes)
+      bytes.force_encoding("BINARY") if bytes.respond_to?(:force_encoding)
+      value = Message.const_get(@type.delete("_")).new
+      value.from_wire_format(StringIO.new(bytes))
+    end
+    def self.encode(value)
+      embedded_bytes = value.to_wire_format
+      VarInt.encode(embedded_bytes.size) + embedded_bytes
+    end
+  end
+
+end
+