linked_rails 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6779d430183378aeebf11d84973275d9f95ba6be8d9d806c4488f9c5e0a7ca11
-  data.tar.gz: e98856daaf5f8698922faeec141b6f24c3e72856076955bd2892b067e37609d2
+  metadata.gz: eefab6e5626896f0baa3510637edc5b59d3e8aaf3e6b9b83f833e5f7f493ab86
+  data.tar.gz: be557fc4729209e7a3f5bc53cce009c6efd3291c0c4a1d0229b10ca12b30e184
 SHA512:
-  metadata.gz: 17934ce95f375a4b36a63b56285f1db4e2171d6d1c5bc2747dc0132548b77c36a484be64aeacb47ec89fe15ba77fd39a9f44ee25096759438aea8882b8ec8dbf
-  data.tar.gz: 30fff5ebacf094fcaada45caab3d15537ba5806692f9dd887f509155420880b07283ec41aa6282e2d572e15fcb7cdce508bd55d102bd790eb1b7be5cc1d353dd
+  metadata.gz: b0ad47f2cf9c64002e625593a678f54e751618420bba68fcb784b61469b7c043fa99eea38a957274d02e1eaae0968a21127752050308cadffda261b5a7bc8bf4
+  data.tar.gz: 0c7c4ad8099fd399370ac1c42673a65be720093df2e8f205d5cbc7a5383967d09f5fadd5ec87bf8d183984400b59208def613b161f65543ff9eabd938039d4f0

data/app/controllers/linked_rails/bulk_controller.rb

@@ -30,12 +30,12 @@ module LinkedRails
       @authorized_resources ||=
         params
           .require(:resources)
-          .map { |param| param.permit(:include, :iri) }
+          .map { |param| resource_params(param) }
           .map(&method(:timed_authorized_resource))
     end
 
     def handle_resource_error(opts, error)
-      log_resource_error(error)
+      log_resource_error(error, opts[:iri])
       status = error_status(error)
       body = error_body(status, error, opts[:iri]) if opts[:include].to_s == 'true'
 
@@ -50,7 +50,7 @@ module LinkedRails
       resource_body(error_resource(status, error, iri))
     end
 
-    def log_resource_error(error)
+    def log_resource_error(error, _iri)
       return unless log_resource_error?(error)
 
       Rails.logger.error(error)
@@ -83,6 +83,12 @@ module LinkedRails
       RDF::Serializers.serializer_for(resource).new(resource, serializer_options).send(:render_hndjson)
     end
 
+    def resource_params(param)
+      params = param.permit(:include, :iri)
+      params[:iri] = URI(params[:iri])
+      params
+    end
+
     def resource_response_body(iri, rack_body, status)
       return rack_body.body if rack_body.is_a?(ActionDispatch::Response::RackBody)
 
@@ -134,16 +140,30 @@ module LinkedRails
 
     def term_from_vocab(iri)
       vocab = Vocab.for(iri)
-      tag = iri.split(vocab.to_s).last
+      tag = iri.to_s.split(vocab.to_s).last
       vocab[tag]
     rescue NoMethodError
       nil
     end
 
+    def ontology_class(iri)
+      klass = LinkedRails.linked_models.detect do |model|
+        (model.iri.is_a?(Array) ? model.iri : [model.iri]).include?(iri)
+      end
+      LinkedRails.ontology_class_class.new(iri: iri, klass: klass)
+    end
+
+    def ontology_property(iri)
+      LinkedRails.ontology_property_class.new(iri: iri)
+    end
+
     def ontology_term_response(iri, term, include)
