duck_record 0.0.1

data/lib/duck_record/locale/en.yml

@@ -0,0 +1,48 @@
+en:
+  # Attributes names common to most models
+  #attributes:
+    #created_at: "Created at"
+    #updated_at: "Updated at"
+
+  # Default error messages
+  errors:
+    messages:
+      required: "must exist"
+      taken: "has already been taken"
+
+  # Active Record models configuration
+  activerecord:
+    errors:
+      messages:
+        record_invalid: "Validation failed: %{errors}"
+        restrict_dependent_destroy:
+          has_one: "Cannot delete record because a dependent %{record} exists"
+          has_many: "Cannot delete record because dependent %{record} exist"
+        # Append your own errors here or at the model/attributes scope.
+
+      # You can define own errors for models or model attributes.
+      # The values :model, :attribute and :value are always available for interpolation.
+      #
+      # For example,
+      #   models:
+      #     user:
+      #       blank: "This is a custom blank message for %{model}: %{attribute}"
+      #       attributes:
+      #         login:
+      #           blank: "This is a custom blank message for User login"
+      # Will define custom blank validation message for User model and
+      # custom blank validation message for login attribute of User model.
+      #models:
+
+    # Translate model names. Used in Model.human_name().
+    #models:
+      # For example,
+      #   user: "Dude"
+      # will translate User model name to "Dude"
+
+    # Translate model attribute names. Used in Model.human_attribute_name(attribute).
+    #attributes:
+      # For example,
+      #   user:
+      #     login: "Handle"
+      # will translate User attribute "login" as "Handle"

data/lib/duck_record/model_schema.rb

@@ -0,0 +1,64 @@
+module DuckRecord
+  module ModelSchema
+    extend ActiveSupport::Concern
+
+    included do
+      delegate :type_for_attribute, to: :class
+    end
+
+    module ClassMethods
+
+      def attributes_builder # :nodoc:
+        @attributes_builder ||= AttributeSet::Builder.new(attribute_types)
+      end
+
+      def attribute_types # :nodoc:
+        load_schema
+        @attribute_types ||= Hash.new
+      end
+
+      def yaml_encoder # :nodoc:
+        @yaml_encoder ||= AttributeSet::YAMLEncoder.new(attribute_types)
+      end
+
+      # Returns the type of the attribute with the given name, after applying
+      # all modifiers. This method is the only valid source of information for
+      # anything related to the types of a model's attributes. This method will
+      # access the database and load the model's schema if it is required.
+      #
+      # The return value of this method will implement the interface described
+      # by ActiveModel::Type::Value (though the object itself may not subclass
+      # it).
+      #
+      # +attr_name+ The name of the attribute to retrieve the type for. Must be
+      # a string
+      def type_for_attribute(attr_name, &block)
+        if block
+          attribute_types.fetch(attr_name, &block)
+        else
+          attribute_types[attr_name]
+        end
+      end
+
+      def _default_attributes # :nodoc:
+        @default_attributes ||= AttributeSet.new({})
+      end
+
+      private
+
+      def schema_loaded?
+        defined?(@loaded) && @loaded
+      end
+
+      def load_schema
+        unless schema_loaded?
+          load_schema!
+        end
+      end
+
+      def load_schema!
+        @loaded = true
+      end
+    end
+  end
+end

data/lib/duck_record/serialization.rb

@@ -0,0 +1,19 @@
+module DuckRecord #:nodoc:
+  # = Active Record \Serialization
+  module Serialization
+    extend ActiveSupport::Concern
+    include ActiveModel::Serializers::JSON
+
+    included do
+      self.include_root_in_json = false
+    end
+
+    def serializable_hash(options = nil)
+      options = options.try(:dup) || {}
+
+      options[:except] = Array(options[:except]).map(&:to_s)
+
+      super(options)
+    end
+  end
+end

data/lib/duck_record/translation.rb

@@ -0,0 +1,22 @@
+module DuckRecord
+  module Translation
+    include ActiveModel::Translation
+
+    # Set the lookup ancestors for ActiveModel.
+    def lookup_ancestors #:nodoc:
+      klass = self
+      classes = [klass]
+      return classes if klass == DuckRecord::Base
+
+      while klass != klass.base_class
+        classes << klass = klass.superclass
+      end
+      classes
+    end
+
+    # Set the i18n scope to overwrite ActiveModel.
+    def i18n_scope #:nodoc:
+      :activerecord
+    end
+  end
+end

data/lib/duck_record/type/array.rb

