beefcake-spanx 0.3.4.1

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in beefcake.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,16 @@
+PATH
+  remote: .
+  specs:
+    beefcake-spanx (0.3.4.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    rake (0.9.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  beefcake-spanx!
+  rake

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2011 Blake Mizerany
+
+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,116 @@
+# Beefcake (A sane Google Protocol Buffers library for Ruby)
+## It's all about being Buf; ProtoBuf.
+
+# Install
+
+    $ gem install beefcake
+
+# Example
+
+    require 'beefcake'
+
+    class Variety
+      include Beefcake::Message
+
+      # Required
+      required :x, :int32, 1
+      required :y, :int32, 2
+
+      # Optional
+      optional :tag, :string, 3
+
+      # Repeated
+      repeated :ary,  :fixed64, 4
+      repeated :pary, :fixed64, 5, :packed => true
+
+      # Enums - Simply use a Module (NOTE: defaults are optional)
+      module Foonum
+        A = 1
+        B = 2
+      end
+
+      # As per the spec, defaults are only set at the end
+      # of decoding a message, not on object creation.
+      optional :foo, Foonum, 6, :default => Foonum::B
+    end
+
+    x = Variety.new :x => 1, :y => 2
+    # or
+    x = Variety.new
+    x.x = 1
+    x.y = 2
+
+## Encoding
+
+Any object responding to `<<` can accept encoding
+
+    s = ""
+    x.encode(s)
+    p [:s, s]
+    # or (because encode returns the string/stream)
+    p [:s, x.encode]
+    # or
+    open("x.dat") do |f|
+      x.encode(f)
+    end
+
+    # decode
+    encoded = x.encode
+    decoded = Variety.decode(encoded)
+    p [:x, decoded]
+
+    # decode merge
+    Variety.decoded(more_data, decoded)
+
+# Why?
+
+  Ruby deserves and needs first-class ProtoBuf support.
+  Other libs didn't feel very "Ruby" to me and were hard to parse.
+
+# Generate code from `.proto` file
+
+    $ protoc --beefcake_out output/path -I path/to/proto/files/dir path/to/proto/file
+
+You can set the BEEFCAKE_NAMESPACE variable to generate the classes under a
+desired namespace. (i.e. App::Foo::Bar)
+
+# Misc
+
+  This library was built with EventMachine in mind.  Not just blocking-IO.
+
+# Dev
+
+Source:
+
+    $ git clone git://github.com/bmizerany/beefcake
+
+## Testing:
+
+    $ gem install turn
+    $ cd /path/to/beefcake
+    $ turn
+
+## VMs:
+
+Currently Beefcake is tested and working on:
+
+* Ruby 1.8.6
+* Ruby 1.8.7
+* Ruby 1.9.2
+* JRuby 1.5.6
+* Rubinius edge
+
+## Future
+
+Nice to have:
+
+* Groups (would be nice for accessing older protos)
+
+# Further Reading
+
+http://code.google.com/apis/protocolbuffers/docs/encoding.html
+
+# Thank You
+
+Keith Rarick (kr) for help with encoding/decoding.
+Aman Gupta (tmm1) for help with cross VM support and performance enhancements.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/beefcake.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "beefcake/version"
+
+Gem::Specification.new do |s|
+  s.name        = "beefcake-spanx"
+  s.version     = Beefcake::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Blake Mizerany"]
+  s.email       = ["blake.mizerany@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{A sane protobuf library for Ruby}
+  s.description = %q{A sane protobuf library for Ruby}
+
+  s.rubyforge_project = "beefcake"
+
+  s.files         = `git ls-files`.split("\n")
+  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_development_dependency "rake"
+end

data/bench/simple.rb

@@ -0,0 +1,90 @@
+$:.unshift File.expand_path('../../lib', __FILE__)
+require 'beefcake'
+
+class MyMessage
+  include Beefcake::Message
+  required :number, :int32,  1
+  required :chars,  :string, 2
+  required :raw,    :bytes,  3
+  required :bool,   :bool,   4
+  required :float,  :float,  5
+end
+
+if ARGV[0] == 'pprof'
+  # profile message creation/encoding/decoding w/ perftools.rb
+  # works on 1.8 and 1.9
+  #   ruby bench/simple.rb pprof
+  #   open bench/beefcake.prof.gif
+
+  ENV['CPUPROFILE_FREQUENCY'] = '4000'
+  require 'rubygems'
+  require 'perftools'
+  PerfTools::CpuProfiler.start(File.expand_path("../beefcake.prof", __FILE__)) do
+    100_000.times do
+      str = MyMessage.new(
+        :number => 12345,
+        :chars  => 'hello',
+        :raw    => 'world',
+        :bool   => true,
+        :float  => 1.2345
+      ).encode
+      MyMessage.decode(str)
+    end
+  end
+  Dir.chdir(File.dirname(__FILE__)) do
+    `pprof.rb beefcake.prof --gif > beefcake.prof.gif`
+  end
+
+else
+  # benchmark message creation/encoding/decoding
+  #   rvm install 1.8.7 1.9.2 jruby rbx
+  #   rvm 1.8.7,1.9.2,jruby,rbx ruby bench/simple.rb
+
+  require 'benchmark'
+
+  ITERS = 100_000
+
+  Benchmark.bmbm do |x|
+    x.report 'object creation' do
+      ITERS.times do
+        Object.new
+      end
+    end
+    x.report 'message creation' do
+      ITERS.times do
+        MyMessage.new(
+          :number => 12345,
+          :chars  => 'hello',
+          :raw    => 'world',
+          :bool   => true,
+          :float  => 1.2345
+        )
+      end
+    end
+    x.report 'message encoding' do
+      m = MyMessage.new(
+        :number => 12345,
+        :chars  => 'hello',
+        :raw    => 'world',
+        :bool   => true,
+        :float  => 1.2345
+      )
+      ITERS.times do
+        m.encode
+      end
+    end
+    x.report 'message decoding' do
+      str = MyMessage.new(
+        :number => 12345,
+        :chars  => 'hello',
+        :raw    => 'world',
+        :bool   => true,
+        :float  => 1.2345
+      ).encode.to_s
+      ITERS.times do
+        MyMessage.decode(str.dup)
+      end
+    end
+  end
+
+end

data/bin/protoc-gen-beefcake

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'beefcake/generator'
+
+ns = (ENV["BEEFCAKE_NAMESPACE"] || "").split("::")
+
+req = CodeGeneratorRequest.decode(STDIN.read)
+res = Beefcake::Generator.compile(ns, req)
+
+# Send it out!
+STDOUT.print(res.encode)

data/lib/beefcake.rb

@@ -0,0 +1,246 @@
+require 'beefcake/buffer'
+
+module Beefcake
+  module Message
+
+    class WrongTypeError < StandardError
+      def initialize(name, exp, got)
+        super("Wrong type `#{got}` given for (#{name}).  Expected #{exp}")
+      end
+    end
+
+
+    class InvalidValueError < StandardError
+      def initialize(name, val)
+        super("Invalid Value given for `#{name}`: #{val.inspect}")
+      end
+    end
+
+
+    class RequiredFieldNotSetError < StandardError
+      def initialize(name)
+        super("Field #{name} is required but nil")
+      end
+    end
+
+
+    class Field < Struct.new(:rule, :name, :type, :fn, :opts)
+      def <=>(o)
+        fn <=> o.fn
+      end
+    end
+
+
+    module Dsl
+      def required(name, type, fn, opts={})
+        field(:required, name, type, fn, opts)
+      end
+
+      def repeated(name, type, fn, opts={})
+        field(:repeated, name, type, fn, opts)
+      end
+
+      def optional(name, type, fn, opts={})
+        field(:optional, name, type, fn, opts)
+      end
+
+      def field(rule, name, type, fn, opts)
+        fields[fn] = Field.new(rule, name, type, fn, opts)
+        attr_accessor name
+      end
+
+      def fields
+        @fields ||= {}
+      end
+    end
+
+    module Encode
+
+      def encode(buf = Buffer.new)
+        validate!
+
+        if ! buf.respond_to?(:<<)
+          raise ArgumentError, "buf doesn't respond to `<<`"
+        end
+
+        if ! buf.is_a?(Buffer)
+          buf = Buffer.new(buf)
+        end
+
+        # TODO: Error if any required fields at nil
+
+        fields.values.sort.each do |fld|
+          if fld.opts[:packed]
+            bytes = encode!(Buffer.new, fld, 0)
+            buf.append_info(fld.fn, Buffer.wire_for(fld.type))
+            buf.append_uint64(bytes.length)
+            buf << bytes
+          else
+            encode!(buf, fld, fld.fn)
+          end
+        end
+
+        buf
+      end
+
+      def encode!(buf, fld, fn)
+        v = self[fld.name]
+        v = v.is_a?(Array) ? v : [v]
+
+        v.compact.each do |val|
+          case fld.type
+          when Class # encodable
+            # TODO: raise error if type != val.class
+            buf.append(:string, val.encode, fn)
+          when Module # enum
+            if ! valid_enum?(fld.type, val)
+              raise InvalidValueError.new(fld.name, val)
+            end
+
+            buf.append(:int32, val, fn)
+          else
+            buf.append(fld.type, val, fn)
+          end
+        end
+
+        buf
+      end
+
+      def valid_enum?(mod, val)
+        !!name_for(mod, val)
+      end
+
+      def name_for(mod, val)
+        mod.constants.each do |name|
+          if mod.const_get(name) == val
+            return name
+          end
+        end
+        nil
+      end
+
+      def validate!
+        fields.values.each do |fld|
+          if fld.rule == :required && self[fld.name].nil?
+            raise RequiredFieldNotSetError, fld.name
+          end
+        end
+      end
+
+    end
+
+
+    module Decode
+      def decode(buf, o=self.new)
+        if ! buf.is_a?(Buffer)
+          buf = Buffer.new(buf)
+        end
+
+        # TODO: test for incomplete buffer
+        while buf.length > 0
+          fn, wire = buf.read_info
+
+          fld = fields[fn]
+
+          # We don't have a field for with index fn.
+          # Ignore this data and move on.
+          if fld.nil?
+            buf.skip(wire)
+            next
+          end
+
+          exp = Buffer.wire_for(fld.type)
+          if wire != exp
+            raise WrongTypeError.new(fld.name, exp, wire)
+          end
+
+          if fld.rule == :repeated && fld.opts[:packed]
+            len = buf.read_uint64
+            tmp = Buffer.new(buf.read(len))
+            o[fld.name] ||= []
+            while tmp.length > 0
+              o[fld.name] << tmp.read(fld.type)
+            end
+	  elsif fld.rule == :repeated
+            val = buf.read(fld.type)
+            (o[fld.name] ||= []) << val
+          else
+            val = buf.read(fld.type)
+            o[fld.name] = val
+          end
+        end
+
+        # Set defaults
+        fields.values.each do |f|
+	  next if o[f.name] == false
+          o[f.name] ||= f.opts[:default]
+        end
+
+        o.validate!
+
+        o
+      end
+    end
+
+
+    def self.included(o)
+      o.extend Dsl
+      o.extend Decode
+      o.send(:include, Encode)
+    end
+
+    def initialize(attrs={})
+      fields.values.each do |fld|
+        self[fld.name] = attrs[fld.name]
+      end
+    end
+
+    def fields
+      self.class.fields
+    end
+
+    def [](k)
+      __send__(k)
+    end
+
+    def []=(k, v)
+      __send__("#{k}=", v)
+    end
+
+    def ==(o)
+      return false if o == nil
+      fields.values.all? {|fld| self[fld.name] == o[fld.name] }
+    end
+
+    def inspect
+      set = fields.values.select {|fld| self[fld.name] != nil }
+
+      flds = set.map do |fld|
+        val = self[fld.name]
+
+        case fld.type
+        when Class
+          "#{fld.name}: #{val.inspect}"
+        when Module
+          title = name_for(fld.type, val) || "-NA-"
+          "#{fld.name}: #{title}(#{val.inspect})"
+        else
+          "#{fld.name}: #{val.inspect}"
+        end
+      end
+
+      "<#{self.class.name} #{flds.join(", ")}>"
+    end
+
+    def to_hash
+      fields.values.inject({}) do |h, fld|
+        if v = self[fld.name]
+          h[fld.name] = v
+        end
+        h
+      end
+    end
+
+  end
+
+end