trax_model 0.0.92 → 0.0.93

data/lib/trax/model/attributes.rb

@@ -5,9 +5,11 @@ module Trax
     module Attributes
       extend ::ActiveSupport::Autoload
 
+      autoload :Attribute
       autoload :Mixin
       autoload :Definitions
       autoload :Errors
+      autoload :Fields
       autoload :Types
       autoload :Type
       autoload :Value
@@ -17,7 +19,7 @@ module Trax
       end
 
       def self.register_attribute_type(mod)
-        key = mod.name.demodulize.underscore.split('_')[0].to_sym
+        key = mod.name.demodulize.underscore.to_sym
 
         config.attribute_types[key] = mod
       end

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

@@ -0,0 +1,11 @@
+module Trax
+  module Model
+    module Attributes
+      class Attribute
+        #should be an abstract class attribute, but making it a normal
+        #class attribute for now until https://github.com/jruby/jruby/issues/3096
+        class_attribute :type
+      end
+    end
+  end
+end

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

@@ -13,6 +13,22 @@ module Trax
         def attribute(*args, type:, **options, &block)
           @model.trax_attribute(*args, type: type, **options, &block)
         end
+
+        def boolean(*args, **options, &block)
+          attribute(*args, :type => :boolean, **options, &block)
+        end
+
+        def enum(*args, **options, &block)
+          attribute(*args, type: :enum, **options, &block)
+        end
+
+        def string(*args, **options, &block)
+          attribute(*args, :type => :string, **options, &block)
+        end
+
+        def struct(*args, **options, &block)
+          attribute(*args, :type => :json, **options, &block)
+        end
       end
     end
   end

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

@@ -9,6 +9,14 @@ module Trax
             "#{type} is an unknown trax model attribute type"
           }
         end
+
+        class DefineAttributeMethodNotDefined < ::Trax::Core::Errors::Base
+          argument :type, :required => true
+
+          message {
+            "#{type} must define a define_attribute method"
+          }
+        end
       end
     end
   end

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

@@ -0,0 +1,74 @@
+module Trax
+  module Model
+    module Attributes
+      module Fields
+        def self.extended(base)
+          base.module_attribute(:_blank_fields_hash) {
+            ::Hashie::Mash.new
+          }
+        end
+
+        def all
+          @all ||= begin
+            constants.map{|const_name| const_get(const_name) }.each_with_object(self._blank_fields_hash) do |klass, result|
+              result[klass.name.symbolize] = klass
+            end
+          end
+        end
+
+        def by_type(*type_names)
+          all.select{|k,v| type_names.include?(v.type) }
+             .try(:with_indifferent_access)
+        end
+
+        def each(&block)
+          all.values(&block)
+        end
+
+        def each_pair(*args, &block)
+          all.each_pair(*args, &block)
+        end
+
+        def booleans
+          @booleans ||= by_type(:boolean)
+        end
+
+        def enums
+          @enums ||= by_type(:enum)
+        end
+
+        def structs
+          @structs ||= by_type(:struct)
+        end
+
+        def strings
+          @strings ||= by_type(:string)
+        end
+
+        def to_schema
+          schema = all.inject(::Hashie::Mash.new) do |result, (k,v)|
+            case v.try(:type)
+            when :enum
+              result[k] = v.to_schema
+            when :struct
+              result[k] = v.to_schema
+            else
+              result[k] = v.try(:to_schema)
+            end
+
+            result
+          end
+          schema
+        end
+
+        def values
+          all.values
+        end
+
+        def [](_name)
+          const_get(_name.to_s.camelize)
+        end
+      end
+    end
+  end
+end

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

@@ -2,41 +2,70 @@ module Trax
   module Model
     module Attributes
       module Mixin
-        def self.mixin_registry_key; :attributes end;
-
-        extend ::Trax::Model::Mixin
+        extend ::Trax::Core::Concern
 
         included do
-          class_attribute :trax_attribute_fields
-
-          self.trax_attribute_fields = ::ActiveSupport::HashWithIndifferentAccess.new
-
           ::Trax::Model::Attributes.config.attribute_types.each_pair do |key, mod|
-            include mod::Mixin
+            include mod::Mixin if mod.const_defined?("Mixin")
           end
         end
 