@@ -0,0 +1,36 @@
+module DuckRecord
+  module Type # :nodoc:
+    class Array < ActiveModel::Type::Value # :nodoc:
+      include ActiveModel::Type::Helpers::Mutable
+
+      attr_reader :subtype
+      delegate :type, :user_input_in_time_zone, :limit, to: :subtype
+
+      def initialize(subtype)
+        @subtype = subtype
+      end
+
+      def cast(value)
+        type_cast_array(value, :cast)
+      end
+
+      def ==(other)
+        other.is_a?(Array) && subtype == other.subtype
+      end
+
+      def map(value, &block)
+        value.map(&block)
+      end
+
+      private
+
+      def type_cast_array(value, method)
+        if value.is_a?(::Array)
+          value.map { |item| type_cast_array(item, method) }
+        else
+          @subtype.public_send(method, value)
+        end
+      end
+    end
+  end
+end

data/lib/duck_record/type/decimal_without_scale.rb

@@ -0,0 +1,13 @@
+module DuckRecord
+  module Type
+    class DecimalWithoutScale < ActiveModel::Type::BigInteger # :nodoc:
+      def type
+        :decimal
+      end
+
+      def type_cast_for_schema(value)
+        value.to_s.inspect
+      end
+    end
+  end
+end

data/lib/duck_record/type/internal/abstract_json.rb

@@ -0,0 +1,33 @@
+module DuckRecord
+  module Type
+    module Internal # :nodoc:
+      class AbstractJson < ActiveModel::Type::Value # :nodoc:
+        include ActiveModel::Type::Helpers::Mutable
+
+        def type
+          :json
+        end
+
+        def deserialize(value)
+          if value.is_a?(::String)
+            ::ActiveSupport::JSON.decode(value) rescue nil
+          else
+            value
+          end
+        end
+
+        def serialize(value)
+          if value.nil?
+            nil
+          else
+            ::ActiveSupport::JSON.encode(value)
+          end
+        end
+
+        def accessor
+          DuckRecord::Store::StringKeyedHashAccessor
+        end
+      end
+    end
+  end
+end

data/lib/duck_record/type/json.rb

@@ -0,0 +1,6 @@
+module DuckRecord
+  module Type
+    class JSON < Internal::AbstractJson
+    end
+  end
+end

data/lib/duck_record/type/registry.rb

@@ -0,0 +1,97 @@
+require 'active_model/type/registry'
+
+module DuckRecord
+  # :stopdoc:
+  module Type
+    class Registry < ActiveModel::Type::Registry
+      def add_modifier(options, klass)
+        registrations << DecorationRegistration.new(options, klass)
+      end
+
+      private
+
+      def registration_klass
+        Registration
+      end
+
+      def find_registration(symbol, *args)
+        registrations
+          .select { |registration| registration.matches?(symbol, *args) }
+          .max
+      end
+    end
+
+    class Registration
+      def initialize(name, block, override: nil)
+        @name = name
+        @block = block
+        @override = override
+      end
+
+      def call(_registry, *args, **kwargs)
+        if kwargs.any? # https://bugs.ruby-lang.org/issues/10856
+          block.call(*args, **kwargs)
+        else
+          block.call(*args)
+        end
+      end
+
+      def matches?(type_name, *args, **kwargs)
+        type_name == name
+      end
+
+      def <=>(other)
+        priority <=> other.priority
+      end
+
+      # TODO Change this to private once we've dropped Ruby 2.2 support.
+      # Workaround for Ruby 2.2 "private attribute?" warning.
+      protected
+
+      attr_reader :name, :block, :adapter, :override
+
+      def priority
+        result = 0
+        if override
+          result |= 1
+        end
+        result
+      end
+    end
+
+    class DecorationRegistration < Registration
+      def initialize(options, klass)
+        @options = options
+        @klass = klass
+      end
+
+      def call(registry, *args, **kwargs)
+        subtype = registry.lookup(*args, **kwargs.except(*options.keys))
+        klass.new(subtype)
+      end
+
+      def matches?(*args, **kwargs)
+        matches_options?(**kwargs)
+      end
+
+      def priority
+        super | 4
+      end
+
+      # TODO Change this to private once we've dropped Ruby 2.2 support.
+      # Workaround for Ruby 2.2 "private attribute?" warning.
+      protected
+
+      attr_reader :options, :klass
+
+      private
+
+      def matches_options?(**kwargs)
+        options.all? do |key, value|
+          kwargs[key] == value
+        end
+      end
+    end
+  end
+  # :startdoc:
+end

data/lib/duck_record/type/serialized.rb

