trax_model 0.0.92 → 0.0.93

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

@@ -0,0 +1,50 @@
+require 'hashie/extensions/ignore_undeclared'
+
+module Trax
+  module Model
+    module Attributes
+      module Types
+        class String < ::Trax::Model::Attributes::Type
+          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, Value, :parent_definition => klass, &block)
+            end
+
+            klass.attribute(attribute_name, typecaster_klass.new(target_klass: attribute_klass))
+            klass.default_value_for(attribute_name) { options[:default] } if options.key?(:default)
+          end
+
+          class Value < ::Trax::Model::Attributes::Value
+            def self.type; :string end;
+          end
+
+          class TypeCaster < ActiveRecord::Type::String
+            def initialize(*args, target_klass:)
+              super(*args)
+
+              @target_klass = target_klass
+            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(value) : value
+            end
+
+            def type_cast_for_database(value)
+              value.try(:to_s)
+            end
+          end
+
+          self.value_klass = ::Trax::Model::Attributes::Types::String::Value
+          self.typecaster_klass = ::Trax::Model::Attributes::Types::String::TypeCaster
+        end
+      end
+    end
+  end
+end

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

@@ -5,6 +5,23 @@ module Trax
     module Attributes
       module Types
         class UuidArray < ::Trax::Model::Attributes::Type
+          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, Value, :parent_definition => klass, &block)
+            end
+
+            attribute_klass.element_class = options[:of] if options.has_key?(:of)
+            options.has_key?(:default) ? self.default_value_for(attribute_name, options[:default]) : []
+            klass.attribute(attribute_name, typecaster_klass.new(target_klass: attribute_klass))
+          end
+
+          class Attribute < ::Trax::Model::Attributes::Attribute
+            self.type = :uuid_array
+          end
+
           class Value < ::Trax::Model::Attributes::Value
             def initialize(*args)
               @array = ::Trax::Model::UUIDArray.new(*args)
@@ -48,34 +65,6 @@ module Trax
               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

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

@@ -2,7 +2,23 @@ module Trax
   module Model
     module Attributes
       class Value < SimpleDelegator
+        include ::ActiveModel::Validations
 
+        def initialize(val)
+          @value = val
+        end
+
+        def __getobj__
+          @value
+        end
+
+        def self.symbolic_name
+          name.demodulize.underscore.to_sym
+        end
+
+        def self.to_sym
+          :value
+        end
       end
     end
   end

data/lib/trax/model/errors.rb

@@ -34,6 +34,13 @@ module Trax
         }
       end
 
+      class FieldDoesNotExist < Trax::Core::Errors::Base
+        argument :field, :required => true
+        argument :model, :required => true
+
+        message { "Field #{field} does not exist for #{model}" }
+      end
+
       class STIAttributeNotFound < ::Trax::Core::Errors::Base
         argument :attribute_name
 

data/lib/trax/model/mixins.rb

@@ -0,0 +1,11 @@
+module Trax
+  module Model
+    module Mixins
+      extend ::ActiveSupport::Autoload
+
+      autoload :FieldScopes
+      autoload :IdScopes
+      autoload :SortByScopes
+    end
+  end
+end

data/lib/trax/model/mixins/field_scopes.rb

