rhino_project_core 0.21.0.beta.10 → 0.21.0.beta.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f83a151c002a790f546ee4a99f6a5da4c856fe3e0d31c1917bcaf885a5e022a
-  data.tar.gz: 48bfd632de1f2f745e0c0a12ffcb4529b88d93d42b7b01befef4812e42895d20
+  metadata.gz: 48972a6d87e8a9974598926b25ef186f652203f9b1d7c53ebc9de7853f87a493
+  data.tar.gz: 650860cbba709f699f9cac8b63c29a4a285b4b56cb620ec13e524935798a49f0
 SHA512:
-  metadata.gz: 5c8c4ef2c32ed9aaae64dd80d9dad0a7783b71e5c8d0a0b3687e47df69931e9e4b736e1db4283cf72b2b97b4669bfcb653548de762e5d3e9254341b82bd19e17
-  data.tar.gz: 1e32892e2b7c520fe84f0cefca3585de708d723ec6948779a3069de6d8e6cc7bd1f6378f201aa78bc982f94972acc0b36c650a0ab84a0aa0a2abf7047cfd356b
+  metadata.gz: 7cf0499cbf1f48987e6299ea7600eace332c13cb37c10abab42d99de97aaaeedbd9b26f0c8de83cbd9a45c193ebb9124cca5aa22569c91d139c65ddaec8e057c
+  data.tar.gz: 026fd26d7518f039183b1510bca2328aeecaf612350ee904c823a7b5bad4a6305053d886e0fa1fe62865cb4149d0ca60c78924639e5760f185570c2f4c4725ac

data/lib/rhino/resource/active_record_extension/properties_describe.rb

@@ -33,194 +33,200 @@ module Rhino
           end
 
           private
-          # FIXME: It can be a hash if passed in from a reference which might have something like
-          # rhino_references %i[{blog_posts: [:comments]}]
-          # but I cannot find current spot where it is used like that currently
-          def property_name(property)
-            property.is_a?(Hash) ? property.keys.first : property
-          end
-
-          def ref_descriptor(names)
-            {
-              type: :reference,
-              anyOf: names.map { |name| { :$ref => "#/components/schemas/#{name.singularize}" } }
-            }
-          end
-
-          def property_type_and_format_attr(name) # rubocop:todo Metrics/MethodLength
-            atype = attribute_types[name.to_s].type
-
-            # The PG array delegates type to "subtype" which is the actual type of the array elements
-            if attribute_types[name.to_s].is_a? ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array
-              return {
-                type: :array,
-                items: {
-                  type: atype
-                }
-              }
+            # FIXME: It can be a hash if passed in from a reference which might have something like
+            # rhino_references %i[{blog_posts: [:comments]}]
+            # but I cannot find current spot where it is used like that currently
+            def property_name(property)
+              property.is_a?(Hash) ? property.keys.first : property
             end
 
