trax_model 0.0.91 → 0.0.92

data/lib/trax/model/attributes/types/uuid_array.rb

@@ -0,0 +1,83 @@
+require 'hashie/extensions/ignore_undeclared'
+
+module Trax
+  module Model
+    module Attributes
+      module Types
+        class UuidArray < ::Trax::Model::Attributes::Type
+          class Value < ::Trax::Model::Attributes::Value
+            def initialize(*args)
+              @array = ::Trax::Model::UUIDArray.new(*args)
+            end
+
+            def __getobj__
+              @array
+            end
+
+            def inspect
+              @array.to_a.flatten.inspect
+            end
+          end
+
+          class TypeCaster < ActiveRecord::Type::Value
+            include ::ActiveRecord::Type::Mutable
+
+            def initialize(*args, target_klass:)
+              super(*args)
+
+              @target_klass = target_klass
+            end
+
+            def type
+              :uuid_array
+            end
+
+            def type_cast_from_user(value)
+              value.is_a?(@target_klass) ? @target_klass : @target_klass.new(value) || @target_klass.new
+            end
+
+            def type_cast_from_database(value)
+              value.present? ? @target_klass.new(*value) : @target_klass.new(nil)
+            end
+
+            def type_cast_for_database(value)
+              if value.present?
+                value.to_json
+              else
+                nil
+              end
+            end
+          end
+
+          module Mixin
+            def self.mixin_registry_key; :uuid_array_attributes end;
+
+            extend ::Trax::Model::Mixin
+            include ::Trax::Model::Attributes::Mixin
+
+            module ClassMethods
+              def uuid_array_attribute(attribute_name, **options, &block)
+                attributes_klass_name = "#{attribute_name}_attributes".classify
+                attributes_klass = const_set(attributes_klass_name, ::Class.new(::Trax::Model::Attributes[:uuid_array]::Value))
+                attributes_klass.instance_eval(&block) if block_given?
+
+                attributes_klass.element_class = options[:of] if options.has_key?(:of)
+
+                trax_attribute_fields[:uuid_array] ||= {}
+                trax_attribute_fields[:uuid_array][attribute_name] = attributes_klass
+
+                if options.has_key?(:default)
+                  self.default_value_for(attribute_name, options[:default])
+                else
+                  []
+                end
+
+                attribute(attribute_name, ::Trax::Model::Attributes[:uuid_array]::TypeCaster.new(target_klass: attributes_klass))
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trax/model/attributes/value.rb

@@ -0,0 +1,9 @@
+module Trax
+  module Model
+    module Attributes
+      class Value < SimpleDelegator
+
+      end
+    end
+  end
+end

data/lib/trax/model/config.rb

@@ -1,20 +1,12 @@
 module Trax
   module Model
     class Config < ::Hashie::Dash
-      ERROR_MESSAGES = {
-        :invalid_uuid_prefix => [
-          "UUID prefix must be 2 characters long",
-          "and be 0-9 or a-f",
-          "for hexadecimal id compatibility"
-        ].join("\n")
-      }.freeze
-
       property :uuid_prefix, :default => nil
       property :uuid_column, :default => :id
 
       def uuid_prefix=(prefix)
         if prefix.length != 2 || prefix.chars.any?{|char| char !~ /[0-9a-f]/ }
-          raise ::Trax::Model::Errors::InvalidPrefixForUUID.new(prefix)
+          raise ::Trax::Model::Errors::InvalidPrefixForUUID.new(:prefix => prefix)
         end
 
         self[:uuid_prefix] = ::Trax::Model::UUIDPrefix.new(prefix)

data/lib/trax/model/enum.rb

@@ -20,7 +20,7 @@
 module Trax
   module Model
     module Enum
-      include ::Trax::Model::Mixin
+      extend ::Trax::Model::Mixin
 
       module ClassMethods
         def define_scopes_for_trax_enum(enum_name)
@@ -50,13 +50,13 @@ module Trax
           validation_options = { :in => enum_values, :message => options.extract!(:message)[:message] }
 
           self.validates_inclusion_of(enum_name, validation_options) unless options.key?(:validate) && !options[:validate]