@@ -0,0 +1,63 @@
+module DuckRecord
+  module Type
+    class Serialized < DelegateClass(ActiveModel::Type::Value) # :nodoc:
+      include ActiveModel::Type::Helpers::Mutable
+
+      attr_reader :subtype, :coder
+
+      def initialize(subtype, coder)
+        @subtype = subtype
+        @coder = coder
+        super(subtype)
+      end
+
+      def deserialize(value)
+        if default_value?(value)
+          value
+        else
+          coder.load(super)
+        end
+      end
+
+      def serialize(value)
+        return if value.nil?
+        unless default_value?(value)
+          super coder.dump(value)
+        end
+      end
+
+      def inspect
+        Kernel.instance_method(:inspect).bind(self).call
+      end
+
+      def changed_in_place?(raw_old_value, value)
+        return false if value.nil?
+        raw_new_value = encoded(value)
+        raw_old_value.nil? != raw_new_value.nil? ||
+          subtype.changed_in_place?(raw_old_value, raw_new_value)
+      end
+
+      def accessor
+        DuckRecord::Store::IndifferentHashAccessor
+      end
+
+      def assert_valid_value(value)
+        if coder.respond_to?(:assert_valid_value)
+          coder.assert_valid_value(value, action: "serialize")
+        end
+      end
+
+      private
+
+        def default_value?(value)
+          value == coder.load(nil)
+        end
+
+        def encoded(value)
+          unless default_value?(value)
+            coder.dump(value)
+          end
+        end
+    end
+  end
+end

data/lib/duck_record/type/text.rb

@@ -0,0 +1,9 @@
+module DuckRecord
+  module Type
+    class Text < ActiveModel::Type::String # :nodoc:
+      def type
+        :text
+      end
+    end
+  end
+end

data/lib/duck_record/type/unsigned_integer.rb

@@ -0,0 +1,15 @@
+module DuckRecord
+  module Type
+    class UnsignedInteger < ActiveModel::Type::Integer # :nodoc:
+      private
+
+      def max_value
+        super * 2
+      end
+
+      def min_value
+        0
+      end
+    end
+  end
+end

data/lib/duck_record/type.rb

@@ -0,0 +1,66 @@
+require 'active_model/type'
+
+require 'duck_record/type/internal/abstract_json'
+require 'duck_record/type/json'
+
+require 'duck_record/type/array'
+
+require 'duck_record/type/serialized'
+require 'duck_record/type/registry'
+
+module DuckRecord
+  module Type
+    @registry = Registry.new
+
+    class << self
+      attr_accessor :registry # :nodoc:
+      delegate :add_modifier, to: :registry
+
+      # Add a new type to the registry, allowing it to be referenced as a
+      # symbol by {ActiveRecord::Base.attribute}[rdoc-ref:Attributes::ClassMethods#attribute].
+      # If your type is only meant to be used with a specific database adapter, you can
+      # do so by passing <tt>adapter: :postgresql</tt>. If your type has the same
+      # name as a native type for the current adapter, an exception will be
+      # raised unless you specify an +:override+ option. <tt>override: true</tt> will
+      # cause your type to be used instead of the native type. <tt>override:
+      # false</tt> will cause the native type to be used over yours if one exists.
+      def register(type_name, klass = nil, **options, &block)
+        registry.register(type_name, klass, **options, &block)
+      end
+
+      def lookup(*args, **kwargs) # :nodoc:
+        registry.lookup(*args, **kwargs)
+      end
+    end
+
+    Helpers = ActiveModel::Type::Helpers
+    BigInteger = ActiveModel::Type::BigInteger
+    Binary = ActiveModel::Type::Binary
+    Boolean = ActiveModel::Type::Boolean
+    Decimal = ActiveModel::Type::Decimal
+    DecimalWithoutScale = ActiveModel::Type::DecimalWithoutScale
+    Float = ActiveModel::Type::Float
+    Integer = ActiveModel::Type::Integer
+    String = ActiveModel::Type::String
+    Text = ActiveModel::Type::Text
+    UnsignedInteger = ActiveModel::Type::UnsignedInteger
+    DateTime = ActiveModel::Type::DateTime
+    Time = ActiveModel::Type::Time
+    Date = ActiveModel::Type::Date
+
+    register(:big_integer, Type::BigInteger, override: false)
+    register(:binary, Type::Binary, override: false)
+    register(:boolean, Type::Boolean, override: false)
+    register(:date, Type::Date, override: false)
+    register(:datetime, Type::DateTime, override: false)
+    register(:decimal, Type::Decimal, override: false)
+    register(:float, Type::Float, override: false)
+    register(:integer, Type::Integer, override: false)
+    register(:string, Type::String, override: false)
+    register(:text, Type::Text, override: false)
+    register(:time, Type::Time, override: false)
+    register(:json, Type::JSON, override: false)
+
+    add_modifier({array: true}, Type::Array)
+  end
+end