protobuf-activerecord 2.1.0 → 3.0.0.pre

data/lib/protobuf/activerecord/protoable/errors.rb

@@ -1,22 +0,0 @@
-module Protoable
-
-  # = Protoable errors
-  #
-  # Generic Protoable exception class
-  class ProtoableError < StandardError
-  end
-
-  # Raised by Protoable.attribute_from_proto when the transformer method
-  # given is not callable.
-  class AttributeTransformerError < ProtoableError
-  end
-
-  # Raised by Protoable.field_from_record when the convert method
-  # given not callable.
-  class FieldTransformerError < ProtoableError
-  end
-
-  # Raised by Protoable.field_scope when given scope is not defined.
-  class SearchScopeError < ProtoableError
-  end
-end

data/lib/protobuf/activerecord/protoable/persistence.rb

@@ -1,56 +0,0 @@
-module Protoable
-  module Persistence
-    def self.included(klass)
-      klass.extend Protoable::Persistence::ClassMethods
-
-      klass.class_eval do
-        # Override Active Record's initialize method so it can accept a protobuf
-        # message as it's attributes. Need to do it in class_eval block since initialize
-        # is defined in ActiveRecord::Base.
-        # :noapi:
-        def initialize(*args)
-          args[0] = attributes_from_proto(args.first) if args.first.is_a?(::Protobuf::Message)
-
-          super(*args)
-        end
-      end
-    end
-
-    module ClassMethods
-      # :nodoc:
-      def create(attributes, options = {}, &block)
-        attributes = attributes_from_proto(attributes) if attributes.is_a?(::Protobuf::Message)
-
-        super(attributes, options)
-      end
-
-      # :nodoc:
-      def create!(attributes, options = {}, &block)
-        attributes = attributes_from_proto(attributes) if attributes.is_a?(::Protobuf::Message)
-
-        super(attributes, options)
-      end
-    end
-
-    # :nodoc:
-    def assign_attributes(attributes, options = {})
-      attributes = attributes_from_proto(attributes) if attributes.is_a?(::Protobuf::Message)
-
-      super(attributes, options)
-    end
-
-    # :nodoc:
-    def update_attributes(attributes, options = {})
-      attributes = attributes_from_proto(attributes) if attributes.is_a?(::Protobuf::Message)
-
-      super(attributes, options)
-    end
-
-    # :nodoc:
-    def update_attributes!(attributes, options = {})
-      attributes = attributes_from_proto(attributes) if attributes.is_a?(::Protobuf::Message)
-
-      super(attributes, options)
-    end
-  end
-end

data/lib/protobuf/activerecord/protoable/scope.rb