-            if %i[datetime date time].include?(atype)
-              return {
-                type: 'string',
-                format: atype
+            def ref_descriptor(names)
+              {
+                type: :reference,
+                anyOf: names.map { |name| { :$ref => "#/components/schemas/#{name.singularize}" } }
               }
             end
 
-            { type: atype }
-          end
+            def property_type_and_format_attr(name) # rubocop:todo Metrics/MethodLength
+              atype = attribute_types[name.to_s].type
 
-          def nested_array_options(name)
-            ref_sym = name.to_sym
+              # The PG array delegates type to "subtype" which is the actual type of the array elements
+              if attribute_types[name.to_s].is_a? ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array
+                return {
+                  type: :array,
+                  items: {
+                    type: atype
+                  }
+                }
+              end
 
-            array_options = {}
+              if %i[datetime date time].include?(atype)
+                return {
+                  type: "string",
+                  format: atype
+                }
+              end
 
-            if nested_attributes_options[ref_sym]
-              array_options[:creatable] = true
-              array_options[:updatable] = true
-              array_options[:destroyable] = nested_attributes_options[ref_sym][:allow_destroy]
+              { type: atype }
             end
 
-            { "x-rhino-attribute-array": array_options.merge(_properties_array[ref_sym] || {}) }
-          end
+            def nested_array_options(name)
+              ref_sym = name.to_sym
 
-          # rubocop:todo Metrics/PerceivedComplexity
-          # rubocop:todo Metrics/AbcSize
-          def property_type_and_format_ref(name) # rubocop:todo Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
-            assoc = reflections[name]
-            klasses = if assoc.options[:polymorphic]
-             assoc.active_record.send("#{assoc.name}_types").map(&:constantize).map { |m| m.model_name.singular }
-            else
-              # FIXME: The tr hack is to match how model_name in rails handles modularized classes
-              [assoc.options[:class_name]&.underscore&.tr('/', '_') || name]
-            end
+              array_options = {}
 
-            return ref_descriptor(klasses) unless reflections[name].macro == :has_many
+              if nested_attributes_options[ref_sym]
+                array_options[:creatable] = true
+                array_options[:updatable] = true
+                array_options[:destroyable] = nested_attributes_options[ref_sym][:allow_destroy]
+              end
 
-            {
-              type: :array,
-              items: ref_descriptor(klasses).merge(nested_array_options(name))
-            }
-          end
-          # rubocop:enable Metrics/AbcSize
-          # rubocop:enable Metrics/PerceivedComplexity
+              { "x-rhino-attribute-array": array_options.merge(_properties_array[ref_sym] || {}) }
+            end
+
+            # rubocop:todo Metrics/PerceivedComplexity
+            # rubocop:todo Metrics/AbcSize
+            def property_type_and_format_ref(name) # rubocop:todo Metrics/CyclomaticComplexity, Metrics/AbcSize, Metrics/PerceivedComplexity
+              assoc = reflections[name]
+              klasses = if assoc.options[:polymorphic]
+                # If its a delgated type it will have type introspection
+                if assoc.active_record.respond_to?("#{assoc.name}_types")
+                  assoc.active_record.send("#{assoc.name}_types").map(&:constantize).map { |m| m.model_name.singular }
+                else
+                  # FIXME: This is wrong, but there is no good way to introspect general polymorphic models
+                  [name]
+                end
+              else
+                # FIXME: The tr hack is to match how model_name in rails handles modularized classes
+                [assoc.options[:class_name]&.underscore&.tr("/", "_") || name]
+              end
 
-          def property_type_and_format(name) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-            # Special cases
-            return { type: :identifier } if name == identifier_property
-            return { type: :string } if defined_enums.key?(name)
+              return ref_descriptor(klasses) unless reflections[name].macro == :has_many
 
-            # FIXME: Hack for tags for now
-            if attribute_types.key?(name.to_s) && attribute_types[name.to_s].class.to_s == 'ActsAsTaggableOn::Taggable::TagListType'
-              return {
+              {
                 type: :array,
-                items: {
-                  type: 'string'
-                }
+                items: ref_descriptor(klasses).merge(nested_array_options(name))
               }
             end
+            # rubocop:enable Metrics/AbcSize
+            # rubocop:enable Metrics/PerceivedComplexity
+
+            def property_type_and_format(name) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+              # Special cases
+              return { type: :identifier } if name == identifier_property
+              return { type: :string } if defined_enums.key?(name)
+
+              # FIXME: Hack for tags for now
+              if attribute_types.key?(name.to_s) && attribute_types[name.to_s].class.to_s == "ActsAsTaggableOn::Taggable::TagListType"
+                return {
+                  type: :array,
+                  items: {
+                    type: "string"
+                  }
+                }
+              end
 
-            # Use the attribute type if possible
-            return property_type_and_format_attr(name) if attribute_types.key?(name.to_s)
+              # Use the attribute type if possible
+              return property_type_and_format_attr(name) if attribute_types.key?(name.to_s)
 
-            return property_type_and_format_ref(name) if reflections.key?(name)
+              return property_type_and_format_ref(name) if reflections.key?(name)
 
-            # FIXME: There may be no way to reach this
-            # raise UnknownpropertyType
-            { type: :unknown }
-          end
+              # FIXME: There may be no way to reach this
+              # raise UnknownpropertyType
+              { type: :unknown }
+            end
 
-          def property_overrides(property)
-            return {} unless _properties_overrides.key?(property)
+            def property_overrides(property)
+              return {} unless _properties_overrides.key?(property)
 
-            _properties_overrides[property].deep_symbolize_keys
-          end
+              _properties_overrides[property].deep_symbolize_keys
+            end
 
-          def property_validations(property) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-            constraint_hash = {}
+            def property_validations(property) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+              constraint_hash = {}
 
-            # https://swagger.io/specification/
+              # https://swagger.io/specification/
 
-            validators_on(property).each do |v|
-              if v.is_a? ActiveModel::Validations::NumericalityValidator
-                if v.options.key?(:greater_than)
-                  constraint_hash[:minimum] = v.options[:greater_than]
-                  constraint_hash[:exclusiveMinimum] = true
-                end
+              validators_on(property).each do |v|
+                if v.is_a? ActiveModel::Validations::NumericalityValidator
+                  if v.options.key?(:greater_than)
+                    constraint_hash[:minimum] = v.options[:greater_than]
+                    constraint_hash[:exclusiveMinimum] = true
+                  end
 
-                if v.options.key?(:less_than)
-                  constraint_hash[:maximum] = v.options[:less_than]
-                  constraint_hash[:exclusiveMaximum] = true
-                end
+                  if v.options.key?(:less_than)
+                    constraint_hash[:maximum] = v.options[:less_than]
+                    constraint_hash[:exclusiveMaximum] = true
+                  end
 
-                constraint_hash[:minimum] = v.options[:greater_than_or_equal_to] if v.options.key?(:greater_than_or_equal_to)
-                constraint_hash[:maximum] = v.options[:less_than_or_equal_to] if v.options.key?(:less_than_or_equal_to)
+                  constraint_hash[:minimum] = v.options[:greater_than_or_equal_to] if v.options.key?(:greater_than_or_equal_to)
+                  constraint_hash[:maximum] = v.options[:less_than_or_equal_to] if v.options.key?(:less_than_or_equal_to)
 
-                if v.options.key?(:in)
-                  constraint_hash[:minimum] = v.options[:in].min
-                  constraint_hash[:maximum] = v.options[:in].max
+                  if v.options.key?(:in)
+                    constraint_hash[:minimum] = v.options[:in].min
+                    constraint_hash[:maximum] = v.options[:in].max
+                  end
                 end
-              end
-
-              if v.is_a? ::ActiveRecord::Validations::LengthValidator
-                constraint_hash[:minLength] = v.options[:minimum] || v.options[:is]
-                constraint_hash[:maxLength] = v.options[:maximum] || v.options[:is]
-              end
 
-              constraint_hash[:pattern] = JsRegex.new(v.options[:with]).source if v.is_a? ::ActiveModel::Validations::FormatValidator
+                if v.is_a? ::ActiveRecord::Validations::LengthValidator
+                  constraint_hash[:minLength] = v.options[:minimum] || v.options[:is]
+                  constraint_hash[:maxLength] = v.options[:maximum] || v.options[:is]
+                end
 
-              constraint_hash[:enum] = v.options[:in] if v.is_a? ActiveModel::Validations::InclusionValidator
-            end
+                constraint_hash[:pattern] = JsRegex.new(v.options[:with]).source if v.is_a? ::ActiveModel::Validations::FormatValidator
 
-            constraint_hash[:enum] = defined_enums[property].keys if defined_enums.key?(property)
+                constraint_hash[:enum] = v.options[:in] if v.is_a? ActiveModel::Validations::InclusionValidator
+              end
 
-            constraint_hash.compact
-          end
+              constraint_hash[:enum] = defined_enums[property].keys if defined_enums.key?(property)
 
-          # If there is a presence validator in the model it is not nullable.
-          # if there is no optional: true on an association, rails will add a
-          # presence validator automatically
-          # Otherwise check the db for the actual column or foreign key setting
-          # Return nil instead of false for compaction
-          def property_nullable?(name) # rubocop:todo Metrics/AbcSize
-            # Check for any presence validator
-            return false if validators_on(name).any?(::ActiveRecord::Validations::PresenceValidator)
-
-            # https://guides.rubyonrails.org/active_record_validations.html#numericality
-            # By default, numericality doesn't allow nil values. You can use allow_nil: true option to permit it.
-            validators_on(name).select { |v| v.is_a? ::ActiveRecord::Validations::NumericalityValidator }.each do |v|
-              return false unless v.options[:allow_nil]
+              constraint_hash.compact
             end
 
-            name = reflections[name].foreign_key if reflections.key?(name)
+            # If there is a presence validator in the model it is not nullable.
+            # if there is no optional: true on an association, rails will add a
+            # presence validator automatically
+            # Otherwise check the db for the actual column or foreign key setting
+            # Return nil instead of false for compaction
+            def property_nullable?(name) # rubocop:todo Metrics/AbcSize
+              # Check for any presence validator
+              return false if validators_on(name).any?(::ActiveRecord::Validations::PresenceValidator)
+
+              # https://guides.rubyonrails.org/active_record_validations.html#numericality
+              # By default, numericality doesn't allow nil values. You can use allow_nil: true option to permit it.
+              validators_on(name).select { |v| v.is_a? ::ActiveRecord::Validations::NumericalityValidator }.each do |v|
+                return false unless v.options[:allow_nil]
+              end
 
-            # Check the column null setting
-            return columns_hash[name].null if columns_hash.key?(name)
+              name = reflections[name].foreign_key if reflections.key?(name)
 
-            true
-          end
+              # Check the column null setting
+              return columns_hash[name].null if columns_hash.key?(name)
 
-          # Return nil instead of false for compaction
-          def property_read_only?(name)
-            return unless read_properties.include?(name) && (create_properties.exclude?(name) && update_properties.exclude?(name))
+              true
+            end
 
-            true
-          end
+            # Return nil instead of false for compaction
+            def property_read_only?(name)
+              return unless read_properties.include?(name) && (create_properties.exclude?(name) && update_properties.exclude?(name))
 
-          # Return nil instead of false for compaction
-          def property_write_only?(name)
-            return unless (create_properties.include?(name) || update_properties.include?(name)) && read_properties.exclude?(name)
+              true
+            end
 
-            true
-          end
+            # Return nil instead of false for compaction
+            def property_write_only?(name)
+              return unless (create_properties.include?(name) || update_properties.include?(name)) && read_properties.exclude?(name)
 
-          def property_default(name)
-            # FIXME: This will not handle datetime fields
-            # https://github.com/rails/rails/issues/27077 sets the default in the db
-            # but Blog.new does not set the default value like other attributes
-            # https://nubinary.atlassian.net/browse/NUB-298
-            _default_attributes[name].type_cast(_default_attributes[name].value_before_type_cast)
-          end
+              true
+            end
+
+            def property_default(name)
+              # FIXME: This will not handle datetime fields
+              # https://github.com/rails/rails/issues/27077 sets the default in the db
+              # but Blog.new does not set the default value like other attributes
+              # https://nubinary.atlassian.net/browse/NUB-298
+              _default_attributes[name].type_cast(_default_attributes[name].value_before_type_cast)
+            end
         end
       end
     end

data/lib/rhino/version.rb

@@ -10,7 +10,7 @@ module Rhino
     MAJOR = 0
     MINOR = 21
     TINY  = 0
-    PRE   = "beta.10"
+    PRE   = "beta.13"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rhino_project_core
 version: !ruby/object:Gem::Version
-  version: 0.21.0.beta.10
+  version: 0.21.0.beta.13
 platform: ruby
 authors:
 - JP Rosevear
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-08-22 00:00:00.000000000 Z
+date: 2024-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails