Module: Protobuf::ActiveRecord::Transformation::ClassMethods

Defined in:
lib/protobuf/active_record/transformation.rb

Instance Method Summary collapse

Instance Method Details

#_filter_attribute_fields(proto) ⇒ Object

Filters accessible attributes that exist in the given protobuf message’s fields or have attribute transformers defined for them.

Returns a hash of attribute fields with their respective values.

:nodoc:



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
 
# File 'lib/protobuf/active_record/transformation.rb', line 29

def _filter_attribute_fields(proto)
  fields = proto.to_hash
  fields.select! do |key, value|
    field = proto.class.get_field(key, true)
    proto.field?(key) && !field.repeated?
  end

  filtered_attributes = _filtered_attributes + _protobuf_attribute_transformers.keys

  attribute_fields = filtered_attributes.inject({}) do |hash, column_name|
    symbolized_column = column_name.to_sym

    if fields.has_key?(symbolized_column) || _protobuf_attribute_transformers.has_key?(symbolized_column)
      hash[symbolized_column] = fields[symbolized_column]
    end

    hash
  end

  _protobuf_nested_attributes.each do |attribute_name|
    nested_attribute_name = "#{attribute_name}_attributes".to_sym
    value = if proto.has_field?(nested_attribute_name)
              proto.__send__(nested_attribute_name)
            elsif proto.has_field?(attribute_name)
              proto.__send__(attribute_name)
            end

    next unless value
    attribute_fields[nested_attribute_name] = value
  end

  attribute_fields
end

#_filtered_attributes ⇒ Object

Overidden by mass assignment security when protected attributes is loaded.

:nodoc:



66
67
68
 
# File 'lib/protobuf/active_record/transformation.rb', line 66

def _filtered_attributes
  return self.attribute_names
end

#_protobuf_convert_fields_to_attributes(key, value) ⇒ Object

:nodoc:



71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/protobuf/active_record/transformation.rb', line 71

def _protobuf_convert_fields_to_attributes(key, value)
  return nil if value.nil?
  return value unless _protobuf_date_datetime_time_or_timestamp_column?(key)

  value = case
          when _protobuf_datetime_column?(key) then
            convert_int64_to_datetime(value)
          when _protobuf_timestamp_column?(key) then
            convert_int64_to_time(value)
          when _protobuf_time_column?(key) then
            convert_int64_to_time(value)
          when _protobuf_date_column?(key) then
            convert_int64_to_date(value)
          end

  return value
end

#attribute_from_proto(attribute, *args, &block) ⇒ Object

Define an attribute transformation from protobuf. Accepts a Symbol, callable, or block.

When given a callable or block, it is directly used to convert the field.

When a symbol is given, it extracts the method with the same name.

The callable or method must accept a single parameter, which is the proto message.

Examples:

attribute_from_proto :public_key, :extract_public_key_from_proto
attribute_from_proto :status, lambda { |proto| # Do some stuff... }
attribute_from_proto :status do |proto|
  # Do some blocky stuff...
end

attribute_from_proto :status, lambda { |proto| nil }, :nullify_on => :status
attribute_from_proto :status, :nullify_on => :status do |proto|
  nil
end



111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
 
# File 'lib/protobuf/active_record/transformation.rb', line 111

def attribute_from_proto(attribute, *args, &block)
  options = args.extract_options!
  symbol_or_block = args.first || block

  if symbol_or_block.is_a?(Symbol)
    callable = lambda { |value| self.__send__(symbol_or_block, value) }
  else
    raise AttributeTransformerError unless symbol_or_block.respond_to?(:call)
    callable = symbol_or_block
  end

  if options[:nullify_on]
    field = protobuf_message.get_field(:nullify)
    unless field && field.is_a?(::Protobuf::Field::StringField) && field.repeated?
      ::Protobuf::Logging.logger.warn "Message: #{protobuf_message} is not compatible with :nullify_on option"
    end
  end

  transformer = ::Protobuf::ActiveRecord::Transformer.new(callable, options)
  _protobuf_attribute_transformers[attribute.to_sym] = transformer
end

#attributes_from_proto(proto) ⇒ Object

Creates a hash of attributes from a given protobuf message.

It converts and transforms field values using the field converters and attribute transformers, ignoring repeated and nil fields.



139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
 
# File 'lib/protobuf/active_record/transformation.rb', line 139

def attributes_from_proto(proto)
  attribute_fields = _filter_attribute_fields(proto)

  attributes = attribute_fields.inject({}) do |hash, (key, value)|
    if _protobuf_attribute_transformers.has_key?(key)
      transformer = _protobuf_attribute_transformers[key]
      attribute = transformer.call(proto)
      hash[key] = attribute unless attribute.nil?
      hash[key] = nil if transformer.nullify?(proto)
    else
      hash[key] = _protobuf_convert_fields_to_attributes(key, value)
    end

    hash
  end

  return attributes unless proto.field?(:nullify) && proto.nullify.is_a?(Array)

  proto.nullify.each do |attribute_name|
    attributes[attribute_name.to_sym] = nil if attribute_names.include?(attribute_name.to_s)
  end

  attributes
end

#convert_int64_to_date(int64) ⇒ Object

:nodoc:



170
171
172
 
# File 'lib/protobuf/active_record/transformation.rb', line 170

def convert_int64_to_date(int64)
  convert_int64_to_time(int64).utc.to_date
end

#convert_int64_to_datetime(int64) ⇒ Object

:nodoc:



175
176
177
 
# File 'lib/protobuf/active_record/transformation.rb', line 175

def convert_int64_to_datetime(int64)
  convert_int64_to_time(int64).to_datetime
end

#convert_int64_to_time(int64) ⇒ Object

:nodoc:



165
166
167
 
# File 'lib/protobuf/active_record/transformation.rb', line 165

def convert_int64_to_time(int64)
  Time.at(int64.to_i)
end