+          
           options.delete(:validate) if options.key?(:validate)
 
           define_scopes_for_trax_enum(enum_name)
 
-          self.default_value_for(enum_name) { default_value } if default_value
-
           super(enum_name, enum_mapping, options)
+          self.default_value_for(enum_name) { default_value } if default_value
         end
       end
     end

data/lib/trax/model/errors.rb

@@ -1,32 +1,43 @@
+require 'trax/core/errors'
+
 module Trax
   module Model
     module Errors
-      class Base < StandardError
-        def initialize(*args)
-          message = (self.class::MESSAGE + args).join("\n")
-          super(message)
-        end
+      class MixinNotRegistered < ::Trax::Core::Errors::Base
+        argument :mixin
+        argument :model
+
+        message {
+          "#{model} tried to load mixin: #{mixin}, whichdoes not exist in " \
+          "registry. Registered mixins were #{::Trax::Model.mixin_registry.keys.join(', ')} \n"
+        }
       end
 
-      class InvalidPrefix < Trax::Model::Errors::Base
-        MESSAGE = [
-          "UUID prefix must be 2 characters long",
-          "and be 0-9 or a-f",
+      class InvalidPrefix < ::Trax::Core::Errors::Base
+        argument :prefix, :required => true
+
+        message {
+          "Prefix #{prefix}"
+          "UUID prefix must be 2 characters long" \
+          "and be 0-9 or a-f" \
           "for hexadecimal id compatibility"
-        ]
+        }
       end
 
-      class DuplicatePrefixRegistered < Trax::Model::Errors::Base
-        MESSAGE = [
-          "UUID prefix must be unique, the",
-          "following prefix was already registered"
-        ]
+      class DuplicatePrefixRegistered < Trax::Core::Errors::Base
+        argument :prefix, :required => true
+        argument :model, :required => true
+
+        message {
+          "UUID prefix must be unique,\n" \
+          "#{prefix} was already registered by #{model}!"
+        }
       end
 
-      class STIAttributeNotFound < ::Trax::Model::Errors::Base
-        MESSAGE = [
-          "STI Attribute was not found for attribute"
-        ]
+      class STIAttributeNotFound < ::Trax::Core::Errors::Base
+        argument :attribute_name
+
+        message { "STI Attribute was not found for #{attribute_name}" }
       end
     end
   end

data/lib/trax/model/freezable.rb

@@ -1,7 +1,7 @@
 module Trax
   module Model
     module Freezable
-      include ::Trax::Model::Mixin
+      extend ::Trax::Model::Mixin
 
       included do
         class_attribute :freezable_fields

data/lib/trax/model/mixin.rb

@@ -1,12 +1,24 @@
 module Trax
   module Model
     module Mixin
-      extend ::ActiveSupport::Concern
+      def self.extended(base)
+        base.extend(::ActiveSupport::Concern)
 
-      included do
-        self.extend(::ActiveSupport::Concern)
+        super(base)
 
-        ::Trax::Model.register_mixin(self)
+        ::Trax::Model.register_mixin(base)
+      end
+
+      def after_included(&block)
+        self.instance_variable_set(:@_after_included_block, block)
+      end
+
+      def mixed_in(&block)
+        after_included(&block)
+      end
+
+      def mixed(&block)
+        after_included(&block)
       end
     end
   end

data/lib/trax/model/railtie.rb

@@ -0,0 +1,17 @@
+module Trax
+  module Model
+    class Railtie < ::Rails::Railtie
+      ::ActiveSupport.on_load(:active_record) do
+        def self.inherited(subklass)
+          subklass.include(::Trax::Model) if ::Trax::Model.config.auto_include
+
+          super(subklass)
+
+          ::Trax::Model.config.auto_include_mixins.each do |mixin|
+            subklass.mixin(mixin)
+          end if ::Trax::Model.config.auto_include_mixins.any?
+        end
+      end
+    end
+  end
+end

data/lib/trax/model/registry.rb

@@ -3,7 +3,7 @@ module Trax
     class Registry
       class_attribute :models
 