@@ -0,0 +1,60 @@
+module Trax
+  module Model
+    module Mixins
+      module FieldScopes
+        extend ::Trax::Model::Mixin
+
+        mixed_in do |**options|
+          options.each_pair do |field_scope_name, field_scope_options|
+            field_scope_options = {} if [ true, false ].include?(field_scope_options)
+
+            field_scope_options[:field] ||= field_scope_name.to_s.include?("by_") ? field_scope_name.to_s.split("by_").pop.to_sym : field_scope_name
+            field_scope_options[:type] ||= :where
+
+            case field_scope_options[:type]
+            when :where
+              define_where_scope_for_field(field_scope_name, **field_scope_options)
+            when :match
+              define_matching_scope_for_field(field_scope_name, **field_scope_options)
+            when :matching
+              define_matching_scope_for_field(field_scope_name, **field_scope_options)
+            when :not
+              define_where_not_scope_for_field(field_scope_name, **field_scope_options)
+            when :where_not
+              define_where_not_scope_for_field(field_scope_name, **field_scope_options)
+            else
+              define_where_scope_for_field(field_scope_name, **field_scope_options)
+            end
+          end
+        end
+
+        module ClassMethods
+          private
+          def define_where_scope_for_field(field_scope_name, **options)
+            scope field_scope_name, lambda{ |*_values|
+              _values.flat_compact_uniq!
+              where(options[:field] => _values)
+            }
+
+            # Alias scope names with pluralized versions, i.e. by_id also => by_ids
+            singleton_class.__send__(:alias_method, :"#{field_scope_name.to_s.pluralize}", field_scope_name)
+          end
+
+          def define_where_not_scope_for_field(field_scope_name, **options)
+            scope field_scope_name, lambda{ |*_values|
+              _values.flat_compact_uniq!
+              where.not(options[:field] => _values)
+            }
+          end
+
+          def define_matching_scope_for_field(field_scope_name, **options)
+            scope field_scope_name, lambda{ |*_values|
+              _values.flat_compact_uniq!
+              matching(options[:field] => _values)
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trax/model/mixins/id_scopes.rb

@@ -0,0 +1,36 @@
+#note this only works with postgres UUID column Types
+
+module Trax
+  module Model
+    module Mixins
+      module IdScopes
+        extend ::Trax::Model::Mixin
+
+        included do
+          if table_exists?
+            id_column_names = self.columns.select{ |col| col.sql_type == "uuid" }.map(&:name).map(&:to_sym)
+            id_column_names.each do |_id_column_name|
+              scope :"by_#{_id_column_name}", lambda{ |*_record_ids|
+                _record_ids.flat_compact_uniq!
+                where(_id_column_name => _record_ids)
+              }
+
+              scope :"by_#{_id_column_name}_not", lambda{ |*_record_ids|
+                _record_ids.flat_compact_uniq!
+                where.not(_id_column_name => _record_ids)
+              }
+
+              define_singleton_method(:"by_#{_id_column_name}s") do |*_record_ids|
+                __send__("by_#{_id_column_name}", _record_ids)
+              end
+
+              define_singleton_method(:"by_#{_id_column_name}s_not") do |*_record_ids|
+                __send__("by_#{_id_column_name}_not", _record_ids)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trax/model/mixins/sort_by_scopes.rb

@@ -0,0 +1,25 @@
+module Trax
+  module Model
+    module Mixins
+      module SortByScopes
+        extend ::Trax::Model::Mixin
+
+        included do
+          scope :sort_by_most_recent, lambda{|field_name='created_at'|
+            order("#{field_name} DESC")
+          }
+          scope :sort_by_least_recent, lambda{|field_name='created_at'|
+            order("#{field_name} ASC")
+          }
+
+          class << self
+            alias_method :sort_by_newest, :sort_by_most_recent
+            alias_method :sort_by_oldest, :sort_by_least_recent
+            alias_method :by_newest, :sort_by_most_recent
+            alias_method :by_oldest, :sort_by_least_recent
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trax/model/railtie.rb

@@ -4,6 +4,7 @@ module Trax
       ::ActiveSupport.on_load(:active_record) do
         def self.inherited(subklass)
           subklass.include(::Trax::Model) if ::Trax::Model.config.auto_include
+          subklass.include(::Trax::Model::Attributes::Mixin) if ::Trax::Model.config.auto_include
 
           super(subklass)
 

data/lib/trax/model/scopes.rb

@@ -0,0 +1,16 @@
+module Trax
+  module Model
+    module Scopes
+      extend ::ActiveSupport::Concern
+
+      module ClassMethods
+        def field_scope(attr_name)
+          scope attr_name, lambda{ |*_scope_values|
+            _scope_values.flat_compact_uniq!
+            where(attr_name => _scope_values)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/trax/model/struct.rb

@@ -1,30 +1,184 @@
+require 'hashie/extensions/coercion'
+require 'hashie/extensions/indifferent_access'
+require 'hashie/extensions/dash/indifferent_access'
+
 module Trax
   module Model
     class Struct < ::Hashie::Dash
       include ::Hashie::Extensions::Dash::IndifferentAccess
       include ::Hashie::Extensions::Coercion
       include ::Hashie::Extensions::IgnoreUndeclared
+      include ::Hashie::Extensions::Dash::PropertyTranslation
       include ::ActiveModel::Validations
 
-      class_attribute :property_types
-
-      def self.inherited(subklass)
-        super(subklass)
+      # note that we must explicitly set default or blank values for all properties.
+      # It defeats the whole purpose of being a 'struct'
+      # if we fail to do so, and it makes our data far more error prone
+      DEFAULT_VALUES_FOR_PROPERTY_TYPES = {
+        :boolean_property => nil,
+        :string_property  => "",
+        :struct_property  => {},
+        :enum_property    => nil,
+      }.with_indifferent_access.freeze
 
-        subklass.property_types = {}.dup.tap do |hash|
-          hash[:structs] = []
-          hash
+      def self.fields_module
+        @fields_module ||= begin
+          module_name = "#{self.name}::Fields"
+          ::Trax::Core::NamedModule.new(module_name, ::Trax::Model::Attributes::Fields)
         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)
+      def self.fields
+        fields_module
+      end
+
+      def self.boolean_property(name, *args, **options, &block)
+        name = name.is_a?(Symbol) ? name.to_s : name
+        klass_name = "#{fields_module.name.underscore}/#{name}".camelize
+        boolean_klass = ::Trax::Core::NamedClass.new(klass_name, Trax::Model::Attributes[:boolean]::Attribute, :parent_definition => self, &block)
+        options[:default] = options.key?(:default) ? options[:default] : DEFAULT_VALUES_FOR_PROPERTY_TYPES[__method__]
+        define_where_scopes_for_boolean_property(name, boolean_klass) unless options.key?(:define_scopes) && !options[:define_scopes]
         property(name, *args, **options)
-        coerce_key(name, struct_klass)
-        property_types[:structs].push(name)
+      end
+
+      def self.string_property(name, *args, **options, &block)
+        name = name.is_a?(Symbol) ? name.to_s : name
+        klass_name = "#{fields_module.name.underscore}/#{name}".camelize
+        string_klass = ::Trax::Core::NamedClass.new(klass_name, Trax::Model::Attributes[:string]::Value, :parent_definition => self, &block)
+        options[:default] = options.key?(:default) ? options[:default] : DEFAULT_VALUES_FOR_PROPERTY_TYPES[__method__]
+        define_where_scopes_for_property(name, string_klass) unless options.key?(:define_scopes) && !options[:define_scopes]
+        property(name.to_sym, *args, **options)
+        coerce_key(name.to_sym, string_klass)
+      end
+
+      def self.struct_property(name, *args, **options, &block)
+        name = name.is_a?(Symbol) ? name.to_s : name
+        klass_name = "#{fields_module.name.underscore}/#{name}".camelize
+        struct_klass = ::Trax::Core::NamedClass.new(klass_name, Trax::Model::Struct, :parent_definition => self, &block)
+        validates(name, :json_attribute => true) unless options[:validate] && !options[:validate]
+        options[:default] = options.key?(:default) ? options[:default] : DEFAULT_VALUES_FOR_PROPERTY_TYPES[__method__]
+        property(name.to_sym, *args, **options)
+        coerce_key(name.to_sym, struct_klass)
+      end
+
+      #note: cant validate because we are coercing which will turn it into nil
+      def self.enum_property(name, *args, **options, &block)
+        name = name.is_a?(Symbol) ? name.to_s : name
+        klass_name = "#{fields_module.name.underscore}/#{name}".camelize
+        enum_klass = ::Trax::Core::NamedClass.new(klass_name, ::Enum, :parent_definition => self, &block)
+        options[:default] = options.key?(:default) ? options[:default] : DEFAULT_VALUES_FOR_PROPERTY_TYPES[__method__]
+        define_scopes_for_enum(name, enum_klass) unless options.key?(:define_scopes) && !options[:define_scopes]
+        property(name.to_sym, *args, **options)
+        coerce_key(name.to_sym, enum_klass)
+      end
+
+      def self.to_schema
+        ::Trax::Core::Definition.new(
+          :source => self.name,
+          :name => self.name.demodulize.underscore,
+          :type => :struct,
+          :fields => self.fields_module.to_schema
+        )
+      end
+
+      def self.type; :struct end;
+
+      def to_serializable_hash
+        _serializable_hash = to_hash
+
+        self.class.fields_module.enums.keys.each do |attribute_name|
+          _serializable_hash[attribute_name] = _serializable_hash[attribute_name].try(:to_i)
+        end if self.class.fields_module.enums.keys.any?
+
+        _serializable_hash
+      end
+
+      class << self
+        alias :boolean :boolean_property
+        alias :enum :enum_property
+        alias :struct :struct_property
+        alias :string :string_property
+      end
+
+      def value
+        self
+      end
+
+      private
+      #this only supports properties 1 level deep, but works beautifully
+      #I.E. for this structure
+      # define_attributes do
+      #   struct :custom_fields do
+      #     enum :color, :default => :blue do
+      #       define :blue,     1
+      #       define :red,      2
+      #       define :green,    3
+      #     end
+      #   end
+      # end
+      # ::Product.by_custom_fields_color(:blue, :red)
+      # will return #{Product color=blue}, #{Product color=red}
+      def self.define_scopes_for_enum(attribute_name, enum_klass)
+        return unless has_active_record_ancestry?(enum_klass)
+
+        model_class = model_class_for_property(enum_klass)
+        field_name = enum_klass.parent_definition.name.demodulize.underscore
+        attribute_name = enum_klass.name.demodulize.underscore
+        scope_name = :"by_#{field_name}_#{attribute_name}"
+        model_class.scope(scope_name, lambda{ |*_scope_values|
+          _integer_values = enum_klass.select_values(*_scope_values.flat_compact_uniq!)
+          _integer_values.map!(&:to_s)
+          model_class.where("#{field_name} -> '#{attribute_name}' IN(?)", _integer_values)
+        })
+      end
+
+      def self.define_where_scopes_for_boolean_property(attribute_name, property_klass)
+        return unless has_active_record_ancestry?(property_klass)
+
+        model_class = model_class_for_property(property_klass)
+        field_name = property_klass.parent_definition.name.demodulize.underscore
+        attribute_name = property_klass.name.demodulize.underscore
+        scope_name = :"by_#{field_name}_#{attribute_name}"
+        model_class.scope(scope_name, lambda{ |*_scope_values|
+          _scope_values.map!(&:to_s).flat_compact_uniq!
+          model_class.where("#{field_name} -> '#{attribute_name}' IN(?)", _scope_values)
+        })
+      end
+
+      def self.define_where_scopes_for_property(attribute_name, property_klass)
+        return unless has_active_record_ancestry?(property_klass)
+
+        model_class = model_class_for_property(property_klass)
+        field_name = property_klass.parent_definition.name.demodulize.underscore
+        attribute_name = property_klass.name.demodulize.underscore
+        scope_name = :"by_#{field_name}_#{attribute_name}"
+
+        model_class.scope(scope_name, lambda{ |*_scope_values|
+          _scope_values.map!(&:to_s).flat_compact_uniq!
+          model_class.where("#{field_name} ->> '#{attribute_name}' IN(?)", _scope_values)
+        })
+      end
+
+      def self.has_active_record_ancestry?(property_klass)
+        return false unless property_klass.respond_to?(:parent_definition)
+
+        result = if property_klass.parent_definition.ancestors.include?(::ActiveRecord::Base)
+          true
+        else
+          has_active_record_ancestry?(property_klass.parent_definition)
+        end
+
+        result
+      end
+
+      def self.model_class_for_property(property_klass)
+        result = if property_klass.parent_definition.ancestors.include?(::ActiveRecord::Base)
+          property_klass.parent_definition
+        else
+          model_class_for_property(property_klass.parent_definition)
+        end
+
+        result
       end
     end
   end