1#!/usr/bin/ruby
2# Protocol Buffers - Google's data interchange format
3# Copyright 2008 Google Inc.  All rights reserved.
4# https://developers.google.com/protocol-buffers/
5#
6# Redistribution and use in source and binary forms, with or without
7# modification, are permitted provided that the following conditions are
8# met:
9#
10#     * Redistributions of source code must retain the above copyright
11# notice, this list of conditions and the following disclaimer.
12#     * Redistributions in binary form must reproduce the above
13# copyright notice, this list of conditions and the following disclaimer
14# in the documentation and/or other materials provided with the
15# distribution.
16#     * Neither the name of Google Inc. nor the names of its
17# contributors may be used to endorse or promote products derived from
18# this software without specific prior written permission.
19#
20# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
23# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
24# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
25# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
26# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
27# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
28# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
30# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31
32require 'google/protobuf/any_pb'
33require 'google/protobuf/duration_pb'
34require 'google/protobuf/field_mask_pb'
35require 'google/protobuf/struct_pb'
36require 'google/protobuf/timestamp_pb'
37
38module Google
39  module Protobuf
40
41    Any.class_eval do
42      def self.pack(msg, type_url_prefix='type.googleapis.com/')
43        any = self.new
44        any.pack(msg, type_url_prefix)
45        any
46      end
47
48      def pack(msg, type_url_prefix='type.googleapis.com/')
49        if type_url_prefix.empty? or type_url_prefix[-1] != '/' then
50          self.type_url = "#{type_url_prefix}/#{msg.class.descriptor.name}"
51        else
52          self.type_url = "#{type_url_prefix}#{msg.class.descriptor.name}"
53        end
54        self.value = msg.to_proto
55      end
56
57      def unpack(klass)
58        if self.is(klass) then
59          klass.decode(self.value)
60        else
61          nil
62        end
63      end
64
65      def type_name
66        return self.type_url.split("/")[-1]
67      end
68
69      def is(klass)
70        return self.type_name == klass.descriptor.name
71      end
72    end
73
74    Timestamp.class_eval do
75      def to_time
76        Time.at(self.to_f)
77      end
78
79      def from_time(time)
80        self.seconds = time.to_i
81        self.nanos = time.nsec
82      end
83
84      def to_i
85        self.seconds
86      end
87
88      def to_f
89        self.seconds + (self.nanos.quo(1_000_000_000))
90      end
91    end
92
93    Duration.class_eval do
94      def to_f
95        self.seconds + (self.nanos.to_f / 1_000_000_000)
96      end
97    end
98
99    class UnexpectedStructType < Google::Protobuf::Error; end
100
101    Value.class_eval do
102      def to_ruby(recursive = false)
103        case self.kind
104        when :struct_value
105          if recursive
106            self.struct_value.to_h
107          else
108            self.struct_value
109          end
110        when :list_value
111          if recursive
112            self.list_value.to_a
113          else
114            self.list_value
115          end
116        when :null_value
117          nil
118        when :number_value
119          self.number_value
120        when :string_value
121          self.string_value
122        when :bool_value
123          self.bool_value
124        else
125          raise UnexpectedStructType
126        end
127      end
128
129      def from_ruby(value)
130        case value
131        when NilClass
132          self.null_value = 0
133        when Numeric
134          self.number_value = value
135        when String
136          self.string_value = value
137        when TrueClass
138          self.bool_value = true
139        when FalseClass
140          self.bool_value = false
141        when Struct
142          self.struct_value = value
143        when Hash
144          self.struct_value = Struct.from_hash(value)
145        when ListValue
146          self.list_value = value
147        when Array
148          self.list_value = ListValue.from_a(value)
149        else
150          raise UnexpectedStructType
151        end
152      end
153    end
154
155    Struct.class_eval do
156      def [](key)
157        self.fields[key].to_ruby
158      rescue NoMethodError
159        nil
160      end
161
162      def []=(key, value)
163        unless key.is_a?(String)
164          raise UnexpectedStructType, "Struct keys must be strings."
165        end
166        self.fields[key] ||= Google::Protobuf::Value.new
167        self.fields[key].from_ruby(value)
168      end
169
170      def to_h
171        ret = {}
172        self.fields.each { |key, val| ret[key] = val.to_ruby(true) }
173        ret
174      end
175
176      def self.from_hash(hash)
177        ret = Struct.new
178        hash.each { |key, val| ret[key] = val }
179        ret
180      end
181
182      def has_key?(key)
183        self.fields.has_key?(key)
184      end
185    end
186
187    ListValue.class_eval do
188      include Enumerable
189
190      def length
191        self.values.length
192      end
193
194      def [](index)
195        self.values[index].to_ruby
196      end
197
198      def []=(index, value)
199        self.values[index].from_ruby(value)
200      end
201
202      def <<(value)
203        wrapper = Google::Protobuf::Value.new
204        wrapper.from_ruby(value)
205        self.values << wrapper
206      end
207
208      def each
209        self.values.each { |x| yield(x.to_ruby) }
210      end
211
212      def to_a
213        self.values.map { |x| x.to_ruby(true) }
214      end
215
216      def self.from_a(arr)
217        ret = ListValue.new
218        arr.each { |val| ret << val }
219        ret
220      end
221    end
222
223  end
224end
225