-      self.models ||= ::Hashie::Mash.new
+      self.models = ::Hashie::Mash.new
 
       class << self
         delegate :key?, :to => :models
@@ -52,8 +52,8 @@ module Trax
       end
 
       def self.uuid_map
-        models.values.reject{|model| model.try(:uuid_prefix) == nil }.inject(::Hashie::Mash.new) do |result, model|
-          result[model.uuid_prefix] = model
+        models.values.reject{|model| model.try(:unique_id_config).try(:uuid_prefix) == nil }.inject(::Hashie::Mash.new) do |result, model|
+          result[model.unique_id_config.uuid_prefix] = model
           result
         end
       end

data/lib/trax/model/restorable.rb

@@ -1,50 +1,59 @@
 module Trax
   module Model
     module Restorable
-      include ::Trax::Model::Mixin
+      extend ::Trax::Model::Mixin
 
-      included do
-        class_attribute :_restorable_config
-
-        alias_method :destroy!, :destroy
+      define_configuration_options! do
+        option :field, :default => :is_deleted
+        option :timestamp_field, :default => :deleted_at
+        option :hide_deleted, :default => true
+        option :alias_destroy, :default => true
+      end
 
-        self._restorable_config = {
-          :field => :is_deleted,
-          :timestamp_field => :deleted_at,
-          :hide_deleted => true
-        }
+      included do
+        define_configuration_options!(:restorable) do
+          option :field, :default => ::Trax::Model::Restorable.config.field
+          option :timestamp_field, :default => ::Trax::Model::Restorable.config.timestamp_field
+          option :hide_deleted, :default => ::Trax::Model::Restorable.config.hide_deleted
+          option :alias_destroy, :default => ::Trax::Model::Restorable.config.alias_destroy
+        end
       end
 
       module ClassMethods
         def setup_restorable!
           self.class_eval do
-            if(self._restorable_config[:hide_deleted])
+            if(self.restorable_config.hide_deleted)
               default_scope { by_not_deleted }
             end
 
+            if(self.restorable_config.alias_destroy)
+              alias_method :destroy!, :destroy
+            end
+
             ### Clear default deleted scope ###
             scope :by_is_deleted, lambda { |*|
-              unscope(:where => self._restorable_config[:field]).where(self._restorable_config[:field] => true)
+              unscope(:where => self.restorable_config.field).where(self.restorable_config.field => true)
             }
             scope :by_not_deleted, lambda { |*|
-              where(self._restorable_config[:field] => false)
+              where(self.restorable_config.field => false)
             }
 
-            default_value_for(self._restorable_config[:field]) { false }
+            default_value_for(self.restorable_config.field) { false }
           end
         end
       end
 
       def destroy
-        self.update_attributes(self._restorable_config[:field] => true, self._restorable_config[:timestamp_field] => ::DateTime.now)
+        self.update_attributes(self.class.restorable_config.field => true, self.class.restorable_config.timestamp_field => ::DateTime.now)
       end
 
       def restore
-        self.update_attributes(self._restorable_config[:field] => false, self._restorable_config[:timestamp_field] => ::DateTime.now)
+        self.update_attributes(self.class.restorable_config.field => false, self.class.restorable_config.timestamp_field => ::DateTime.now)
       end
 
       def self.apply_mixin(target, options)
-        target._restorable_config.merge!(options)
+        target.restorable_config.merge!(options)
+
         target.setup_restorable!
       end
     end

data/lib/trax/model/struct.rb

@@ -0,0 +1,31 @@
+module Trax
+  module Model
+    class Struct < ::Hashie::Dash
+      include ::Hashie::Extensions::Dash::IndifferentAccess
+      include ::Hashie::Extensions::Coercion
+      include ::Hashie::Extensions::IgnoreUndeclared
+      include ::ActiveModel::Validations
+
+      class_attribute :property_types
+
+      def self.inherited(subklass)
+        super(subklass)
+
+        subklass.property_types = {}.dup.tap do |hash|
+          hash[:structs] = []
+          hash
+        end
+      end
+
+      def self.struct_property(name, *args, **options, &block)
+        struct_klass_name = "#{name}_structs".classify
+        struct_klass = const_set(struct_klass_name, ::Class.new(::Trax::Model::Struct))
+        struct_klass.instance_eval(&block)
+        options[:default] = {} unless options.key?(:default)
+        property(name, *args, **options)
+        coerce_key(name, struct_klass)
+        property_types[:structs].push(name)
+      end
+    end
+  end
+end