+        after_included do
+          evaluate_attribute_definitions_blocks
+        end
+
         module ClassMethods
-          # so we can keep all our definitions in same place, and largely so we
-          # can use attribute method to define methods
-          #probably overkill but..
           def define_attributes(&block)
-            model_klass_proxy = ::Trax::Model::Attributes::Definitions.new(self)
-            model_klass_proxy.instance_eval(&block)
+            self.instance_variable_set("@_attribute_definitions_block", block)
           end
 
-          def trax_attribute(name, type:, **options, &block)
-            trax_attribute_fields[type] ||= {}
+          #recursively search direct parent classes for attribute definitions, so we can fully support
+          #inheritance
+          def fetch_attribute_definitions_in_chain(_attribute_definitions_blocks = [], klass=nil)
+            _attribute_definitions_blocks.push(klass.instance_variable_get("@_attribute_definitions_block")) if klass && klass.instance_variable_defined?("@_attribute_definitions_block")
+
+            if klass && klass.superclass != ::ActiveRecord::Base
+              return fetch_attribute_definitions_in_chain(_attribute_definitions_blocks, klass.superclass)
+            else
+              return _attribute_definitions_blocks.compact
+            end
+          end
 
+          def fields_module
+            @fields_module ||= begin
+              module_name = "#{self.name}::Fields"
+              ::Trax::Core::NamedModule.new(module_name, ::Trax::Model::Attributes::Fields, :definition_context => self)
+            end
+          end
+
+          def fields
+            @fields ||= fields_module
+          end
+
+          def trax_attribute(name, type:, **options, &block)
             raise ::Trax::Model::Attributes::Errors::UnknownAttributeType.new(type: type) unless ::Trax::Model::Attributes.key?(type)
-            attribute_type_definition_method = ::Trax::Model::Attributes[type]::Mixin::ClassMethods.instance_methods.first
 
-            self.send(attribute_type_definition_method, name, **options, &block)
+            if ::Trax::Model::Attributes[type].const_defined?("Mixin")
+              attribute_type_definition_method = ::Trax::Model::Attributes[type]::Mixin::ClassMethods.instance_methods.first
+              self.send(attribute_type_definition_method, name, **options, &block)
+              self.validates(name, options[:validates]) if options.key?(:validates)
+            elsif ::Trax::Model::Attributes[type].respond_to?(:define_attribute)
+              ::Trax::Model::Attributes[type].define_attribute(self, name, **options, &block)
+              self.validates(name, options[:validates]) if options.key?(:validates)
+            else
+              raise ::Trax::Model::Attributes::Errors::UnknownAttributeType.new(type: type)
+            end
+          end
+
+          def evaluate_attribute_definitions_blocks
+            model_klass_proxy = ::Trax::Model::Attributes::Definitions.new(self)
+            attribute_definition_blocks = self.superclasses_until(::ActiveRecord::Base, self, [ self ]).map{ |klass| klass.instance_variable_get(:@_attribute_definitions_block) }.compact
 
-            self.validates(name, options[:validates]) if options.key?(:validates)
+            attribute_definition_blocks.each do |blk|
+              model_klass_proxy.instance_eval(&blk)
+            end if attribute_definition_blocks.any?
           end
         end
-
       end
     end
   end

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

@@ -2,6 +2,10 @@ module Trax
   module Model
     module Attributes
       class Type
+        class_attribute :value_klass
+        class_attribute :attribute_klass
+        class_attribute :typecaster_klass
+
         def self.inherited(subklass)
           ::Trax::Model::Attributes.register_attribute_type(subklass)
         end

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

@@ -5,6 +5,14 @@ module Trax
     module Attributes
       module Types
         class Array < ::Trax::Model::Attributes::Type
+          def self.define_attribute(source_klass, attribute_name, **options, &block)
+            klass.fields_module.const_set(attributes_klass_name, ::Class.new(::Trax::Model::Attributes[:array]::Value))
+          end
+
+          class Attribute < ::Trax::Model::Attributes::Attribute
+            self.type = :array
+          end
+
           class Value < ::Trax::Model::Attributes::Value
             class_attribute :element_class
             include ::Enumerable
@@ -60,31 +68,6 @@ module Trax
               end
             end
           end
