linked_rails 0.0.1 → 0.0.4.pre.g2c53724b3

data/app/models/linked_rails/collection.rb

@@ -2,6 +2,7 @@
 
 require 'pundit'
 
+require_relative 'collection/configuration'
 require_relative 'collection/filter'
 require_relative 'collection/filterable'
 require_relative 'collection/iri'
@@ -9,28 +10,38 @@ require_relative 'collection/iri_mapping'
 require_relative 'collection/sortable'
 require_relative 'collection/sorting'
 require_relative 'collection/view'
+require_relative 'collection/paginated'
 require_relative 'collection/paginated_view'
+require_relative 'collection/infinite'
 require_relative 'collection/infinite_view'
 
 module LinkedRails
   class Collection # rubocop:disable Metrics/ClassLength
     include ActiveModel::Model
-    include LinkedRails::Model::Enhancements
-    include LinkedRails::Model::Iri
+    include LinkedRails::Model::Actionable
+    include LinkedRails::Model::IRI
+    include LinkedRails::Collection::Configuration
     include LinkedRails::Collection::Filterable
-    include LinkedRails::Collection::Iri
-    include LinkedRails::Collection::IriMapping
+    include LinkedRails::Collection::IRI
+    include LinkedRails::Collection::IRIMapping
     include LinkedRails::Collection::Sortable
 
-    enhance LinkedRails::Enhancements::Actionable
-
-    attr_accessor :association, :association_class, :association_scope, :grid_max_columns, :joins,
-                  :name, :page_size, :parent, :part_of, :policy, :user_context, :view
-    attr_writer :association_base, :table_type, :default_display, :default_title, :default_type,
-                :display, :policy_scope, :title, :type, :views
+    attr_accessor :name, :policy, :user_context
+    attr_writer :association_base, :views
 
     alias id iri
 