@@ -1,121 +0,0 @@
-module Protoable
-  module Scope
-    def self.extended(klass)
-      klass.class_eval do
-        class << self
-          alias_method :by_fields, :search_scope
-          alias_method :scope_from_proto, :search_scope
-        end
-      end
-    end
-
-    # Define fields that should be searchable via `search_scope`. Accepts a
-    # protobuf field and an already defined scope. If no scope is specified,
-    # the scope will be the field name, prefixed with `by_` (e.g. when the
-    # field is :guid, the scope will be :by_guid).
-    #
-    # Optionally, a parser can be provided that will be called, passing the
-    # field value as an argument. This allows custom data parsers to be used
-    # so that they don't have to be handled by scopes. Parsers can be procs,
-    # lambdas, or symbolized method names and must accept the value of the
-    # field as a parameter.
-    #
-    # > **Deprecated usage**: Previous versions required the scope to be passed
-    #   as a second argument. This has been replaced with the new hash-style
-    #   options or simply relying on the defaults. While it will still work
-    #   until v3.0 is released, it has been deprecated.
-    #
-    #
-    # Examples:
-    #
-    #   class User < ActiveRecord::Base
-    #     scope :by_guid, lambda { |*guids| where(:guid => guids) }
-    #     scope :custom_guid_scope, lambda { |*guids| where(:guid => guids) }
-    #
-    #     # Equivalent to `field_scope :guid, :by_guid`
-    #     field_scope :guid
-    #
-    #     # With a custom scope
-    #     field_scope :guid, :scope => :custom_guid_scope
-    #
-    #     # With a custom parser that converts the value to an integer
-    #     field_scope :guid, :scope => :custom_guid_scope, :parser => lambda { |value| value.to_i }
-    #   end
-    #
-    def field_scope(field, *args)
-      # TODO: For backwards compatibility. Remove this in the next major release.
-      options = args.extract_options!
-
-      scope_name = case
-                   when args.present? then
-                     warn "WARNING: Passing scopes directly to field_scope is deprecated and will be removed in 3.0. Use :scope => xxx instead."
-                     args.first
-                   when options.include?(:scope) then
-                     options[:scope]
-                   else
-                     # When no scope is defined, assume the scope is the field, prefixed with `by_`
-                     :"by_#{field}"
-                   end
-      searchable_fields[field] = scope_name
-
-      searchable_field_parsers[field] = options[:parser] if options[:parser]
-    end
-
-    # :noapi:
-    def parse_search_values(proto, field)
-      value = proto.__send__(field)
-
-      if searchable_field_parsers[field]
-        parser = searchable_field_parsers[field]
-
-        if parser.respond_to?(:to_sym)
-          value = self.__send__(parser.to_sym, value)
-        else
-          value = parser.call(value)
-        end
-      end
-
-      values = [ value ].flatten
-      values.map!(&:to_i) if proto.get_field_by_name(field).enum?
-      values
-    end
-
-    # Builds and returns a Arel relation based on the fields that are present
-    # in the given protobuf message using the searchable fields to determine
-    # what scopes to use. Provides several aliases for variety.
-    #
-    # Examples:
-    #
-    #   # Search starting with the default scope and searchable fields
-    #   User.search_scope(request)
-    #   User.by_fields(request)
-    #   User.scope_from_proto(request)
-    #
-    def search_scope(proto)
-      relation = scoped # Get an ARel relation to build off of
-
-      searchable_fields.each do |field, scope_name|
-        next unless proto.respond_to_and_has_and_present?(field)
-
-        unless self.respond_to?(scope_name)
-          raise Protoable::SearchScopeError, "Undefined scope :#{scope_name}."
-        end
-
-        search_values = parse_search_values(proto, field)
-        relation = relation.__send__(scope_name, *search_values)
-      end
-
-      return relation
-    end
-
-    # :noapi:
-    def searchable_fields
-      @_searchable_fields ||= {}
-    end
-
-    # :noapi:
-    def searchable_field_parsers
-      @_searchable_field_parsers ||= {}
-    end
-  end
-end

data/lib/protobuf/activerecord/protoable/serialization.rb