+      capital = term.relativize(term.vocab).to_s[0] =~ /[A-Z]/
+      resource = capital ? ontology_class(term) : ontology_property(term)
+
       resource_response(
         iri,
-        body: include ? resource_body(LinkedRails.ontology_property_class.new(iri: term)) : nil,
+        body: include ? resource_body(resource) : nil,
         cache: :public,
         language: I18n.locale,
         status: 200
@@ -189,7 +209,7 @@ module LinkedRails
     end
 
     def wrong_host?(iri)
-      !iri.starts_with?(LinkedRails.iri)
+      !iri.to_s.starts_with?(LinkedRails.iri)
     end
   end
 end

data/app/controllers/linked_rails/enum_values_controller.rb

@@ -3,47 +3,5 @@
 module LinkedRails
   class EnumValuesController < LinkedRails.controller_parent_class
     active_response :index
-
-    private
-
-    def enum_options!
-      serializer_class!.enum_options(params[:attribute]) || raise(ActiveRecord::RecordNotFound)
-    end
-
-    def requested_resource
-      return super unless action_name == 'index'
-
-      @requested_resource ||= LinkedRails::Sequence.new(
-        enum_options!.values,
-        id: index_iri,
-        scope: LinkedRails::EnumValuePolicy::Scope
-      )
-    end
-
-    def model_class
-      @model_class ||= self.class.linked_models.detect do |klass|
-        klass.to_s == ([params[:module]].compact + [params[:klass]&.singularize]).join('/').classify
-      end
-    end
-
-    def model_class!
-      model_class || raise(ActiveRecord::RecordNotFound)
-    end
-
-    def serializer_class
-      @serializer_class ||= RDF::Serializers.serializer_for(model_class!)
-    end
-
-    def serializer_class!
-      serializer_class || raise(ActiveRecord::RecordNotFound)
-    end
-
-    class << self
-      def linked_models
-        @linked_models ||= ObjectSpace.each_object(Class).select do |c|
-          c.included_modules.include?(LinkedRails::Model)
-        end
-      end
-    end
   end
 end

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

@@ -7,15 +7,23 @@ module LinkedRails
     class Item # rubocop:disable Metrics/ClassLength
       include ActiveModel::Model
       include LinkedRails::Model
-      enhance LinkedRails::Enhancements::Singularable
 
-      attr_accessor :list, :policy_arguments, :submit_label
+      attr_accessor :inherit, :list, :one_click, :policy_arguments, :submit_label, :target_path
       attr_writer :parent, :resource, :root_relative_iri, :user_context, :object,
                   :target
       delegate :user_context, to: :list, allow_nil: true
-
-      %i[description result type policy label image url include_object include_paths collection condition form completed
-         tag http_method favorite path policy_resource predicate resource].each do |method|
+      collection_options(
+        association_base: lambda {
+          action_list = parent ? parent.action_list(user_context) : association_class.app_action_list(user_context)
+
+          action_list.actions
+        },
+        display: :grid,
+        title: -> { I18n.t('actions.plural') }
+      )
+
+      %i[condition description result type policy label image target_url collection form
+         tag http_method favorite action_path policy_resource predicate resource].each do |method|
         attr_writer method
         define_method method do
           var = instance_variable_get(:"@#{method}")
@@ -28,10 +36,10 @@ module LinkedRails
 
       def action_status
         @action_status ||=
-          if completed
-            Vocab.schema.CompletedActionStatus
-          elsif policy_valid?
+          if policy_valid?
             Vocab.schema.PotentialActionStatus
+          elsif policy_status
+            policy_status
           elsif policy_expired?
             Vocab.ontola[:ExpiredActionStatus]
           else
@@ -39,13 +47,11 @@ module LinkedRails
           end
       end
 
-      def as_json(_opts = {})
+      def as_json(**_opts)
         {}
       end
 
       def available?
-        return false unless action_status == Vocab.schema.PotentialActionStatus
-
         @condition.nil? || condition
       end
 
@@ -62,9 +68,8 @@ module LinkedRails
           I18n.t("actions.status.#{action_status.to_s.split('#').last}", default: nil)
       end
 
-      def form_resource_includes # rubocop:disable Metrics/CyclomaticComplexity
+      def form_resource_includes
         return {} if included_object.nil?
-        return include_paths || {} if iri.anonymous?
 
         includes = included_object.class.try(:preview_includes)&.presence || []
 
@@ -72,7 +77,7 @@ module LinkedRails
       end
 
       def included_object
-        object if include_object || object&.iri&.anonymous?
+        object if object&.iri&.anonymous?
       end
 
       def object
@@ -92,10 +97,10 @@ module LinkedRails
       end
 
       def policy_message
-        resource_policy.try(:message) if action_status == Vocab.ontola[:DisabledActionStatus]
+        resource_policy.try(:message) unless policy_valid?
       end
 
-      def root_relative_iri(_opts = {})
+      def root_relative_iri(**_opts)
         value = root_relative_iri_from_var
         value = RDF::URI(value) unless value.blank? || value.is_a?(RDF::URI)
         return @root_relative_iri = value if value
@@ -117,16 +122,26 @@ module LinkedRails
         resource.try(:singular_resource?)
       end
 
+      def policy_status
+        resource_policy.try(:action_status)
+      end
+
       def iri_opts
-        resource&.iri_opts || {}
+        return {} if resource.blank?
+
+        resource.try(:singular_resource?) ? resource.singular_iri_opts : resource.iri_opts
       end
 
       def iri_template
-        path_suffix = path.blank? ? "/actions/#{tag}" : "/#{path}"
+        path_suffix = "/#{action_path || tag}"
 
-        return @iri_template ||= URITemplate.new(path_suffix) if resource.blank?
+        return @iri_template ||= LinkedRails::URITemplate.new(path_suffix) if resource.blank?
 
-        @iri_template ||= iri_template_expand_path(resource.send(:iri_template), path_suffix)
+        base_template = resource.send(resource.try(:singular_resource?) ? :singular_iri_template : :iri_template)
+        @iri_template ||= iri_template_expand_path(
+          base_template.to_s.sub('display,', '').sub('sort%5B%5D*,', ''),
+          path_suffix
+        )
       end
 
       def rdf_type
@@ -184,6 +199,12 @@ module LinkedRails
         @root_relative_iri
       end
 
+      def target_url_fallback
+        base = (resource.try(:singular_resource?) ? resource.singular_iri : resource.iri).dup
+        base.path += "/#{target_path}" if target_path.present?
+        base
+      end
+
       def type_fallback
         Vocab.schema.UpdateAction
       end
@@ -203,23 +224,18 @@ module LinkedRails
         end
 
         def requested_index_resource(params, user_context)
-          parent = parent_from_params(params, user_context)
-          action_list = parent ? parent.action_list(user_context) : app_action_list(user_context)
+          parent = parent_from_params!(params, user_context) if params.key?(:parent_iri)
 
-          LinkedRails.collection_class.new(
-            association_base: action_list.actions,
-            association_class: ::Actions::Item,
-            default_display: :grid,
-            default_title: I18n.t('actions.plural'),
-            parent: parent,
-            title: params[:title]
+          default_collection_option(:collection_class).collection_or_view(
+            default_collection_options.merge(parent: parent),
+            index_collection_params(params, user_context)
           )
         end
 
         def requested_single_resource(params, user_context)
           return nil if params[:id].blank?
 
-          parent = parent_from_params(params, user_context)
+          parent = parent_from_params!(params, user_context) if params.key?(:parent_iri)
           action_list = parent ? parent.action_list(user_context) : app_action_list(user_context)
 
           action_list&.action(params[:id].to_sym)

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

@@ -7,14 +7,12 @@ module LinkedRails
     class List
       include ActiveModel::Model
       include LinkedRails::Model
-      include DefaultActions
-      extend LinkedRails::Enhanceable
 
       attr_accessor :resource, :user_context
       class_attribute :_defined_actions, instance_reader: false, instance_writer: false
 
       def actions
-        @actions ||= defined_actions.map { |tag, opts| action_item(tag, opts.dup) }
+        @actions ||= defined_actions.map { |tag, opts| action_item(tag, opts.dup) }.select(&:available?)
       end
 
       def action(tag)
@@ -34,9 +32,9 @@ module LinkedRails
       private
 
       def action_item(tag, options)
-        options[:tag] ||= options[:action_tag] || tag
+        options[:tag] ||= tag
         options[:list] ||= self
-        LinkedRails.actions_item_class.new(options.except(:action_tag))
+        LinkedRails.actions_item_class.new(options.except(:action_name))
       end
 
       def association
@@ -77,26 +75,11 @@ module LinkedRails
 
         private
 
-        def has_collection_action(action, opts = {}) # rubocop:disable Naming/PredicateName
-          opts[:http_method] ||= 'POST'
-          defined_actions[:collection][action] = opts
-        end
-
-        def has_resource_action(action, opts = {}) # rubocop:disable Naming/PredicateName
-          opts[:http_method] ||= 'POST'
-          defined_actions[:resource][action] = opts
-        end
-
-        def has_singular_action(action, opts = {}) # rubocop:disable Naming/PredicateName
-          opts[:http_method] ||= 'POST'
-          defined_actions[:singular][action] = opts
-        end
-
         def initial_defined_actions(clone_from = {})
           {
-            collection: clone_from[:collection].dup || {},
-            resource: clone_from[:resource].dup || {},
-            singular: clone_from[:singular].dup || {}
+            collection: clone_from[:collection].dup&.select { |_, value| value[:inherit] != false } || {},
+            resource: clone_from[:resource].dup&.select { |_, value| value[:inherit] != false } || {},
+            singular: clone_from[:singular].dup&.select { |_, value| value[:inherit] != false } || {}
           }
         end
 
@@ -106,8 +89,6 @@ module LinkedRails
           self._defined_actions = initial_defined_actions(superclass.try(:_defined_actions) || {})
         end
       end
-
-      enhanceable :actionable_class, :Action
     end
   end
 end

data/app/models/linked_rails/collection/configuration.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Collection
+    module Configuration
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        private
+
+        def define_default_option_method(option)
+          attr_accessor "default_#{option}"
+        end
+
+        def define_getter_option_method(option)
+          attr_writer option
+
+          define_method(option) do
+            resolve_collection_option(option)
+          end
+        end
+      end
+
+      included do
+        attr_accessor :iri_template
+
+        LinkedRails::Model::Collections::COLLECTION_CUSTOMIZABLE_OPTIONS.each_key do |option|
+          define_default_option_method(option)
+        end
+        LinkedRails::Model::Collections::COLLECTION_OPTIONS.each_key do |option|
+          define_getter_option_method(option)
+        end
+
+        def display
+          resolve_collection_option(:display)&.to_sym
+        end
+
+        def type
+          resolve_collection_option(:type)&.to_sym
+        end
+      end
+
+      private
+
+      def resolve_collection_option(option)
+        var_name = :"@#{option}"
+        default_method_name = "default_#{option}"
+
+        var = instance_variable_defined?(var_name) ? instance_variable_get(var_name) : try(default_method_name)
+
+        var.respond_to?(:call) ? instance_exec(&var) : var
+      end
+    end
+  end
+end

data/app/models/linked_rails/collection/filter.rb

@@ -8,7 +8,7 @@ module LinkedRails
 
       attr_accessor :default_filter, :key, :value, :collection
 
-      def iri(_opts = {})
+      def iri(**_opts)
         self
       end
     end

data/app/models/linked_rails/collection/filter_field.rb

@@ -13,7 +13,7 @@ module LinkedRails
       callable_variable(:options_array)
       callable_variable(:options_in)
 
-      def iri(_opts = {})
+      def iri(**_opts)
         self
       end
 
@@ -25,6 +25,10 @@ module LinkedRails
         attrs = option.is_a?(Hash) ? option : {value: option}
         Collection::FilterOption.new(attrs.merge(collection: collection, key: key))
       end
+
+      def serializable?
+        options_in || options_array
+      end
     end
   end
 end

data/app/models/linked_rails/collection/filter_option.rb

@@ -9,7 +9,7 @@ module LinkedRails
 
       attr_accessor :collection, :count, :value, :key
 
-      def iri(_opts = {})
+      def iri(**_opts)
         self
       end
     end

data/app/models/linked_rails/collection/filterable.rb

@@ -5,12 +5,7 @@ module LinkedRails
     module Filterable
       include RDF::Serializers::DataTypeHelper
 
-      attr_writer :default_filters, :filter, :unfiltered_collection
-
-      def default_filters
-        opts = @default_filters || association_class.try(:default_filters) || {}
-        opts.respond_to?(:call) ? opts.call(parent) : opts
-      end
+      attr_writer :filter, :unfiltered_collection
 
       def filter
         default_filters.merge(@filter || {})
@@ -19,7 +14,7 @@ module LinkedRails
       delegate :filter_options, to: :association_class
 
       def filter_fields
-        @filter_fields ||= filter_options&.map { |key, options| filter_field(key, options) }
+        @filter_fields ||= filter_options&.map { |key, options| filter_field(key, options) }&.select(&:serializable?)
       end
 
       def filtered?
@@ -83,7 +78,7 @@ module LinkedRails
 
       def sanitized_filter_value(key, value)
         mapping = association_class.predicate_mapping[key]
-        datatype = mapping.is_a?(FastJsonapi::Relationship) ? RDF.xsd.anyURI : mapping.datatype
+        datatype = mapping.is_a?(FastJsonapi::Relationship) ? Vocab.xsd.anyURI : mapping.datatype
         val = xsd_to_rdf(datatype, value)
         val.literal? ? val.object : val
       end

data/app/models/linked_rails/collection/infinite.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  class Collection
+    module Infinite
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :before
+      end
+
+      def initialize(orignial = {})
+        attrs = orignial.with_indifferent_access
+        attrs[:before] = attrs[:before]&.map { |val| val.with_indifferent_access }
+        super(attrs)
+      end
+
+      def next
+        return if before.blank? || members.blank?
+
+        current_opts = {
+          collection: collection,
+          filter: filter
+        }
+        next_view = collection.view_with_opts(current_opts.merge(before: next_before_values))
+
+        next_view.iri if next_view.count.positive?
+      end
+
+      def prev; end
+
+      def type
+        :infinite
+      end
+
+      private
+
+      def additional_statements(arel, index)
+        (preconditions(index) + [arel]).reduce { |or_acc, or_value| or_acc.and(or_value) }
+      end
+
+      def before_iri_opts
+        before&.map { |hash| "#{CGI.escape(hash[:key])}=#{hash[:value]}" }
+      end
+
+      def before_query
+        before_values.each_with_index.reduce(nil) do |acc, (value, index)|
+          arel = arel_table[value[:attribute]].send(value[:direction], value[:value])
+          acc.nil? ? arel : acc.or(additional_statements(arel, index))
+        end
+      end
+
+      def before_values
+        @before_values ||= before&.map do |value|
+          sorting = collection.sortings.detect { |s| s.key == value[:key] }
+          {
+            attribute: sorting.attribute_name,
+            direction: sorting.sort_direction,
+            key: value[:key],
+            value: value[:value]
+          }
+        end
+      end
+
+      def iri_opts
+        {
+          'before%5B%5D': before_iri_opts
+        }.merge(collection.iri_opts)
+      end
+
+      def members_query
+        prepare_members(association_base)
+          .where(before_query)
+          .limit(page_size)
+      end
+
+      def next_before_values
+        last_record = members.last
+        before_values.map do |val|
+          value = last_record.send(val[:attribute])
+          value = value.utc.iso8601(6) if value.is_a?(Time)
+          {
+            key: val[:key],
+            value: value
+          }
+        end
+      end
+
+      def preconditions(index)
+        before_values[0...index].map do |v|
+          condition = arel_table[v[:attribute]].eq(v[:value])
+          condition = condition.or(arel_table[v[:attribute]].eq(nil)) if v[:direction] == :gt
+          condition
+        end
+      end
+
+      def sort_column
+        @sort_column ||= collection.sortings.last.sort_value.keys.first
+      end
+    end
+  end
+end

data/app/models/linked_rails/collection/infinite_view.rb

@@ -3,96 +3,7 @@
 module LinkedRails
   class Collection
     class InfiniteView < LinkedRails.collection_view_class
-      attr_accessor :before
-
-      def initialize(orignial = {})
-        attrs = orignial.with_indifferent_access
-        attrs[:before] = attrs[:before]&.map { |val| val.with_indifferent_access }
-        super(attrs)
-      end
-
-      def next
-        return if before.blank? || members.blank?
-
-        current_opts = {
-          collection: collection,
-          filter: filter
-        }
-        next_view = collection.view_with_opts(current_opts.merge(before: next_before_values))
-
-        next_view.iri if next_view.count.positive?
-      end
-
-      def prev; end
-
-      def type
-        :infinite
-      end
-
-      private
-
-      def additional_statements(arel, index)
-        (preconditions(index) + [arel]).reduce { |or_acc, or_value| or_acc.and(or_value) }
-      end
-
-      def before_iri_opts
-        before&.map { |hash| "#{CGI.escape(hash[:key])}=#{hash[:value]}" }
-      end
-
-      def before_query
-        before_values.each_with_index.reduce(nil) do |acc, (value, index)|
-          arel = arel_table[value[:attribute]].send(value[:direction], value[:value])
-          acc.nil? ? arel : acc.or(additional_statements(arel, index))
-        end
-      end
-
-      def before_values
-        @before_values ||= before&.map do |value|
-          sorting = collection.sortings.detect { |s| s.key == value[:key] }
-          {
-            attribute: sorting.attribute_name,
-            direction: sorting.sort_direction,
-            key: value[:key],
-            value: value[:value]
-          }
-        end
-      end
-
-      def iri_opts
-        {
-          'before%5B%5D': before_iri_opts
-        }.merge(collection.iri_opts)
-      end
-
-      def members_query
-        prepare_members(association_base)
-          .where(before_query)
-          .limit(page_size)
-      end
-
-      def next_before_values
-        last_record = members.last
-        before_values.map do |val|
-          value = last_record.send(val[:attribute])
-          value = value.utc.iso8601(6) if value.is_a?(Time)
-          {
-            key: val[:key],
-            value: value
-          }
-        end
-      end
-
-      def preconditions(index)
-        before_values[0...index].map do |v|
-          condition = arel_table[v[:attribute]].eq(v[:value])
-          condition = condition.or(arel_table[v[:attribute]].eq(nil)) if v[:direction] == :gt
-          condition
-        end
-      end
-
-      def sort_column
-        @sort_column ||= collection.sortings.last.sort_value.keys.first
-      end
+      include LinkedRails::Collection::Infinite
     end
   end
 end