+    def initialize(**opts)
+      opts = opts.with_indifferent_access
+
+      %i[association_class iri_template].each do |key|
+        raise("No #{key} given") if opts[key].blank?
+      end
+      opts[:route_key] ||= opts[:association_class].collection_route_key
+
+      super
+    end
+
     def action_list(user_context)
       @action_list ||= {}
       @action_list[user_context] ||= association_class.try(:action_list)&.new(
@@ -56,21 +67,8 @@ module LinkedRails
       super(options.merge(except: %w[association_class unfiltered_collection collection]))
     end
 
-    def association_base
-      @association_base ||= apply_scope(sorted_association(filtered_association))
-    end
-
-    def build_child # rubocop:disable Metrics/AbcSize
-      child =
-        parent&.build_child(association_class, user_context: user_context) ||
-        association_class.build_new(parent: parent, user_context: user_context)
-
-      attributes_from_filters = ActionController::Parameters.new(association_class.attributes_from_filters(@filter))
-      permitted_child_keys = Pundit.policy(user_context, child)&.permitted_attributes || []
-      permitted_attributes_from_filters = attributes_from_filters.permit(permitted_child_keys)
-
-      child.assign_attributes(permitted_attributes_from_filters)
-      child
+    def child_resource
+      @child_resource ||= build_child
     end
 
     def columns
@@ -79,18 +77,10 @@ module LinkedRails
       RDF::List[*columns_list] if columns_list.present?
     end
 
-    def default_page_size
-      association_class.try(:default_per_page) || 20
-    end
-
     def default_view
       @default_view ||= view_with_opts(default_view_opts)
     end
 
-    def display
-      @display&.to_sym || default_display
-    end
-
     def first
       case type
       when :paginated
@@ -110,32 +100,7 @@ module LinkedRails
 
     def new_child(options)
       attrs = options.merge(new_child_values)
-      self.class.new(attrs)
-    end
-
-    def preview_includes
-      {
-        default_view: default_view.preview_includes,
-        filter_fields: :options,
-        filters: [],
-        sortings: []
-      }
-    end
-
-    def title
-      var = @title || @default_title
-      return var.call(parent) if var.respond_to?(:call)
-
-      var || title_from_translation
-    end
-
-    def title_from_translation
-      plural = association_class.name.tableize
-      I18n.t(
-        "#{plural}.collection.#{@filter&.values&.join('.').presence || name || :default}",
-        count: ->(_opts) { total_count },
-        default: association_class.plural_label
-      )
+      self.class.new(**attrs)
     end
 
     def total_count
@@ -143,11 +108,7 @@ module LinkedRails
     end
 
     def total_page_count
-      (total_count / (page_size || default_page_size).to_f).ceil if total_count
-    end
-
-    def type
-      @type&.to_sym || default_type
+      (total_count / page_size.to_f).ceil if total_count
     end
 
     def unscoped_association
@@ -160,21 +121,25 @@ module LinkedRails
 
     def view_with_opts(opts)
       @views ||= []
-      view = LinkedRails.collection_view_class.new({collection: self, type: type}.merge(opts))
+      view = collection_view_class.new(**{collection: self, type: type}.merge(opts))
       @views << view
       view
     end
 
     private
 
-    def default_display
-      @default_display = @default_display.call(parent) if @default_display.respond_to?(:call)
+    def build_child
+      child =
+        parent&.build_child(association_class, user_context: user_context) ||
+        association_class.build_new(parent: parent, user_context: user_context)
 
-      @default_display || association_class.try(:default_collection_display)
+      child.assign_attributes(association_base.where_values_hash) if association_base.respond_to?(:where_values_hash)
+      child.assign_attributes(permitted_attributes_from_filters(child))
+      child
     end
 
-    def default_type
-      @default_type || association_class.try(:default_collection_type) || :paginated
+    def collection_view_class
+      LinkedRails.collection_view_class
     end
 
     def default_view_opts
@@ -187,30 +152,33 @@ module LinkedRails
       opts
     end
 
-    def policy_scope
-      return @policy_scope if @policy_scope == false
-
-      @policy_scope = policy ? policy::Scope : Pundit::PolicyFinder.new(filtered_association).scope!
-    end
-
     def paginated?
       type == :paginated
     end
 
-    def table_type
-      return @table_type if @table_type
+    def permitted_attributes_from_filters(child)
+      return {} if @filter.empty?
 
-      case display&.to_sym
-      when :table
-        :default
-      when :settingsTable
-        :settings
-      end
+      Pundit.policy(user_context, child).try(:permitted_attributes_from_filters, @filter) || {}
+    end
+
+    def title_from_translation
+      plural = association_class.name.tableize
+
+      I18n.t(
+        "#{plural}.collection.#{filter&.values&.join('.').presence || name || :default}",
+        count: ->(_opts) { total_count },
+        default: association_class.plural_label
+      )
     end
 
     def new_child_values
       instance_values
-        .slice('association', 'association_class', 'association_scope', 'iri_template', 'parent')
+        .slice(
+          'iri_template',
+          *LinkedRails::Model::Collections::COLLECTION_STATIC_OPTIONS.keys.map(&:to_s),
+          *LinkedRails::Model::Collections::COLLECTION_CUSTOMIZABLE_OPTIONS.keys.map { |key| "default_#{key}" }
+        )
         .merge(
           unfiltered_collection: filtered? ? @unfiltered_collection : self,
           user_context: user_context

data/app/models/linked_rails/creative_work.rb

@@ -8,7 +8,7 @@ module LinkedRails
     attr_writer :iri
     attr_accessor :description, :name, :text, :url
 
-    def iri(_opts = {})
+    def iri(**_opts)
       @iri ||= RDF::Node.new
     end
 

data/app/models/linked_rails/entry_point.rb

@@ -6,7 +6,7 @@ module LinkedRails
     include LinkedRails::Model
 
     attr_accessor :parent
-    attr_writer :url
+    attr_writer :target_url
     delegate :form, :description, :http_method, :image, :user_context,
              :resource, :tag, to: :parent
 
@@ -16,12 +16,15 @@ module LinkedRails
       form&.form_iri
     end
 
-    def as_json(_opts = {})
+    def as_json(**_opts)
       {}
     end
 
     def iri_template
-      @iri_template ||= iri_template_with_fragment(URITemplate.new(parent.root_relative_iri.to_s), :EntryPoint)
+      @iri_template ||= iri_template_with_fragment(
+        LinkedRails::URITemplate.new(parent.root_relative_iri.to_s),
+        :EntryPoint
+      )
     end
 
     def label
@@ -30,8 +33,8 @@ module LinkedRails
       value || label_fallback
     end
 
-    def url
-      @url || parent.url
+    def target_url
+      @target_url || parent.target_url
     end
 
     private

data/app/models/linked_rails/enum_value.rb

@@ -5,14 +5,14 @@ module LinkedRails
     include ActiveModel::Model
     include LinkedRails::Model
 
-    attr_accessor :attr, :close_match, :exact_match, :group_by, :key, :klass, :type
+    attr_accessor :attr, :close_match, :exact_match, :group_by, :identifier, :key, :klass, :type
     attr_writer :iri, :label
 
     def label
       label_from_variable || LinkedRails.translate(:enum, :label, self)
     end
 
-    def iri(_opts = {})
+    def iri(**_opts)
       @iri || iri_with_root(RDF::URI("/enums/#{klass.name.tableize}/#{attr}##{key}"))
     end
 
@@ -29,5 +29,43 @@ module LinkedRails
     def label_from_variable
       @label.respond_to?(:call) ? @label.call : @label
     end
+
+    class << self
+      def class_for_params(params)
+        LinkedRails.linked_models.detect do |klass|
+          klass.to_s == ([params[:module]].compact + [params[:klass]&.singularize]).join('/').classify
+        end
+      end
+
+      def enum_options(params)
+        serializer_for_params(params)&.enum_options(params[:attribute])
+      end
+
+      def requested_resource(opts, _user_context)
+        options = enum_options(opts[:params])
+
+        return unless options
+
+        LinkedRails::Sequence.new(
+          options.values,
+          id: sanitized_sequence_iri(opts[:iri]),
+          scope: LinkedRails::EnumValuePolicy::Scope
+        )
+      end
+
+      def sanitized_sequence_iri(raw_iri)
+        iri = RDF::URI(raw_iri)
+        iri.query = nil
+        iri.fragment = nil
+        iri.path = iri.path.split('.').first
+        iri
+      end
+
+      def serializer_for_params(params)
+        klass = class_for_params(params)
+
+        RDF::Serializers.serializer_for(klass) if klass
+      end
+    end
   end
 end

data/app/models/linked_rails/form/field/association_input.rb

@@ -9,7 +9,13 @@ module LinkedRails
         def datatype; end
 
         def nested_form
-          @nested_form ||= klass_name.constantize.form_class
+          @nested_form ||= target_class.form_class
+        end
+
+        def target_class
+          return @target_class if @target_class
+
+          klass_name.constantize unless form.abstract_form
         end
 
         private

data/app/models/linked_rails/form/field/file_input.rb

@@ -4,6 +4,7 @@ module LinkedRails
   class Form
     class Field
       class FileInput < Field
+        attr_accessor :max_size
       end
     end
   end

data/app/models/linked_rails/form/field/resource_field.rb

@@ -10,6 +10,8 @@ module LinkedRails
 
         attr_reader :path
 
+        def label_from_property; end
+
         def permission_required?
           false
         end

data/{lib/linked_rails/enhancements/indexable/model.rb → app/models/linked_rails/form/field/url_input.rb}

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 module LinkedRails
-  module Enhancements
-    module Indexable
-      module Model
+  class Form
+    class Field
+      class UrlInput < Field
       end
     end
   end

data/app/models/linked_rails/form/field.rb

@@ -2,25 +2,27 @@
 
 module LinkedRails
   class Form
-    class Field < LinkedRails::Resource
-      attr_writer :datatype,
-                  :description,
+    class Field < LinkedRails::Resource # rubocop:disable Metrics/ClassLength
+      attr_writer :description,
                   :helper_text,
                   :label,
+                  :max_inclusive,
                   :max_length,
                   :min_count,
+                  :min_inclusive,
                   :min_length,
-                  :sh_in,
                   :pattern,
-                  :path
-      attr_accessor :default_value,
+                  :path,
+                  :placeholder,
+                  :sh_in,
+                  :start_adornment
+      attr_accessor :datatype,
+                    :default_value,
                     :max_count,
                     :max_count_prop,
-                    :max_inclusive,
                     :max_inclusive_prop,
                     :max_length_prop,
                     :min_count_prop,
-                    :min_inclusive,
                     :min_inclusive_prop,
                     :min_length_prop,
                     :model_attribute,
@@ -31,9 +33,6 @@ module LinkedRails
                     :validators,
                     :sh_in_prop,
                     :key
-      def datatype
-        @datatype || raise("No datatype found for #{key} in #{form.name}")
-      end
 
       def description
         description_from_attribute || description_fallback
@@ -43,6 +42,10 @@ module LinkedRails
         helper_text_from_attribute || helper_text_fallback
       end
 
+      def max_inclusive
+        @max_inclusive || validators[:max_inclusive]
+      end
+
       def max_length
         @max_length || validators[:max_length]
       end
@@ -51,6 +54,10 @@ module LinkedRails
         @min_count || (validators[:presence] ? 1 : nil)
       end
 
+      def min_inclusive
+        @min_inclusive || validators[:min_inclusive]
+      end
+
       def min_length
         @min_length || validators[:min_length]
       end
@@ -72,12 +79,20 @@ module LinkedRails
         true
       end
 
+      def placeholder
+        placeholder_from_attribute || placeholder_fallback
+      end
+
       def sh_in
         return validators[:sh_in] if @sh_in.blank?
 
         @sh_in.respond_to?(:call) ? @sh_in.call : @sh_in
       end
 
+      def start_adornment
+        @start_adornment.respond_to?(:call) ? @start_adornment.call : @start_adornment
+      end
+
       private
 
       def description_from_attribute
@@ -101,12 +116,21 @@ module LinkedRails
       end
 
       def label_fallback
-        field_label = LinkedRails.translate(:field, :label, self, false)
-        return field_label if field_label.present?
+        LinkedRails.translate(:field, :label, self, false).presence || label_from_property
+      end
 
+      def label_from_property
         LinkedRails.translate(:property, :label, path) if path
       end
 
+      def placeholder_from_attribute
+        @placeholder.respond_to?(:call) ? @placeholder.call : @placeholder
+      end
+
+      def placeholder_fallback
+        LinkedRails.translate(:field, :placeholder, self, false)
+      end
+
       class << self
         def iri
           Vocab.form[name.demodulize]

data/app/models/linked_rails/form/field_factory.rb

@@ -3,10 +3,17 @@
 module LinkedRails
   class Form
     class FieldFactory # rubocop:disable Metrics/ClassLength
+      DATABASE_ERRORS = [
+        'PG::ConnectionBad'.safe_constantize,
+        ActiveRecord::StatementInvalid,
+        ActiveRecord::ConnectionNotEstablished
+      ].compact.freeze
       MAX_STR_LEN = 255
       VALIDATOR_SELECTORS = [
         [:min_length, ActiveModel::Validations::LengthValidator, :minimum],
+        [:min_inclusive, ActiveModel::Validations::NumericalityValidator, :greater_than_or_equal_to],
         [:max_length, ActiveModel::Validations::LengthValidator, :maximum],
+        [:max_inclusive, ActiveModel::Validations::NumericalityValidator, :less_than_or_equal_to],
         [:pattern, ActiveModel::Validations::FormatValidator, :with],
         [:presence, ActiveModel::Validations::PresenceValidator, nil],
         [:sh_in, ActiveModel::Validations::InclusionValidator, :in]
@@ -15,7 +22,8 @@ module LinkedRails
 
       attr_accessor :field_options, :form, :key
 
-      delegate :form_options_iri,
+      delegate :abstract_form,
+               :form_options_iri,
                :model_class,
                :model_policy!,
                :serializer_attributes,
@@ -24,12 +32,21 @@ module LinkedRails
                to: :form
 
       def condition_or_field
-        @condition_or_field ||= model_policy!.condition_for(
+        return @condition_or_field if instance_variable_defined?(:@condition_or_field)
+
+        alternatives = node_shapes_for(
           key,
-          field,
           property: field_options[:if] || [],
           sh_not: field_options[:unless] || []
         )
+        @condition_or_field =
+          if alternatives.count == 1
+            Condition.new(shape: alternatives.first, pass: field)
+          elsif alternatives.count.positive?
+            Condition.new(shape: SHACL::NodeShape.new(or: alternatives), pass: field)
+          else
+            field
+          end
       end
 
       private
@@ -45,8 +62,7 @@ module LinkedRails
       end
 
       def attr_to_datatype # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength
-        name = serializer_attribute&.key&.to_s || key.to_s
-        case attribute_type(name)
+        case attribute_type
         when :string, :text
           Vocab.xsd.string
         when :integer
@@ -58,22 +74,26 @@ module LinkedRails
         when :boolean
           Vocab.xsd.boolean
         when :decimal
-          decimal_data_type(name)
+          decimal_data_type(attribute_name)
         when :file
           Vocab.ll[:blob]
         else
-          Vocab.xsd.string if model_class.try(:defined_enums)&.key?(name)
+          Vocab.xsd.string if model_class.try(:defined_enums)&.key?(attribute_name)
         end
       end
 
-      def attribute_type(name)
-        model_class.try(:attribute_types).try(:[], name)&.type
-      rescue PG::ConnectionBad, ActiveRecord::StatementInvalid, ActiveRecord::ConnectionNotEstablished
+      def attribute_name
+        serializer_attribute&.key&.to_s || key.to_s
+      end
+
+      def attribute_type
+        model_class.try(:attribute_types).try(:[], attribute_name)&.type
+      rescue *DATABASE_ERRORS
         :string
       end
 
       def attribute_validators
-        @attribute_validators ||= model_class.validators.select { |v| v.attributes.include?(model_attribute) }
+        @attribute_validators ||= model_class&.validators&.select { |v| v.attributes.include?(model_attribute) }
       end
 
       def datatype
@@ -143,7 +163,7 @@ module LinkedRails
         when Vocab.ontola['datatype/postalRange']
           return Form::Field::PostalRangeInput
         else
-          max_length && max_length > MAX_STR_LEN ? Form::Field::TextAreaInput : Form::Field::TextInput
+          attribute_type == :text ? Form::Field::TextAreaInput : Form::Field::TextInput
         end
       end
       # rubocop:enable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/MethodLength, Metrics/PerceivedComplexity
@@ -168,6 +188,15 @@ module LinkedRails
         @model_attribute ||= (model_class.try(:attribute_alias, key) || key).to_sym
       end
 
+      def node_shapes_for(attr, property: [], sh_not: [])
+        alternatives = abstract_form ? [] : model_policy!.condition_alternatives(attr, field.permission_required?)
+        alternatives = [[]] if alternatives.empty? && (property.any? || sh_not.any?)
+
+        alternatives.map do |props|
+          SHACL::NodeShape.new(property: props + property, sh_not: sh_not)
+        end
+      end
+
       def normalized_key(key)
         return key.to_s[0...-3].to_sym if key.to_s.ends_with?('_id')
         return key.to_s[0...-4].pluralize.to_sym if key.to_s.ends_with?('_ids')
@@ -197,14 +226,15 @@ module LinkedRails
       def validator(klass, option_key)
         matched_validator = validator_by_class(klass)
 
-        option_key ? matched_validator&.options.try(:[], option_key) : matched_validator.present?
+        value = option_key ? matched_validator&.options.try(:[], option_key) : matched_validator.present?
+
+        value unless value.respond_to?(:call)
       end
 
       def validator_by_class(klass)
-        matched_validator = attribute_validators&.detect { |v| v.is_a?(klass) }
-        return if matched_validator.blank?
-
-        matched_validator if matched_validator.options[:if].blank? && matched_validator.options[:unless].blank?
+        attribute_validators&.detect do |validator|
+          validator.is_a?(klass) && validator.options[:if].blank? && validator.options[:unless].blank?
+        end
       end
 
       def validators
@@ -212,7 +242,7 @@ module LinkedRails
           VALIDATOR_SELECTORS.map do |key, klass, option_key|
             [key, validator(klass, option_key)]
           end
-        ]
+        ].compact
       end
     end
   end

data/app/models/linked_rails/form/group.rb

@@ -6,19 +6,17 @@ module LinkedRails
       attr_accessor :fields, :collapsible, :hidden, :footer
       attr_writer :description, :key, :label
 
-      def initialize(attrs = {})
-        super(attrs)
+      def initialize(**attrs)
+        super(**attrs)
         self.fields = []
       end
 
       def description
-        @description = @description.call if @description.respond_to?(:call)
-        @description
+        @description.respond_to?(:call) ? @description.call : @description
       end
 
       def label
-        @label = @label.call if @label.respond_to?(:call)
-        @label
+        @label.respond_to?(:call) ? @label.call : @label
       end
 
       def rdf_type