data/lib/trax/model/unique_id.rb

@@ -1,17 +1,56 @@
 module Trax
   module Model
     module UniqueId
-      include ::Trax::Model::Mixin
+      extend ::Trax::Model::Mixin
+
+      define_configuration_options! do
+        option :uuid_column, :default => :id
+        option :uuid_map, :default => {}
+      end
 
       included do
-        #grab prefix from uuid registry if using that
-        if ::Trax::Model::UUID.klass_prefix_map.has_key?(self.name)
-          self.trax_defaults.uuid_prefix = ::Trax::Model::UUIDPrefix.new(klass_prefix_map[self.name])
+        define_configuration_options!(:unique_id) do
+          option :uuid_prefix,
+                 :setter => lambda{ |prefix|
+                   if(::Trax::Model::UniqueId.config.uuid_map.values.include?(prefix) && ::Trax::Model::UniqueId.config.uuid_map[self.source.name] != prefix)
+                     raise ::Trax::Model::Errors::DuplicatePrefixRegistered.new(:prefix => prefix, :model => self.source.name)
+                   end
+
+                   ::Trax::Model::UniqueId.config.uuid_map[self.source.name] = prefix
+                   ::Trax::Model::UUIDPrefix.new(prefix)
+                 },
+                 :validates => {
+                   :exclusion => {
+                     :in => ::Trax::Model::Registry.uuid_map.values
+                   },
+                   :inclusion => {
+                     :in => ::Trax::Model::UUIDPrefix.all,
+                     :message => "%{value} not a valid uuid prefix!\nRun Trax::Model::UUIDPrefix.all for valid prefix list"
+                   },
+                   :allow_nil => true
+                 }
+
+          option :uuid_column, :default => ::Trax::Model::UniqueId.config.uuid_column
+        end
+
+        #grab prefix from uuid registry if uuids are defined in an initializer
+        if ::Trax::Model.mixin_registry.key?(:unique_id) && ::Trax::Model::UUID.klass_prefix_map.key?(self.name)
+          self.unique_id_config.uuid_prefix = ::Trax::Model::UUID.klass_prefix_map[self.name]
+        end
+      end
+
+      after_included do |options|
+        self.unique_id_config.merge!(options)
+
+        if(self.unique_id_config.uuid_prefix)
+          default_value_for(:"#{self.unique_id_config.uuid_column}") {
+            ::Trax::Model::UUID.generate(self.unique_id_config.uuid_prefix)
+          }
         end
       end
 
       def uuid
-        uuid_column = self.class.trax_defaults.uuid_column
+        uuid_column = self.class.unique_id_config.uuid_column
         uuid_value = (uuid_column == "uuid") ? super : __send__(uuid_column)
 
         ::Trax::Model::UUID.new(uuid_value)
@@ -33,17 +72,20 @@ module Trax
       end
 
       module ClassMethods
-        delegate :uuid_prefix, :to => :trax_defaults
-        delegate :uuid_column, :to => :trax_defaults
-
-        def defaults(*args)
-          super(*args)
-
-          self.default_value_for(:"#{self.trax_defaults.uuid_column}") {
-            ::Trax::Model::UUID.generate(self.trax_defaults.uuid_prefix)
-          }
+        def uuid_prefix
+          self.unique_id_config.uuid_prefix
         end
       end
+
+      # def self.apply_mixin(target, options)
+      #   target.unique_id_config.merge!(options)
+      #
+      #   if(target.unique_id_config.uuid_prefix)
+      #     target.default_value_for(:"#{target.unique_id_config.uuid_column}") {
+      #       ::Trax::Model::UUID.generate(target.unique_id_config.uuid_prefix)
+      #     }
+      #   end
+      # end
     end
   end
 end