@@ -1,190 +0,0 @@
-require 'heredity/inheritable_class_instance_variables'
-
-module Protoable
-  module Serialization
-    def self.included(klass)
-      klass.extend Protoable::Serialization::ClassMethods
-      klass.__send__(:include, ::Heredity::InheritableClassInstanceVariables)
-
-      klass.class_eval do
-        class << self
-          attr_accessor :_protobuf_field_transformers, :_protobuf_field_options
-        end
-
-        @_protobuf_field_transformers = {}
-        @_protobuf_field_options = {}
-
-        inheritable_attributes :_protobuf_field_transformers, :_protobuf_field_options,
-          :protobuf_message
-      end
-    end
-
-    module ClassMethods
-      # :nodoc:
-      def _protobuf_convert_attributes_to_fields(key, value)
-        return value if value.nil?
-
-        value = case
-                when _protobuf_date_column?(key) then
-                  value.to_time.to_i
-                when _protobuf_datetime_column?(key) then
-                  value.to_i
-                when _protobuf_time_column?(key) then
-                  value.to_i
-                when _protobuf_timestamp_column?(key) then
-                  value.to_i
-                else
-                  value
-                end
-
-        return value
-      end
-
-      # Define a field transformation from a record. Accepts a Symbol,
-      # callable, or block that is called with the record being serialized.
-      #
-      # 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:
-      #   field_from_record :public_key, :convert_public_key_to_proto
-      #   field_from_record :status, lambda { |record| # Do some stuff... }
-      #   field_from_record :status do |record|
-      #     # Do some blocky stuff...
-      #   end
-      #
-      def field_from_record(field, transformer = nil, &block)
-        transformer ||= block
-
-        if transformer.is_a?(Symbol)
-          callable = lambda { |value| self.__send__(transformer, value) }
-        else
-          callable = transformer
-        end
-
-        unless callable.respond_to?(:call)
-          raise FieldTransformerError, 'Attribute transformers need a callable or block!'
-        end
-
-        _protobuf_field_transformers[field.to_sym] = callable
-      end
-
-      # Define the protobuf message class that should be used to serialize the
-      # object to protobuf. Accepts a string or symbol and an options hash.
-      #
-      # When protobuf_message is declared, Protoable automatically extracts the
-      # fields from the message and automatically adds a to_proto method that
-      # serializes the object to protobuf.
-      #
-      # The fields that will be automatically serialized can be configured by
-      # passing :only or :except in the options hash. If :only is specified, only
-      # the specified fields will be serialized. If :except is specified, all
-      # field except the specified fields will be serialized.
-      #
-      # By default, deprecated fields will be serialized. To exclude deprecated
-      # fields, pass :deprecated => false in the options hash.
-      #
-      # Examples:
-      #   protobuf_message :user_message
-      #   protobuf_message "UserMessage"
-      #   protobuf_message "Namespaced::UserMessage"
-      #   protobuf_message :user_message, :only => [ :guid, :name ]
-      #   protobuf_message :user_message, :except => :email_domain
-      #   protobuf_message :user_message, :except => :email_domain, :deprecated => false
-      #
-      def protobuf_message(message = nil, options = {})
-        unless message.nil?
-          @protobuf_message = message.to_s.classify.constantize
-
-          self._protobuf_field_options = options
-
-          define_method(:to_proto) do |options = {}|
-            self.class.protobuf_message.new(self.fields_from_record(options))
-          end
-        end
-
-        @protobuf_message
-      end
-    end
-
-    # :nodoc:
-    def _filter_field_attributes(options = {})
-      options = _normalize_options(options)
-
-      fields = _filtered_fields(options)
-      fields &= [ options[:only] ].flatten if options[:only].present?
-      fields -= [ options[:except] ].flatten if options[:except].present?
-
-      fields
-    end
-
-    # :nodoc:
-    def _filtered_fields(options = {})
-      exclude_deprecated = ! options.fetch(:deprecated, true)
-
-      fields = self.class.protobuf_message.all_fields.map do |field|
-        next if field.nil?
-        next if exclude_deprecated && field.deprecated?
-        field.name.to_sym
-      end
-      fields.compact!
-
-      fields
-    end
-
-    # :nodoc:
-    def _normalize_options(options)
-      options ||= {}
-      options[:only] ||= [] if options.fetch(:except, false)
-      options[:except] ||= [] if options.fetch(:only, false)
-
-      self.class._protobuf_field_options.merge(options)
-    end
-
-    # Extracts attributes that correspond to fields on the specified protobuf
-    # message, performing any necessary column conversions on them. Accepts a
-    # hash of options for specifying which fields should be serialized.
-    #
-    # Examples:
-    #   fields_from_record(:only => [ :guid, :name ])
-    #   fields_from_record(:except => :email_domain)
-    #   fields_from_record(:include => :email_domain)
-    #   fields_from_record(:except => :email_domain, :deprecated => false)
-    #
-    def fields_from_record(options = {})
-      field_attributes = _filter_field_attributes(options)
-      field_attributes += [ options.fetch(:include, []) ]
-      field_attributes.flatten!
-      field_attributes.compact!
-      field_attributes.uniq!
-
-      field_attributes = field_attributes.inject({}) do |hash, field|
-        if _protobuf_field_transformers.has_key?(field)
-          hash[field] = _protobuf_field_transformers[field].call(self)
-        else
-          value = respond_to?(field) ? __send__(field) : nil
-          hash[field] = _protobuf_convert_attributes_to_fields(field, value)
-        end
-        hash
-      end
-
-      field_attributes
-    end
-
-  private
-
-    # :nodoc:
-    def _protobuf_convert_attributes_to_fields(field, value)
-      self.class._protobuf_convert_attributes_to_fields(field, value)
-    end
-
-    # :nodoc:
-    def _protobuf_field_transformers
-      self.class._protobuf_field_transformers
-    end
-  end
-end

