protobuf-activerecord 2.1.0 → 3.0.0.pre

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    OWVlMmI0NmI3ODc3MjI1NDk3NTUyMDhlODIyZDE0ODg3NGNmODlhZQ==
-  data.tar.gz: !binary |-
-    NjEwNzFlMTAyZGE1Yzk5NGZjNDVjZmJlYmU5ODExYjFkNWIwMTVjOA==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    NzkzN2ZkMGY3YzdiN2NlZjAwZTAwZjMzZDc0NTQzMjMwNzgzOWY2NDg1MWQ5
-    YzBhZTI3ZmFjMGIzOWRlYjgxMmRhN2Y1NDZlNGE4MzI5OTY3NWVjZjljNzc1
-    NjU4MjUxZjRlNGE5NmI3MzMzMzc0YWM1YTRmYTQxMDQwYTMzMDA=
-  data.tar.gz: !binary |-
-    ZmY0YWY3OGRkNTdkNzAwYzQ1YTkzZjVhZjk5ZDAwMGUzMDdkNjUyNGY2MzBk
-    ODY4ZGZlYWQ2NmFmOGQyNjdiZjY4MmI4NDI1YWZhNzEzY2MwYWQyZWFkZGUx
-    OWM0NDc5MWRmYjhhYjYwMGQ4YzE5NzE4ZjgzNjkxNDY4NGFjOTM=
+SHA1:
+  metadata.gz: 222a25f863e0432deaee84af24cdb1afcf54d470
+  data.tar.gz: 2db3c1dce2882e7495cfe2d7b3eed18f01677b19
+SHA512:
+  metadata.gz: 96dd33216999495aca093656d30918711af9c1641e4476ea028b929ba162607510ce0d36253762821e4b48c210c4834188166a3c12e9b7d0a77a6ef58045bdf4
+  data.tar.gz: c0ef76053aff3bcdbf00a3a8d9bb894367491c753a4e583799fef3d1a2d928445306cb898b1cd6b9d1d94ae8795050c016958ad9f262f8419c2671e173f027f0

data/Gemfile

@@ -2,7 +2,3 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in protobuf-activerecord.gemspec
 gemspec
-
-gem 'builder', '~> 3.0.4' # Builder 3.1.x is not supported by Active Record
-                          # and Bundler has trouble resolving the dependency
-                          # with Geminabox.

data/lib/protobuf-activerecord.rb

@@ -3,6 +3,29 @@ require 'active_support/concern'
 require 'heredity'
 require 'protobuf'
 
-require 'protobuf/activerecord/version'
-require 'protobuf/activerecord/protobuf_ext/message'
-require 'protobuf/activerecord/protoable'
+require 'protobuf/active_record/config'
+require 'protobuf/active_record/model'
+require 'protobuf/active_record/version'
+
+module Protobuf
+  module ActiveRecord
+    module LoadHooks
+      def inherited(klass)
+        super
+
+        klass.class_eval do
+          include Protobuf::ActiveRecord::Model
+        end
+      end
+    end
+
+    def self.config
+      @config ||= Protobuf::ActiveRecord::Config.new
+    end
+
+    # Initialize the config
+    config
+  end
+end
+
+require 'protobuf/active_record/railtie' if defined?(Rails)

data/lib/protobuf/active_record/attribute_methods.rb

