trax_model 0.0.91 → 0.0.92

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 809159b1a30e397711f6f8dc007fd412b8e689ca
-  data.tar.gz: b9be65956b716ee4a8750a9edb7f2812d18fdb38
+  metadata.gz: d24f88faa95bde183c2a7046d8c1d86b604987bd
+  data.tar.gz: 4c124fcd2c0f21166cfc7012b75979af8551d4b7
 SHA512:
-  metadata.gz: 71c0453bed5cb715577fed35c59aad6c9a910cb7fc2435a0b423304a5e4af9d00bce47707dfac47165923567030a5b6338c9cc9dc372937d798b366f96b71a0e
-  data.tar.gz: 562cab67f023f85a5a84b26e76ab3f9dc9d30480c728b0a87534723d25e21d7bb7557134c8ff97fdfee61d61453540ff9a0c3fb73f3d970044f05da84fa55036
+  metadata.gz: 5cac8b9cf60e27ab5c532ba6dc7a778319440392240cb38083676cdcaa10466446e8981fac14bca8397132ecc88f006fd551da8e040116a653e5897049cf23c2
+  data.tar.gz: 89309b58c39783f84f322664750a05214b9522a7d7be892bcc0a00b269077563404c4622a5c549e57d4fdedd64fe5e7be949266e774279676118b234db2085d2

data/Gemfile

@@ -1,3 +1,3 @@
 source 'https://rubygems.org'
-
+gem 'trax_core', :path => "~/gems/trax_core"
 gemspec

data/lib/trax/model.rb

@@ -4,10 +4,12 @@ require 'hashie/dash'
 require 'hashie/mash'
 require 'simple_enum'
 require_relative './string'
-# require_relative './enum'
+require_relative './validators/boolean_validator'
 require_relative './validators/email_validator'
+require_relative './validators/enum_validator'
 require_relative './validators/frozen_validator'
 require_relative './validators/future_validator'
+require_relative './validators/json_attribute_validator'
 require_relative './validators/subdomain_validator'
 require_relative './validators/url_validator'
 
@@ -16,6 +18,7 @@ module Trax
     extend ::ActiveSupport::Concern
     extend ::ActiveSupport::Autoload
 
+    autoload :Attributes
     autoload :Config
     autoload :Enum
     autoload :Errors
@@ -28,24 +31,38 @@ module Trax
     autoload :Mixin
     autoload :MTI
     autoload :Restorable
+    autoload :Railtie
     autoload :STI
+    autoload :Struct
     autoload :Validators
 
     include ::Trax::Model::Matchable
     include ::ActiveModel::Dirty
 
+    define_configuration_options! do
+      option :auto_include, :default => false
+      option :auto_include_mixins, :default => []
+    end
+
     class << self
       attr_accessor :mixin_registry
     end
 
     @mixin_registry = {}
 
-    def self.register_mixin(mixin_klass)
-      mixin_key = mixin_klass.name.demodulize.underscore.to_sym
+    def self.register_mixin(mixin_klass, key = nil)
+      mixin_key = mixin_klass.respond_to?(:mixin_registry_key) ? mixin_klass.mixin_registry_key : (key || mixin_klass.name.demodulize.underscore.to_sym)
+
+      return if mixin_registry.key?(mixin_key)
       mixin_registry[mixin_key] = mixin_klass
     end
 
+    def self.root
+      ::Pathname.new(::File.path(__FILE__))
+    end
+
     def self.eager_autoload_mixins!
+      ::Trax::Model::Attributes::Mixin
       ::Trax::Model::Enum
       ::Trax::Model::Freezable
       ::Trax::Model::Restorable
@@ -55,9 +72,9 @@ module Trax
     eager_autoload_mixins!
 
     included do
-      class_attribute :trax_defaults
+      class_attribute :registered_mixins
 
-      self.trax_defaults = ::Trax::Model::Config.new
+      self.registered_mixins = {}
 
       register_trax_models(self)
     end
@@ -66,19 +83,57 @@ module Trax
       delegate :register_trax_model, :to => "::Trax::Model::Registry"
       delegate :[], :to => :find
 
-      def defaults(options = {})
-        options.each_pair do |key, val|
-          self.trax_defaults.__send__("#{key}=", val)
+      def after_inherited(&block)
+        instance_variable_set(:@_after_inherited_block, block)
+      end
+
+      #the tracepoint stuff is to ensure that we call the after_inherited block not
+      #right after the class is defined, but rather, after the class is defined and
+      #evaluated. i.e. this allows us to do stuff like set class attributes
+      # class_attribute :messages_class
+      #
+      # after_inherited do
+      #   has_many :computed_subtype_messages, :class_name => message_class
+      # end
+      # - Then in subklass
+      # self.messages_class = "MySubtypeSpecifcModel"
+
+      def inherited(subklass)
+        super(subklass)
+
+        if self.instance_variable_defined?(:@_after_inherited_block)
+          trace = ::TracePoint.new(:end) do |tracepoint|
+            if tracepoint.self == subklass
+              trace.disable
+
+              subklass.instance_eval(&self.instance_variable_get(:@_after_inherited_block))
+            end
+          end
+
+          trace.enable
         end
       end
 
       def mixin(key, options = {})
-        mixin_klass = ::Trax::Model.mixin_registry[key]
+        raise ::Trax::Model::Errors::MixinNotRegistered.new(
+          model: self.name,
+          mixin: key
+        )  unless ::Trax::Model.mixin_registry.key?(key)
+
+        mixin_module = ::Trax::Model.mixin_registry[key]
+        self.registered_mixins[key] = mixin_module
 
         self.class_eval do