data/lib/protobuf/activerecord/protoable/transformation.rb

@@ -1,158 +0,0 @@
-require 'heredity/inheritable_class_instance_variables'
-
-module Protoable
-  module Transformation
-    def self.included(klass)
-      klass.extend Protoable::Transformation::ClassMethods
-      klass.__send__(:include, ::Heredity::InheritableClassInstanceVariables)
-
-      klass.class_eval do
-        class << self
-          attr_accessor :_protobuf_attribute_transformers
-        end
-
-        @_protobuf_attribute_transformers = {}
-
-        inheritable_attributes :_protobuf_attribute_transformers
-      end
-    end
-
-    module ClassMethods
-      # 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:
-      def _filter_attribute_fields(proto)
-        fields = proto.to_hash
-        fields.select! do |key, value|
-          field = proto.get_field_by_name(key) || proto.get_ext_field_by_name(key)
-          proto.has_field?(key) && !field.repeated?
-        end
-
-        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
-
-        attribute_fields
-      end
-
-      # Filters protected attributes from the available attributes list. When
-      # set through accessible attributes, returns the accessible attributes.
-      # When set through protected attributes, returns the attributes minus any
-      # protected attributes.
-      #
-      # :nodoc:
-      def _filtered_attributes
-        return accessible_attributes.to_a if accessible_attributes.present?
-
-        return self.attribute_names - protected_attributes.to_a
-      end
-
-      # :nodoc:
-      def _protobuf_convert_fields_to_columns(key, value)
-        return value if value.nil?
-
-        value = case
-                when _protobuf_date_column?(key) then
-                  convert_int64_to_date(value)
-                when _protobuf_datetime_column?(key) then
-                  convert_int64_to_datetime(value)
-                when _protobuf_time_column?(key) then
-                  convert_int64_to_time(value)
-                when _protobuf_timestamp_column?(key) then
-                  convert_int64_to_time(value)
-                else
-                  value
-                end
-
-        return value
-      end
-
-      # 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
-      #
-      def attribute_from_proto(attribute, transformer = nil, &block)
-        transformer ||= block
-
-        if transformer.is_a?(Symbol)
-          callable = lambda { |value| self.__send__(transformer, value) }
-        else
-          callable = transformer
-        end
-
-        unless callable.respond_to?(:call)
-          raise AttributeTransformerError, 'Attribute transformers need a callable or block!'
-        end
-
-        _protobuf_attribute_transformers[attribute.to_sym] = callable
-      end
-
-
-      # 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.
-      #
-      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)
-            attribute = _protobuf_attribute_transformers[key].call(proto)
-            hash[key] = attribute unless attribute.nil?
-          else
-            hash[key] = _protobuf_convert_fields_to_columns(key, value)
-          end
-
-          hash
-        end
-
-        attributes
-      end
-
-      # :nodoc:
-      def convert_int64_to_time(int64)
-        Time.at(int64.to_i)
-      end
-
-      # :nodoc:
-      def convert_int64_to_date(int64)
-        convert_int64_to_time(int64).utc.to_date
-      end
-
-      # :nodoc:
-      def convert_int64_to_datetime(int64)
-        convert_int64_to_time(int64).to_datetime
-      end
-    end
-
-    # Calls up to the class version of the method.
-    #
-    def attributes_from_proto(proto)
-      self.class.attributes_from_proto(proto)
-    end
-  end
-end