trax_model 0.0.95 → 0.0.96

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2e9c4e45cdc76295880d1e087727ec1414889bdc
-  data.tar.gz: eb26cfa1732eaa1e2ba69b3b5448e71e8c229837
+  metadata.gz: 41cea382b5de1b943f513df7167f86adb4912f94
+  data.tar.gz: 86a810a545fe00b3de9b759f1be14b82fa632069
 SHA512:
-  metadata.gz: fc5388aaf9d9a351bc4412357e4d7d2b01ccac35934ac02d9b193aa8eb24814f852e482efa6ee455318c8fe4129c65fda97e2d2e11b19fd8a4a943372eec0dab
-  data.tar.gz: 0847884f74518a4fe603b92d2e2366b08218ccf7a56a07d4ae057f5ebc783d952fefcfe532de86117fd7e02656e9b682bab9ee463aa94b5f40e8e30c15ecb696
+  metadata.gz: 93c99a50811671b71bb4a4156ac3200e019d28a03611a80e8ddb0cc9184d830d8129d9f20f6c88c67ec2b93e03bfd82684bbdfb7df7da99c683ba54c1fd2b7bd
+  data.tar.gz: 2b90612a719954a3f0027c6792d14af4a5e445a99b15fd392b57ea597d5439354e54cec3530f223a44cdf46f5f0e5ca0a840e6ddf012cfac4a06ce937334b254

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

@@ -8,10 +8,13 @@ module Trax
           #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
+
+            attribute_klass = if options.key?(:extend)
+              _klass_prototype = options[:extend].constantize
+              _klass = ::Trax::Core::NamedClass.new(klass_name, _klass_prototype, :parent_definition => klass, &block)
+              _klass
             else
-              ::Trax::Core::NamedClass.new(klass_name, ::Enum, :parent_definition => klass, &block)
+              ::Trax::Core::NamedClass.new(klass_name, ::Trax::Core::Types::Enum, :parent_definition => klass, &block)
             end
 
             klass.attribute(attribute_name, ::Trax::Model::Attributes::Types::Enum::TypeCaster.new(target_klass: attribute_klass))

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

@@ -8,6 +8,8 @@ module Trax
           module ValueExtensions
             extend ::ActiveSupport::Concern
 
+            include ::ActiveModel::Validations
+
             def inspect
               self.to_hash.inspect
             end
@@ -16,20 +18,108 @@ module Trax
               self.to_hash.to_json
             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
+
             module ClassMethods
               def type; :struct end;
 
               def permitted_keys
                 @permitted_keys ||= properties.map(&:to_sym)
               end
+
+              #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 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 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 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 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 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
 
           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)
+            attribute_klass = if options.key?(:extend)
+              _klass_prototype = options[:extend].constantize
+              _klass = ::Trax::Core::NamedClass.new(klass_name, _klass_prototype, :parent_definition => klass, &block)
+              _klass.include(ValueExtensions) unless klass.const_defined?("ValueExtensions")
               _klass
             else
               ::Trax::Core::NamedClass.new(klass_name, Value, :parent_definition => klass, &block)
@@ -39,6 +129,7 @@ module Trax
             klass.validates(attribute_name, :json_attribute => true) unless options.key?(:validate) && !options[:validate]
             klass.default_value_for(attribute_name) { {} }
             define_model_accessors(klass, attribute_name, attribute_klass, options[:model_accessors]) if options.key?(:model_accessors) && options[:model_accessors]
+            define_model_scopes(klass, attribute_name, attribute_klass, options[:model_scopes]) if options.key?(:model_scopes) && options[:model_scopes]
           end
 
           class Value < ::Trax::Model::Struct
@@ -59,11 +150,11 @@ module Trax
             end
 
             def type_cast_from_user(value)
-              value.is_a?(@target_klass) ? @target_klass : @target_klass.new(value || {})
+              value.is_a?(@target_klass) ? value : @target_klass.new(value || {})
             end
 
             def type_cast_from_database(value)
-              value.present? ? @target_klass.new(JSON.parse(value)) : value
+              value.present? ? @target_klass.new(::JSON.parse(value)) : value
             end
 
             def type_cast_for_database(value)
@@ -76,15 +167,43 @@ module Trax
 
           private
 