-
-          module Mixin
-            def self.mixin_registry_key; :array_attributes end;
-
-            extend ::Trax::Model::Mixin
-            include ::Trax::Model::Attributes::Mixin
-
-            module ClassMethods
-              def 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[:array]::Value))
-                attributes_klass.instance_eval(&block)
-
-                attributes_klass.element_class = options[:of] if options.has_key?(:of)
-
-                trax_attribute_fields[:array] ||= {}
-                trax_attribute_fields[:array][attribute_name] = attributes_klass
-
-                attribute(attribute_name, ::Trax::Model::Attributes[:array]::TypeCaster.new(target_klass: attributes_klass))
-
-                # self.default_value_for(attribute_name) { self.class.element_class.new }
-                # self.validates(attribute_name, :json_attribute => true)
-              end
-            end
-          end
         end
       end
     end

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

@@ -0,0 +1,51 @@
+require 'hashie/extensions/ignore_undeclared'
+
+module Trax
+  module Model
+    module Attributes
+      module Types
+        class Boolean < ::Trax::Model::Attributes::Type
+          #this will by default validate boolean values
+          def self.define_attribute(klass, attribute_name, **options, &block)
+            klass_name = "#{klass.fields_module.name.underscore}/#{attribute_name}".camelize
+            attribute_klass = if options.key?(:class_name)
+              options[:class_name].constantize
+            else
+              ::Trax::Core::NamedClass.new(klass_name, ::Trax::Model::Attributes[:boolean]::Attribute, :parent_definition => klass, &block)
+            end
+
+            klass.attribute(attribute_name, ::Trax::Model::Attributes::Types::Boolean::TypeCaster.new)
+            klass.validates(attribute_name, :boolean => true) unless options.key?(:validate) && !options[:validate]
+            klass.default_value_for(attribute_name) { options[:default] } if options.key?(:default)
+          end
+
+          class Attribute < ::Trax::Model::Attributes::Attribute
+            self.type = :boolean
+
+            def self.to_schema
+              ::Trax::Core::Definition.new({
+                :name => attribute_name,
+                :type => type.to_s,
+                :source => name,
+                :values => values
+              })
+            end
+
+            private
+
+            def self.attribute_name
+              name.demodulize.underscore
+            end
+
+            def self.values
+              [ true, false ]
+            end
+          end
+
+          class TypeCaster < ActiveRecord::Type::Boolean
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -5,24 +5,65 @@ module Trax
     module Attributes
       module Types
         class Enum < ::Trax::Model::Attributes::Type
-          class TypeCaster < ActiveRecord::Type::Integer
+          #note: we dont validate enum attribute value because typecaster will turn it into nil which we allow
+          def self.define_attribute(klass, attribute_name, **options, &block)
+            klass_name = "#{klass.fields_module.name.underscore}/#{attribute_name}".camelize
+            attribute_klass = if options.key?(:class_name)
+              options[:class_name].constantize
+            else
+              ::Trax::Core::NamedClass.new(klass_name, ::Enum, :parent_definition => klass, &block)
+            end
+
+            klass.attribute(attribute_name, ::Trax::Model::Attributes::Types::Enum::TypeCaster.new(target_klass: attribute_klass))
+            klass.default_value_for(attribute_name) { options[:default] } if options.key?(:default)
+            define_scopes(klass, attribute_name, attribute_klass) unless options.key?(:define_scopes) && !options[:define_scopes]
+          end
+
+          def self.define_scopes(klass, attribute_name, attribute_klass)
+            klass.class_eval do
+              scope_method_name = :"by_#{attribute_name}"
+              scope_not_method_name = :"by_#{attribute_name}_not"
+
+              scope scope_method_name, lambda { |*values|
+                values.flat_compact_uniq!
+                where(attribute_name => attribute_klass.select_values(*values))
+              }
+              scope scope_not_method_name, lambda { |*values|
+                values.flat_compact_uniq!
+                where.not(attribute_name => attribute_klass.select_values(*values))
+              }
+            end
           end
 
-          module Mixin
-            def self.mixin_registry_key; :enum_attributes end;
+          class TypeCaster < ActiveRecord::Type::Value
+            include ::ActiveRecord::Type::Mutable
 