-          unless self.ancestors.include?(mixin_klass)
-            include(mixin_klass)
-            mixin_klass.apply_mixin(self, options) if mixin_klass.respond_to?(:apply_mixin)
+          include(mixin_module) unless self.ancestors.include?(mixin_module)
+
+          options = {} if options.is_a?(TrueClass)
+          options = { options => true } if options.is_a?(Symbol)
+          mixin_module.apply_mixin(self, options) if mixin_module.respond_to?(:apply_mixin)
+
+          if mixin_module.instance_variable_defined?(:@_after_included_block)
+            block = mixin_module.instance_variable_get(:@_after_included_block)
+
+            instance_exec(options, &block)
           end
         end
       end
@@ -105,5 +160,9 @@ module Trax
         name.underscore
       end
     end
+
+    ::ActiveSupport.run_load_hooks(:trax_model, self)
   end
 end
+
+::Trax::Model::Railtie if defined?(Rails)

data/lib/trax/model/attributes.rb

@@ -0,0 +1,40 @@
+require 'hashie/extensions/ignore_undeclared'
+
+module Trax
+  module Model
+    module Attributes
+      extend ::ActiveSupport::Autoload
+
+      autoload :Mixin
+      autoload :Definitions
+      autoload :Errors
+      autoload :Types
+      autoload :Type
+      autoload :Value
+
+      define_configuration_options! do
+        option :attribute_types, :default => {}
+      end
+
+      def self.register_attribute_type(mod)
+        key = mod.name.demodulize.underscore.split('_')[0].to_sym
+
+        config.attribute_types[key] = mod
+      end
+
+      def self.[](key)
+        config.attribute_types[key]
+      end
+
+      def self.key?(type)
+        config.attribute_types.has_key?(type)
+      end
+
+      def self.eager_autoload_types!
+        ::Trax::Model::Attributes::Types
+      end
+
+      eager_autoload_types!
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Trax
+  module Model
+    module Attributes
+      class Definitions < ::SimpleDelegator
+        def initialize(model)
+          @model = model
+        end
+
+        def __getobj__
+          @model
+        end
+
+        def attribute(*args, type:, **options, &block)
+          @model.trax_attribute(*args, type: type, **options, &block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Trax
+  module Model
+    module Attributes
+      module Errors
+        class UnknownAttributeType < ::Trax::Core::Errors::Base
+          argument :type, :required => true
+
+          message {
+            "#{type} is an unknown trax model attribute type"
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Trax
+  module Model
+    module Attributes
+      module Mixin
+        def self.mixin_registry_key; :attributes end;
+
+        extend ::Trax::Model::Mixin
+
+        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
+          end
+        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)
+          end
+
+          def trax_attribute(name, type:, **options, &block)
+            trax_attribute_fields[type] ||= {}
+
+            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)
+
+            self.validates(name, options[:validates]) if options.key?(:validates)
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Trax
+  module Model
+    module Attributes
+      class Type
+        def self.inherited(subklass)
+          ::Trax::Model::Attributes.register_attribute_type(subklass)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module Trax
+  module Model
+    module Attributes
+      module Types
+        ::Trax::Core::FS::CurrentDirectory.new['types'].recursive_files.each do |file|
+          load file
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,92 @@
+require 'hashie/extensions/ignore_undeclared'
+#totally not working atm :), dont use me!
+module Trax
+  module Model
+    module Attributes
+      module Types
+        class Array < ::Trax::Model::Attributes::Type
+          class Value < ::Trax::Model::Attributes::Value
+            class_attribute :element_class
+            include ::Enumerable
+
+            def initialize(*args)
+              @array = super(*args)
+              @array.map!{ |ele| self.class.element_class.new(ele) } if self.class.element_class && @array.any?
+            end
+
+            def __getobj__
+              @array
+            end
+
+            def <<(val)
+              if self.class.element_class && val.class == self.class.element_class
+                super(val)
+              else
+                super(self.class.element_class.new(val))
+              end
+            end
+
+            def each(&block)
+              yield __getobj__.each(&block)
+            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
+              :array
+            end
+
+            def type_cast_from_user(value)
+              value.is_a?(@target_klass) ? @target_klass : @target_klass.new(value || {})
+            end
+
+            def type_cast_from_database(value)
+              value.present? ? @target_klass.new(JSON.parse(value)) : value
+            end
+
+            def type_cast_for_database(value)
+              if value.present?
+                value.map{ |element| element.try(:to_json) }
+              else
+                nil
+              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
+  end
+end

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

@@ -0,0 +1,32 @@
+require 'hashie/extensions/ignore_undeclared'
+
+module Trax
+  module Model
+    module Attributes
+      module Types
+        class Enum < ::Trax::Model::Attributes::Type
+          class TypeCaster < ActiveRecord::Type::Integer
+          end
+
+          module Mixin
+            def self.mixin_registry_key; :enum_attributes end;
+
+            extend ::Trax::Model::Mixin
+            include ::Trax::Model::Attributes::Mixin
+            include ::Trax::Model::Enum
+
+            module ClassMethods
+              def enum_attribute(attribute_name, values:, **options, &block)
+                attribute(attribute_name, ::Trax::Model::Attributes[:enum]::TypeCaster.new)
+
+                options.delete(:validates) if options.key?(:validates)
+
+                as_enum(attribute_name, values, **options)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+require 'hashie/extensions/ignore_undeclared'
+
+module Trax
+  module Model
+    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
+
+            def inspect
+              self.to_hash.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
+              :json
+            end
+
+            def type_cast_from_user(value)
+              value.is_a?(@target_klass) ? @target_klass : @target_klass.new(value || {})
+            end
+
+            def type_cast_from_database(value)
+              value.present? ? @target_klass.new(JSON.parse(value)) : value
+            end
+
+            def type_cast_for_database(value)
+              value.present? ? value.to_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
+        end
+      end
+    end
+  end
+end