+          def self.define_model_scopes(model, attribute_name, struct_attribute, option_value)
+            properties_to_define = if [ true ].include?(option_value)
+                                     struct_attribute.properties.to_a
+                                   elsif option_value.is_a?(Hash) && option_value.has_key?(:only)
+                                     struct_attribute.properties.to_a & option_value[:only]
+                                   elsif option_value.is_a?(Hash) && option_value.has_key?(:except)
+                                     struct_attribute.properties.to_a - option_value[:except]
+                                   elsif option_value.is_a?(Array)
+                                     struct_attribute.properties.to_a & option_value
+                                   else
+                                     raise Trax::Model::Errors::InvalidOption.new(
+                                       :option => :model_scopes,
+                                       :valid_choices => ["true", "array of properties", "hash with :only or :except keys"]
+                                     )
+                                   end
+
+            properties_to_define.each do |_property|
+              getter_method, setter_method = _property.to_sym, :"#{_property}="
+
+              model.__send__(:define_method, setter_method) do |val|
+                self[attribute_name] = {} unless self[attribute_name]
+                self.__send__(attribute_name).__send__(setter_method, val)
+              end
+
+              model.delegate(getter_method, :to => attribute_name)
+            end
+          end
+
           def self.define_model_accessors(model, attribute_name, struct_attribute, option_value)
             properties_to_define = if [ true ].include?(option_value)
                                      struct_attribute.properties.to_a
-                                   elsif option_value.is_a(Hash) && option_value.has_key?(:only)
-                                     struct_attribute.properties.to_a.only(*option_value[:only])
-                                   elsif option_value.is_a(Hash) && option_value.has_key?(:except)
-                                     struct_attribute.properties.to_a.except(*option_value[:except])
-                                   elsif option_value.is_a(Array)
-                                     struct_attribute.properties.to_a.only(*option_value[:only])
+                                   elsif option_value.is_a?(Hash) && option_value.has_key?(:only)
+                                     struct_attribute.properties.to_a & option_value[:only]
+                                   elsif option_value.is_a?(Hash) && option_value.has_key?(:except)
+                                     struct_attribute.properties.to_a - option_value[:except]
+                                   elsif option_value.is_a?(Array)
+                                     struct_attribute.properties.to_a & option_value
                                    else
                                      raise Trax::Model::Errors::InvalidOption.new(
                                        :option => :model_accessors,

data/lib/trax/model/struct.rb

@@ -96,16 +96,6 @@ module Trax
 
       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

data/lib/trax/model/unique_id.rb

@@ -10,7 +10,6 @@ module Trax
 
       after_included do |options|
         define_configuration_options!(:unique_id) do
-
           option :uuid_prefix,
                  :validates => {
                    :exclusion => {

data/lib/trax/validators/json_attribute_validator.rb

@@ -10,7 +10,7 @@ class JsonAttributeValidator < ActiveModel::EachValidator
     unless value.is_a?(json_attribute) && value.valid?
       if value.is_a?(json_attribute)
         value.errors.messages.each_pair do |k,v|
-          v.flatten.join(", ") if v.is_a?(Array)
+          v = v.flatten.join(", ") if v.is_a?(Array)
           object.errors.add("#{attribute}.#{k}", v)
         end
       else

data/lib/trax_model/version.rb

@@ -1,3 +1,3 @@
 module TraxModel
-  VERSION = '0.0.95'
+  VERSION = '0.0.96'
 end

data/trax_model.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "trax_core", "~> 0.0.76"
+  spec.add_dependency "trax_core", "~> 0.0.80"
   spec.add_dependency "default_value_for", "~> 3.0.0"
   spec.add_dependency "simple_enum"
   spec.add_development_dependency "hashie", ">= 3.4.2"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trax_model
 version: !ruby/object:Gem::Version
-  version: 0.0.95
+  version: 0.0.96
 platform: ruby
 authors:
 - Jason Ayre
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-09 00:00:00.000000000 Z
+date: 2015-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trax_core
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.76
+        version: 0.0.80
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.0.76
+        version: 0.0.80
 - !ruby/object:Gem::Dependency
   name: default_value_for
   requirement: !ruby/object:Gem::Requirement