linked_rails 0.0.3 → 0.0.4.pre.g0ec6e30ca

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,29 +32,31 @@ 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
 
       def attr_column(name)
-        column_model =
-          if model_class.is_delegated_attribute?(name)
-            model_class.class_for_delegated_attribute(name)
-          else
-            model_class
-          end
-        column_model.column_for_attribute(name)
+        model_class.column_for_attribute(name)
       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 +68,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 +157,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 +182,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 +220,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 +236,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

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

@@ -6,13 +6,13 @@ module LinkedRails
       attr_accessor :groups, :label, :description
       attr_writer :key
 
-      def initialize(attrs = {})
-        super(attrs)
+      def initialize(**attrs)
+        super(**attrs)
         self.groups = []
       end
 
-      def add_group(opts)
-        group = Form::Group.new(opts)
+      def add_group(**opts)
+        group = Form::Group.new(**opts)
         groups << group
         group
       end
@@ -21,6 +21,10 @@ module LinkedRails
         @footer_group ||= add_group(collapsible: false, footer: true, key: :footer)
       end
 
+      def footer_group!
+        @footer_group
+      end
+
       class << self
         def iri
           Vocab.form[:Page]

data/app/models/linked_rails/form.rb

@@ -5,10 +5,11 @@ require 'pundit'
 module LinkedRails
   class Form # rubocop:disable Metrics/ClassLength
     include LinkedRails::Model
+    include LinkedRails::Model::Cacheable
 
-    class_attribute :pages, :model_class
+    class_attribute :abstract_form, :pages, :model_class
 
-    def root_relative_iri(_opts = {})
+    def root_relative_iri(**_opts)
       self.class.form_iri_path
     end
 
@@ -63,10 +64,6 @@ module LinkedRails
         @serializer_reflections ||= serializer_class&.relationships_to_serialize || {}
       end
 
-      def preview_includes
-        [pages: {groups: [fields: [:fail, :pass, shape: [:property, nested_shapes: :property]]]}]
-      end
-
       private
 
       def current_group
@@ -85,7 +82,7 @@ module LinkedRails
         @default_page ||= page(:default)
       end
 
-      def field(key, opts = {})
+      def field(key, **opts)
         current_group.fields << Form::FieldFactory.new(
           field_options: opts,
           form: self,
@@ -94,9 +91,10 @@ module LinkedRails
       end
 
       def find_form_class(params)
-        requested_class = [params[:module], "#{params[:id]&.singularize}_forms"].compact.join('/').classify
+        form_name = [params[:module], "#{params[:id]&.singularize}_forms"].compact.join('/').classify
+        requested_class = form_name.safe_constantize
 
-        LinkedRails::Form.descendants.detect { |klass| klass.to_s == requested_class }
+        requested_class if requested_class && requested_class < LinkedRails::Form
       end
 
       def footer
@@ -108,10 +106,10 @@ module LinkedRails
         current_page.footer_group
       end
 
-      def group(key, opts = {})
+      def group(key, **opts)
         opts[:collapsible] = true unless opts.key?(:collapsible)
         opts[:key] = key
-        group = current_page.add_group(opts)
+        group = current_page.add_group(**opts)
         @current_group = group
 
         yield if block_given?
@@ -120,26 +118,24 @@ module LinkedRails
         group
       end
 
-      # rubocop:disable Naming/PredicateName
-      def has_many(key, opts = {})
+      def has_many(key, **opts)
         opts[:input_field] = Form::Field::AssociationInput
         opts[:max_count] = 99
-        field(key, opts)
+        field(key, **opts)
       end
 
-      def has_one(key, opts = {})
+      def has_one(key, **opts)
         opts[:input_field] = Form::Field::AssociationInput
         opts[:max_count] = 1
-        field(key, opts)
+        field(key, **opts)
       end
-      # rubocop:enable Naming/PredicateName
 
       def hidden(&block)
         group(:hidden, collapsible: false, hidden: true, &block)
       end
 
-      def page(key, opts = {})
-        page = Form::Page.new(opts.merge(key: key))
+      def page(key, **opts)
+        page = Form::Page.new(**opts.merge(key: key))
         @current_page = page
         pages << @current_page
         yield if block_given?
@@ -147,9 +143,9 @@ module LinkedRails
         page
       end
 
-      def resource(key, opts = {})
+      def resource(key, **opts)
         opts[:input_field] = Form::Field::ResourceField
-        field(key, opts)
+        field(key, **opts)
       end
     end
   end

data/app/models/linked_rails/manifest.rb

@@ -5,6 +5,27 @@ module LinkedRails
     include ActiveModel::Model
     include LinkedRails::Model
 
+    def save
+      Storage.hset(
+        :persistent,
+        :manifest,
+        URL.as_href(LinkedRails.iri) => web_manifest.to_json
+      )
+    end
+
+    def web_manifest
+      web_manifest_base.merge(
+        ontola: web_manifest_ontola_section,
+        serviceworker: web_manifest_sw_section
+      )
+    end
+
+    private
+
+    def allowed_external_sources
+      []
+    end
+
     def app_name
       Rails.application.railtie_name.chomp('_application').humanize
     end
@@ -17,8 +38,27 @@ module LinkedRails
       '#eef0f2'
     end
 
+    def blob_preview_iri
+      return unless ActiveStorage::Blob.service.present?
+
+      "#{LinkedRails.iri(path: 'rails/active_storage/blobs/redirect')}/{signed_id}/preview"
+    end
+
+    def blob_upload_iri
+      return unless ActiveStorage::Blob.service.present?
+
+      LinkedRails.iri(path: 'rails/active_storage/direct_uploads')
+    end
+
     def css_class; end
 
+    def csp_entries
+      {
+        connectSrc: [ActiveStorage::Blob.service.try(:bucket)&.url].compact,
+        scriptSrc: [ActiveStorage::Blob.service.try(:bucket)&.url].compact
+      }
+    end
+
     def header_background
       :primary
     end
@@ -27,17 +67,16 @@ module LinkedRails
       :white
     end
 
-    def preload_iris
-      [
-        scope,
-        LinkedRails.iri(path: 'ns/core').to_s,
-        LinkedRails.iri(path: 'c_a').to_s,
-        LinkedRails.iri(path: 'menus').to_s
-      ]
+    def icons
+      []
+    end
+
+    def lang
+      :nl
     end
 
     def scope
-      @scope ||= LinkedRails.iri.to_s
+      LinkedRails.iri.to_s
     end
 
     def site_theme_color
@@ -52,51 +91,92 @@ module LinkedRails
       app_name
     end
 
+    def start_url
+      scope == '/' ? scope : "#{scope}/"
+    end
+
     def theme; end
 
     def theme_options
       {}
     end
 
-    def web_manifest
-      web_manifest_base.merge(
-        ontola: web_manifest_ontola_section,
-        serviceworker: web_manifest_sw_section
-      )
-    end
-
     def web_manifest_base # rubocop:disable Metrics/MethodLength
       {
         background_color: background_color,
         dir: :rtl,
         display: :standalone,
-        lang: :nl,
+        icons: icons,
+        lang: lang,
         name: app_name,
         scope: scope,
         short_name: app_name,
-        start_url: scope,
+        start_url: start_url,
         theme_color: site_theme_color
       }
     end
 
-    def web_manifest_ontola_section
+    def web_manifest_ontola_section # rubocop:disable Metrics/MethodLength
       {
-        css_class: css_class,
+        allowed_external_sources: allowed_external_sources,
+        blob_preview_iri:  blob_preview_iri,
+        blob_upload_iri: blob_upload_iri,
+        csp: csp_entries,
         header_background: header_background,
         header_text: header_text,
-        preload: preload_iris,
+        preconnect: preconnect,
         primary_color: site_theme_color,
         secondary_color: site_secondary_color,
+        styled_headers: styled_headers,
         theme: theme,
-        theme_options: theme_options.to_query
+        theme_options: theme_options.to_query,
+        tracking: tracking,
+        website_iri: LinkedRails.iri.to_s,
+        websocket_path: websocket_path
       }
     end
 
     def web_manifest_sw_section
       {
-        src: "#{scope}/sw.js?manifestLocation=#{Rack::Utils.escape("#{scope}/manifest.json")}",
+        src: "#{scope.chomp('/')}/sw.js",
         scope: scope
       }
     end
+
+    def websocket_path
+      Rails.application.config.try(:action_cable).try(:mount_path).try(:[], 1..-1)
+    end
+
+    def preconnect
+      []
+    end
+
+    def styled_headers
+      false
+    end
+
+    def tracking
+      []
+    end
+
+    class << self
+      def destroy(iri)
+        Storage.hdel(:persistent, :manifest, URL.as_href(iri))
+      end
+
+      def move(from, to)
+        Storage.hset(
+          :persistent,
+          :redirect_prefix,
+          URL.as_href(from) => URL.as_href(to)
+        )
+
+        data = Storage.hget(:persistent, :manifest, URL.as_href(from))
+
+        Storage.hset(:persistent, :manifest, URL.as_href(to), data) if data
+
+        destroy(from)
+      end
+    end
   end
 end

data/app/models/linked_rails/menus/item.rb

@@ -12,7 +12,7 @@ module LinkedRails
       delegate :iri_opts, to: :parent
 
       alias id iri
-      %i[action href image label menus iri_base].each do |method|
+      %i[action href image label iri_base].each do |method|
         callable_variable(method, instance: :parent)
       end
 
@@ -26,7 +26,7 @@ module LinkedRails
       def iri_template
         return parent.send(:iri_template) unless parent.is_a?(LinkedRails::Menus::List)
 
-        return URITemplate.new("#{iri_base}{/tag}{#fragment}") if iri_base
+        return LinkedRails::URITemplate.new("#{iri_base}{/tag}{#fragment}") if iri_base
 
         iri_template_expand_path(parent.send(:iri_template), '{/tag}')
       end
@@ -36,7 +36,7 @@ module LinkedRails
 
         @menu_sequence ||=
           LinkedRails::Sequence.new(
-            -> { menus&.compact&.each { |menu| menu.parent = self } },
+            -> { menus },
             id: menu_sequence_iri,
             parent: self,
             scope: false
@@ -52,6 +52,12 @@ module LinkedRails
         sequence_iri
       end
 
+      def menus
+        return @menus unless @menus.respond_to?(:call)
+
+        @menus = parent.instance_exec(&@menus).compact.each { |menu| menu.parent = self }
+      end
+
       def rdf_type
         type || Vocab.ontola[:MenuItem]
       end
@@ -67,24 +73,15 @@ module LinkedRails
       end
 
       class << self
-        def base_includes
-          [action: :target]
-        end
-
         def preview_includes
-          base_includes + [
-            menu_sequence: [
-              members: base_includes +
-                [menu_sequence: [members: base_includes]]
-            ]
-          ]
+          [menu_sequence: [members: [menu_sequence: :members]]]
         end
 
         def requested_index_resource(params, user_context)
           parent = parent_from_params(params, user_context)
           return if parent.blank?
 
-          parent.menu_sequence
+          parent.try(:menu_sequence)
         end
       end
     end

data/app/models/linked_rails/menus/list.rb

@@ -20,21 +20,28 @@ module LinkedRails
       end
 
       def iri_opts
-        resource&.iri_opts || {}
+        return {} if resource.blank?
+
+        resource.try(:singular_resource?) ? resource.singular_iri_opts : resource.iri_opts
       end
 
       def menus
-        @menus ||= available_menus.map(&method(:menu_item))
+        @menus ||= available_menus.map(&method(:memoized_menu_item))
       end
 
       def menu(tag)
-        menu_item(tag, available_menus[tag].dup) if available_menus.key?(tag)
+        memoized_menu_item(tag, available_menus[tag].dup) if available_menus.key?(tag)
       end
 
       private
 
       def default_label(tag, options)
-        I18n.t("menus.#{resource&.class&.name&.tableize}.#{tag}", options[:label_params])
+        I18n.t("menus.#{resource&.class&.name&.tableize}.#{tag}", **options[:label_params])
+      end
+
+      def memoized_menu_item(tag, options)
+        @memoized_menu_item ||= {}
+        @memoized_menu_item[tag] ||= menu_item(tag, options)
       end
 
       def menu_available?(_tag, options)
@@ -42,16 +49,20 @@ module LinkedRails
       end
 
       def menu_item(tag, options) # rubocop:disable Metrics/AbcSize
-        if options[:policy].present?
-          return unless resource_policy(options[:policy_resource]).send(options[:policy], *options[:policy_arguments])
-        end
+        return unless show_menu_item?(tag, options)
+
         options[:label_params] ||= {}
         options[:label_params][:default] ||= ["menus.default.#{tag}".to_sym, tag.to_s.capitalize]
         options[:label] ||= default_label(tag, options)
+        options[:action] = ontola_dialog_action(options[:href]) if options.delete(:dialog)
         options.except!(:policy_resource, :policy, :policy_arguments, :label_params)
         LinkedRails.menus_item_class.new(resource: resource, tag: tag, parent: self, **options)
       end
 
+      def policy_verdict(policy, options)
+        policy.send(options[:policy], *options[:policy_arguments])
+      end
+
       def resource_policy(policy_resource)
         policy_resource ||= resource
         policy_resource = instance_exec(&policy_resource) if policy_resource.respond_to?(:call)
@@ -61,8 +72,18 @@ module LinkedRails
         @resource_policy[policy_resource] ||= Pundit.policy(user_context, policy_resource)
       end
 
+      def show_menu_item?(_tag, options)
+        return true if options[:policy].blank?
+
+        policy = resource_policy(options[:policy_resource])
+
+        policy_verdict(policy, options)
+      end
+
       def iri_template
-        @iri_template ||= iri_template_expand_path(resource.send(:iri_template), '/menus')
+        base_template = resource.send(resource.try(:singular_resource?) ? :singular_iri_template : :iri_template)
+
+        @iri_template ||= iri_template_expand_path(base_template, '/menus')
       end
 
       class << self
@@ -88,7 +109,7 @@ module LinkedRails
           _defined_menus || {}
         end
 
-        def has_menu(tag, opts = {}) # rubocop:disable Naming/PredicateName
+        def has_menu(tag, **opts)
           defined_menus[tag] = opts
         end
 
@@ -100,7 +121,6 @@ module LinkedRails
           LinkedRails::Sequence.new(
             menu_list.menus,
             id: menu_list.iri,
-            member_includes: Item.preview_includes,
             scope: false
           )
         end

data/app/models/linked_rails/ontology/base.rb

@@ -9,7 +9,7 @@ module LinkedRails
 
       def data
         data = []
-        iri.each_statement do |statement|
+        iri.try(:each_statement) do |statement|
           next unless include_data_statement?(statement)
 
           statement.graph_name = ::RDF::Serializers.config.default_graph
@@ -41,6 +41,8 @@ module LinkedRails
       end
 
       def include_data_statement?(statement)
+        return false if statement.subject.node? || statement.object.node?
+
         statement.predicate != Vocab.rdfs.label &&
           statement.predicate != Vocab.rdfs.range &&
           statement.predicate != Vocab.rdfs.domain