-            extend ::Trax::Model::Mixin
-            include ::Trax::Model::Attributes::Mixin
-            include ::Trax::Model::Enum
+            def type; :enum end;
 
-            module ClassMethods
-              def enum_attribute(attribute_name, values:, **options, &block)
-                attribute(attribute_name, ::Trax::Model::Attributes[:enum]::TypeCaster.new)
+            def initialize(*args, target_klass:)
+              super(*args)
+
+              @target_klass = target_klass
+            end
 
-                options.delete(:validates) if options.key?(:validates)
+            def type_cast_from_user(value)
+              @target_klass === value ? @target_klass.new(value) : nil
+            end
+
+            def type_cast_from_database(value)
+              return if value.nil?
+
+              value.present? ? @target_klass.new(value.to_i) : value
+            end
+
+            def type_cast_for_database(value)
+              return if value.nil?
+
+              value.try(:to_i) { @target_klass.new(value).to_i }
+            end
 
-                as_enum(attribute_name, values, **options)
-              end
+            def changed_in_place?(raw_old_value, new_value)
+              raw_old_value.try(:to_i) != type_cast_for_database(new_value)
             end
           end
         end

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

@@ -5,14 +5,43 @@ module Trax
     module Attributes
       module Types
         class Json < ::Trax::Model::Attributes::Type
-          class Value < ::Trax::Model::Struct
-            def self.permitted_keys
-              @permitted_keys ||= properties.map(&:to_sym)
-            end
+          module ValueExtensions
+            extend ::ActiveSupport::Concern
 
             def inspect
               self.to_hash.inspect
             end
+
+            def to_json
+              self.to_hash.to_json
+            end
+
+            module ClassMethods
+              def type; :struct end;
+
+              def permitted_keys
+                @permitted_keys ||= properties.map(&:to_sym)
+              end
+            end
+          end
+
+          def self.define_attribute(klass, attribute_name, **options, &block)
+            klass_name = "#{klass.fields_module.name.underscore}/#{attribute_name}".camelize
+            attribute_klass = if options.key?(:class_name)
+              _klass = options[:class_name].constantize
+              _klass.include(ValueExtensions)
+              _klass
+            else
+              ::Trax::Core::NamedClass.new(klass_name, Value, :parent_definition => klass, &block)
+            end
+
+            klass.attribute(attribute_name, typecaster_klass.new(target_klass: attribute_klass))
+            klass.validates(attribute_name, :json_attribute => true) unless options.key?(:validate) && !options[:validate]
+            klass.default_value_for(attribute_name) { {} }
+          end
+
+          class Value < ::Trax::Model::Struct
+            include ValueExtensions
           end
 
           class TypeCaster < ActiveRecord::Type::Value
@@ -37,38 +66,12 @@ module Trax
             end
 
             def type_cast_for_database(value)
-              value.present? ? value.to_hash.to_json : nil
+              value.present? ? value.to_serializable_hash.to_json : nil
             end
           end
 
-          module Mixin
-            def self.mixin_registry_key; :json_attributes end;
-
-            extend ::Trax::Model::Mixin
-            include ::Trax::Model::Attributes::Mixin
-
-            included do
-              class_attribute :json_attribute_fields
-
-              self.json_attribute_fields = ::ActiveSupport::HashWithIndifferentAccess.new
-            end
-
-            module ClassMethods
-              def json_attribute(attribute_name, **options, &block)
-                attributes_klass_name = "#{attribute_name}_attributes".classify
-                attributes_klass = const_set(attributes_klass_name, ::Class.new(::Trax::Model::Attributes[:json]::Value))
-                attributes_klass.instance_eval(&block)
-
-                trax_attribute_fields[:json] ||= {}
-                trax_attribute_fields[:json][attribute_name] = attributes_klass
-
-                attribute(attribute_name, ::Trax::Model::Attributes[:json]::TypeCaster.new(target_klass: attributes_klass))
-
-                self.default_value_for(attribute_name) { {} }
-                self.validates(attribute_name, :json_attribute => true) unless options.key?(:validate) && !options[:validate]
-              end
-            end
-          end
+          self.value_klass = ::Trax::Model::Attributes::Types::Json::Value
+          self.typecaster_klass = ::Trax::Model::Attributes::Types::Json::TypeCaster
         end
       end
     end