@@ -0,0 +1,35 @@
+require 'active_support/concern'
+
+module Protobuf
+  module ActiveRecord
+    module AttributeMethods
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def alias_field(field_alias, attribute)
+          alias_attribute field_alias, attribute
+
+          attribute_from_proto attribute, fetch_attribute_alias_from_proto(attribute, field_alias)
+          field_from_record field_alias, fetch_field_alias_from_record(attribute, field_alias)
+        end
+
+        def fetch_attribute_alias_from_proto(attribute, field_alias)
+          lambda do |proto|
+            value = proto.__send__(:"#{field_alias}!")
+            value ||= proto.__send__(:"#{attribute}!") if proto.respond_to?(attribute)
+
+            self._protobuf_convert_fields_to_attributes(attribute, value)
+          end
+        end
+
+        def fetch_field_alias_from_record(attribute, field_aliasd)
+          lambda do |record|
+            value = record.__send__(field_alias)
+
+            self._protobuf_convert_attributes_to_fields(attribute, value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/active_record/columns.rb

@@ -0,0 +1,74 @@
+require 'active_support/concern'
+
+module Protobuf
+  module ActiveRecord
+    module Columns
+      extend ::ActiveSupport::Concern
+
+      included do
+        include ::Heredity
+
+        inheritable_attributes :_protobuf_columns,
+                               :_protobuf_column_types,
+                               :_protobuf_mapped_columns
+      end
+
+      module ClassMethods
+        def _protobuf_columns
+          _protobuf_map_columns unless _protobuf_mapped_columns?
+
+          @_protobuf_columns
+        end
+
+        def _protobuf_column_types
+          _protobuf_map_columns unless _protobuf_mapped_columns?
+
+          @_protobuf_column_types
+        end
+
+        # :nodoc:
+        def _protobuf_date_column?(key)
+          _protobuf_column_types.fetch(:date, false) && _protobuf_column_types[:date].include?(key)
+        end
+
+        # :nodoc:
+        def _protobuf_datetime_column?(key)
+          _protobuf_column_types.fetch(:datetime, false) && _protobuf_column_types[:datetime].include?(key)
+        end
+
+        # Map out the columns for future reference on type conversion
+        # :nodoc:
+        def _protobuf_map_columns(force = false)
+          return unless table_exists?
+
+          @_protobuf_mapped_columns = false if force
+          return if _protobuf_mapped_columns?
+
+          @_protobuf_columns = {}
+          @_protobuf_column_types = Hash.new { |h,k| h[k] = [] }
+
+          columns.map do |column|
+            @_protobuf_columns[column.name.to_sym] = column
+            @_protobuf_column_types[column.type.to_sym] << column.name.to_sym
+          end
+
+          @_protobuf_mapped_columns = true
+        end
+
+        def _protobuf_mapped_columns?
+          @_protobuf_mapped_columns
+        end
+
+        # :nodoc:
+        def _protobuf_time_column?(key)
+          _protobuf_column_types.fetch(:time, false) && _protobuf_column_types[:time].include?(key)
+        end
+
+        # :nodoc:
+        def _protobuf_timestamp_column?(key)
+          _protobuf_column_types.fetch(:timestamp, false) && _protobuf_column_types[:timestamp].include?(key)
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/active_record/config.rb

@@ -0,0 +1,11 @@
+module Protobuf
+  module ActiveRecord
+    class Config < ActiveSupport::OrderedOptions
+      def initialize(options = {})
+        super
+
+        self[:autoload] = true
+      end
+    end
+  end
+end

data/lib/protobuf/active_record/errors.rb

@@ -0,0 +1,23 @@
+module Protobuf
+  module ActiveRecord
+    # = Protobuf Active Record errors
+    #
+    # Generic Protobuf Active Record exception class
+    class ProtobufActiveRecordError < StandardError
+    end
+
+    # Raised by `attribute_from_proto` when the transformer method
+    # given is not callable.
+    class AttributeTransformerError < ProtobufActiveRecordError
+    end
+
+    # Raised by `field_from_record` when the convert method
+    # given not callable.
+    class FieldTransformerError < ProtobufActiveRecordError
+    end
+
+    # Raised by `field_scope` when given scope is not defined.
+    class SearchScopeError < ProtobufActiveRecordError
+    end
+  end
+end

data/lib/protobuf/active_record/mass_assignment_security.rb

@@ -0,0 +1,16 @@
+require 'active_support/concern'
+require 'protobuf/active_record/mass_assignment_security/persistence'
+require 'protobuf/active_record/mass_assignment_security/transformation'
+
+module Protobuf
+  module ActiveRecord
+    module MassAssignmentSecurity
+      extend ::ActiveSupport::Concern
+
+      included do
+        include Protobuf::ActiveRecord::MassAssignmentSecurity::Persistence
+        include Protobuf::ActiveRecord::MassAssignmentSecurity::Transformation
+      end
+    end
+  end
+end

data/lib/protobuf/active_record/mass_assignment_security/persistence.rb

@@ -0,0 +1,57 @@
+require 'active_support/concern'
+
+module Protobuf
+  module ActiveRecord
+    module MassAssignmentSecurity
+      module Persistence
+        extend ::ActiveSupport::Concern
+
+        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
+
+      # Override Active Record's initialize method so it can accept a protobuf
+      # message as it's attributes.
+      # :noapi:
+      def initialize(*args, &block)
+        args[0] = attributes_from_proto(args.first) if args.first.is_a?(::Protobuf::Message)
+
+        super(*args, &block)
+      end
+    end
+  end
+end

data/lib/protobuf/active_record/mass_assignment_security/transformation.rb

@@ -0,0 +1,27 @@
+require 'active_support/concern'
+
+module Protobuf
+  module ActiveRecord
+    module MassAssignmentSecurity
+      module Transformation
+        extend ::ActiveSupport::Concern
+
+        module ClassMethods
+          # 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
+            if accessible_attributes.present?
+              accessible_attributes.to_a
+            else
+              self.attribute_names - protected_attributes.to_a
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/active_record/model.rb

@@ -0,0 +1,32 @@
+require 'protobuf/active_record/attribute_methods'
+require 'protobuf/active_record/columns'
+require 'protobuf/active_record/errors'
+require 'protobuf/active_record/mass_assignment_security'
+require 'protobuf/active_record/persistence'
+require 'protobuf/active_record/scope'
+require 'protobuf/active_record/serialization'
+require 'protobuf/active_record/transformation'
+require 'protobuf/active_record/validations'
+
+module Protobuf
+  module ActiveRecord
+    module Model
+      extend ::ActiveSupport::Concern
+
+      included do
+        include Protobuf::ActiveRecord::AttributeMethods
+        include Protobuf::ActiveRecord::Columns
+        include Protobuf::ActiveRecord::Serialization
+        include Protobuf::ActiveRecord::Scope
+        include Protobuf::ActiveRecord::Transformation
+        include Protobuf::ActiveRecord::Validations
+
+        if defined?(::ActiveModel::MassAssignmentSecurity)
+          include Protobuf::ActiveRecord::MassAssignmentSecurity
+        else
+          include Protobuf::ActiveRecord::Persistence
+        end
+      end
+    end
+  end
+end

data/lib/protobuf/active_record/persistence.rb

@@ -0,0 +1,55 @@
+require 'active_support/concern'
+
+module Protobuf
+  module ActiveRecord
+    module Persistence
+      extend ::ActiveSupport::Concern
+
+      module ClassMethods
+        # :nodoc:
+        def create(attributes = {}, &block)
+          attributes = attributes_from_proto(attributes) if attributes.is_a?(::Protobuf::Message)
+
+          super(attributes, &block)
+        end
+
+        # :nodoc:
+        def create!(attributes = {}, &block)
+          attributes = attributes_from_proto(attributes) if attributes.is_a?(::Protobuf::Message)
+
+          super(attributes, &block)
+        end
+      end
+
+      # Override Active Record's initialize method so it can accept a protobuf
+      # message as it's attributes.
+      # :noapi:
+      def initialize(*args, &block)
+        args[0] = attributes_from_proto(args.first) if args.first.is_a?(::Protobuf::Message)
+
+        super(*args, &block)
+      end
+
+      # :nodoc:
+      def assign_attributes(attributes)
+        attributes = attributes_from_proto(attributes) if attributes.is_a?(::Protobuf::Message)
+
+        super(attributes)
+      end
+
+      # :nodoc:
+      def update_attributes(attributes)
+        attributes = attributes_from_proto(attributes) if attributes.is_a?(::Protobuf::Message)
+
+        super(attributes)
+      end
+
+      # :nodoc:
+      def update_attributes!(attributes)
+        attributes = attributes_from_proto(attributes) if attributes.is_a?(::Protobuf::Message)
+
+        super(attributes)
+      end
+    end
+  end
+end

data/lib/protobuf/active_record/railtie.rb

@@ -0,0 +1,11 @@
+module Protobuf
+  module ActiveRecord
+    class Railtie < Rails::Railtie
+      config.protobuf_active_record = Protobuf::ActiveRecord.config
+
+      ActiveSupport.on_load(:active_record) do
+        extend Protobuf::ActiveRecord::LoadHooks if Protobuf::ActiveRecord.config.autoload
+      end
+    end
+  end
+end

data/lib/protobuf/active_record/scope.rb

@@ -0,0 +1,121 @@
+require 'active_support/concern'
+
+module Protobuf
+  module ActiveRecord
+    module Scope
+      extend ::ActiveSupport::Concern
+
+      included do
+        class << self
+          alias_method :by_fields, :search_scope
+          alias_method :scope_from_proto, :search_scope
+        end
+      end
+
+      module ClassMethods
+        # 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.
+        #
+        # 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, options = {})
+          scope_name = if options.include?(:scope)
+                         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
+
+        # Get an ARel relation to build off of. If we're in Rails 4 we need to
+        # use `all` instead of `scoped`.
+        # :noapi:
+        def model_scope
+          ::ActiveRecord::VERSION::MAJOR >= 4 ? all : scoped
+        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)
+          search_relation = model_scope
+
+          searchable_fields.each do |field, scope_name|
+            next unless proto.respond_to_and_has_and_present?(field)
+
+            unless self.respond_to?(scope_name)
+              raise Protobuf::ActiveRecord::SearchScopeError, "Undefined scope :#{scope_name}."
+            end
+
+            search_values = parse_search_values(proto, field)
+            search_relation = search_relation.__send__(scope_name, *search_values)
+          end
+
+          return search_relation
+        end
+
+        # :noapi:
+        def searchable_fields
+          @_searchable_fields ||= {}
+        end
+
+        # :noapi:
+        def searchable_field_parsers
+          @_searchable_field_parsers ||= {}
+        end
+      end
+    end
+  end
+end