linked_rails 0.0.1 → 0.0.4.pre.g2c53724b3

data/lib/linked_rails/model/filtering.rb

@@ -6,9 +6,7 @@ module LinkedRails
       extend ActiveSupport::Concern
 
       included do
-        class_attribute :default_filters, instance_accessor: false, instance_predicate: false
         class_attribute :filter_options
-        self.default_filters = {}
       end
 
       module ClassMethods
@@ -16,17 +14,17 @@ module LinkedRails
           class_variables.include?(:@@filter_options) ? super : {}
         end
 
-        def filterable(options = {})
+        def filterable(**options)
           initialize_filter_options
 
-          self.filter_options = HashWithIndifferentAccess.new(options).merge(filter_options)
+          self.filter_options = filter_options.merge(options)
 
           options.map { |k, filter| define_filter_method(k, filter) }
         end
 
         private
 
-        def boolean_filter(true_filter, false_filter, options = {})
+        def boolean_filter(true_filter, false_filter, **options)
           {
             filter: resolve_boolean_filter(true_filter, false_filter),
             values: [true, false]
@@ -36,7 +34,7 @@ module LinkedRails
         def initialize_filter_options
           return if filter_options && method(:filter_options).owner == singleton_class
 
-          self.filter_options = superclass.try(:filter_options)&.dup || {}
+          self.filter_options = superclass.try(:filter_options)&.dup || HashWithIndifferentAccess.new
         end
 
         def define_filter_method(key, filter)

data/lib/linked_rails/model/indexable.rb

@@ -15,33 +15,23 @@ module LinkedRails
           parent.send(collection_name, params) if collection_name
         end
 
-        def root_collection(params = {})
+        def root_collection(**params)
           return unless root_collection?
 
-          root_collection_class.collection_or_view(root_collection_opts, params)
-        end
-
-        def root_collection_class
-          LinkedRails.collection_class
+          default_collection_option(:collection_class).collection_or_view(
+            default_collection_options,
+            params
+          )
         end
 
         private
 
         def collection_from_parent_name(parent, _params)
-          collection_name = "#{name.underscore}_collection"
+          collection_name = "#{name.demodulize.underscore}_collection"
 
           collection_name if parent.respond_to?(collection_name, true)
         end
 
-        def grid_max_columns; end
-
-        def root_collection_opts
-          {
-            association_class: self,
-            grid_max_columns: grid_max_columns
-          }
-        end
-
         def root_collection?
           true
         end

data/lib/linked_rails/model/iri.rb

@@ -2,7 +2,7 @@
 
 module LinkedRails
   module Model
-    module Iri
+    module IRI
       extend ActiveSupport::Concern
 
       def anonymous_iri
@@ -14,13 +14,17 @@ module LinkedRails
       end
 
       # @return [RDF::URI].
-      def iri(opts = {})
+      def iri(**opts)
         return anonymous_iri if anonymous_iri?
-        return iri_with_root(root_relative_iri(opts)) if opts.present?
+        return iri_with_root(root_relative_iri(**opts)) if opts.present?
 
         @iri ||= iri_with_root(root_relative_iri)
       end
 
+      def iri_elements
+        root_relative_iri.to_s&.split('?')&.first&.split('/')&.map(&:presence)&.compact&.presence
+      end
+
       # @return [Hash]
       def iri_opts
         @iri_opts ||= {
@@ -33,14 +37,14 @@ module LinkedRails
         self.class.iri
       end
 
-      def reload(_opts = {})
+      def reload(**_opts)
         @iri = nil
         super
       end
 
       # @return [RDF::URI]
-      def root_relative_iri(opts = {})
-        RDF::URI(expand_iri_template(iri_opts.merge(opts)))
+      def root_relative_iri(**opts)
+        RDF::URI(expand_iri_template(**iri_opts.merge(opts)))
       end
 
       # @return [String, Symbol]
@@ -49,7 +53,7 @@ module LinkedRails
       private
 
       # @return [String]
-      def expand_iri_template(args = {})
+      def expand_iri_template(**args)
         iri_template.expand(args)
       end
 
@@ -68,7 +72,7 @@ module LinkedRails
 
       # @return [URITemplate]
       def iri_template_expand_path(template_base, path)
-        tokens = template_base.tokens
+        tokens = (template_base.is_a?(String) ? LinkedRails::URITemplate.new(template_base) : template_base).tokens
 
         ind = tokens.find_index do |t|
           t.is_a?(URITemplate::RFC6570::Expression::FormQuery) || t.is_a?(URITemplate::RFC6570::Expression::Fragment)
@@ -76,18 +80,12 @@ module LinkedRails
 
         prefix = ind ? tokens[0...ind] : tokens
         suffix = ind ? tokens[ind..-1] : []
-        URITemplate.new([prefix, path, suffix].flatten.join)
+        LinkedRails::URITemplate.new([prefix, path, suffix].flatten.join)
       end
 
       # @return [URITemplate]
       def iri_template_with_fragment(template_base, fragment)
-        URITemplate.new("#{template_base.to_s.sub(/{#[\w]+}/, '').split('#').first}##{fragment}")
-      end
-
-      def singular_iri; end
-
-      def singular_iri_opts
-        {}
+        LinkedRails::URITemplate.new("#{template_base.to_s.sub(/{#[\w]+}/, '').split('#').first}##{fragment}")
       end
 
       module ClassMethods
@@ -99,7 +97,7 @@ module LinkedRails
           return if self == ApplicationRecord
 
           superclass.try(:iri_namespace) ||
-            (linked_rails_module? ? Vocab.ontola : LinkedRails.app_vocab)
+            (linked_rails_module? ? Vocab.ontola : Vocab.app)
         end
 
         def iri_value
@@ -107,14 +105,25 @@ module LinkedRails
         end
 
         def iri_template
-          @iri_template ||= URITemplate.new("/#{route_key}{/id}{#fragment}")
+          @iri_template ||= LinkedRails::URITemplate.new("/#{route_key}{/id}{#fragment}")
+        end
+
+        def iris_from_scope(scope)
+          ids = ids_for_iris(scope).uniq
+          ids.map { |id| LinkedRails.iri(path: iri_template.expand(id: id)) }
+        end
+
+        def ids_for_iris(scope)
+          scope.pluck(:id)
         end
 
         def linked_rails_module?
           (Rails.version < '6' ? parents : module_parents).include?(LinkedRails)
         end
 
-        delegate :route_key, to: :model_name
+        def route_key
+          try(:model_name)&.route_key || to_s.tableize
+        end
       end
     end
   end

data/lib/linked_rails/model/iri_mapping.rb

@@ -2,7 +2,7 @@
 
 module LinkedRails
   module Model
-    module IriMapping
+    module IRIMapping
       extend ActiveSupport::Concern
 
       module ClassMethods
@@ -10,11 +10,24 @@ module LinkedRails
           LinkedRails.iri_mapper.parent_from_params(params, user_context)
         end
 
+        def parent_from_params!(params, user_context)
+          parent_from_params(params, user_context) || raise(ActiveRecord::RecordNotFound)
+        end
+
+        def requested_action(opts, user_context)
+          action_key = opts[:params][:action_key]
+          resource = LinkedRails.iri_mapper.resource_from_iri(
+            iri_without_action(opts[:iri]),
+            user_context
+          )
+          resource&.action(action_key, user_context)
+        end
+
         def requested_index_resource(params, user_context)
           if params.key?(:parent_iri)
             collection_from_parent(index_collection_params(params, user_context))
           else
-            root_collection(index_collection_params(params, user_context))
+            root_collection(**index_collection_params(params, user_context))
           end
         end
 
@@ -25,10 +38,10 @@ module LinkedRails
         def requested_resource(opts, user_context)
           if collection_action?(opts)
             requested_index_resource(opts[:params], user_context)
+          elsif action_item_action?(opts)
+            requested_action(opts, user_context)
           elsif singular_action?(opts)
-            resource = requested_singular_resource(opts[:params], user_context)
-            resource&.singular_resource = true
-            resource
+            singular_resource(requested_singular_resource(opts[:params], user_context))
           else
             requested_single_resource(opts[:params], user_context)
           end
@@ -38,7 +51,7 @@ module LinkedRails
           if self < ActiveRecord::Base
             find_by(primary_key => params[:id]) if params.key?(:id)
           else
-            new(params)
+            new(params.except(:format))
           end
         end
 
@@ -46,10 +59,20 @@ module LinkedRails
           requested_single_resource(params, user_context) || raise(ActiveRecord::RecordNotFound)
         end
 
+        def singular_resource(resource)
+          resource&.singular_resource = true
+          resource
+        end
+
         private
 
+        def action_item_action?(opts)
+          opts[:params][:action_key].present?
+        end
+
         def collection_action?(opts)
-          %w[index create].include?(opts[:action]) && !opts[:params][:singular_route]
+          opts[:action] == 'index' ||
+            opts[:class].action_list.defined_actions[:collection].key?(opts[:action].to_sym)
         end
 
         def index_collection_params(params, user_context)
@@ -57,7 +80,13 @@ module LinkedRails
 
           {
             user_context: user_context
-          }.merge(params_hash).with_indifferent_access
+          }.merge(params_hash).symbolize_keys
+        end
+
+        def iri_without_action(url)
+          iri = RDF::URI(url)
+          iri.path = iri.path.split('/')[0...-1].join('/') if iri.path
+          iri.to_s
         end
 
         def singular_action?(opts)

data/lib/linked_rails/model/menuable.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Model
+    module Menuable
+      extend ActiveSupport::Concern
+
+      def menus(user_context = nil)
+        menu_list(user_context).menus
+      end
+
+      def menu(tag, user_context = nil)
+        menu_list(user_context).menu(tag)
+      end
+
+      def menu_list(user_context = nil)
+        @menu_list ||= {}
+        @menu_list[user_context] ||= self.class.menu_class.new(resource: self, user_context: user_context)
+      end
+
+      module ClassMethods
+        def menu_class
+          @menu_class ||= "#{name}MenuList".safe_constantize || "#{superclass.name}MenuList".safe_constantize
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/model/serialization.rb

@@ -16,19 +16,6 @@ module LinkedRails
       end
 
       module ClassMethods
-        def attributes_from_filters(filters)
-          filters.each_with_object({}) do |(key, value), hash|
-            next unless value.count == 1
-
-            attribute = predicate_mapping[key]&.key
-            hash[attribute] = value.first if attribute
-          end
-        end
-
-        def include_in_collection?
-          false
-        end
-
         def input_select_property
           Vocab.schema.name
         end
@@ -68,7 +55,7 @@ module LinkedRails
           serializer
             .attributes_to_serialize
             .values
-            .select { |attr| attr.predicate.present? }
+            .select { |attr| attr.predicate.present? && !attr.predicate.is_a?(Proc) }
             .map { |attr| [attr.predicate, attr] }
         end
 
@@ -79,7 +66,7 @@ module LinkedRails
           serializer
             .relationships_to_serialize
             .values
-            .select { |value| value.predicate.present? }
+            .select { |value| value.predicate.present? && !value.predicate.is_a?(Proc) }
             .map { |value| [value.predicate, value] }
         end
       end

data/lib/linked_rails/model/singularable.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Model
+    module Singularable
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :singular_resource
+      end
+
+      def root_relative_singular_iri(**opts)
+        RDF::URI(singular_iri_template.expand(singular_iri_opts.merge(opts)))
+      end
+
+      def root_relative_iri(**opts)
+        return super unless singular_iri?
+
+        root_relative_singular_iri(**opts)
+      end
+
+      def singular_iri(**opts)
+        return iri_with_root(root_relative_singular_iri(**opts)) if opts.present?
+
+        @singular_iri ||= iri_with_root(root_relative_singular_iri)
+      end
+
+      def singular_iri?
+        anonymous_iri?
+      end
+
+      def singular_iri_opts
+        {}
+      end
+
+      def singular_iri_template
+        self.class.singular_iri_template
+      end
+
+      def singular_resource?
+        singular_resource || false
+      end
+
+      class_methods do
+        delegate :singular_route_key, to: :model_name
+
+        def requested_singular_resource(_params, _user_context)
+          raise(NotImplementedError)
+        end
+
+        def singular_iri_template
+          @singular_iri_template ||= LinkedRails::URITemplate.new("{/parent_iri*}/#{singular_route_key}{#fragment}")
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/model/sorting.rb

@@ -5,11 +5,6 @@ module LinkedRails
     module Sorting
       extend ActiveSupport::Concern
 
-      included do
-        class_attribute :default_sortings, instance_accessor: false, instance_predicate: false
-        self.default_sortings = [{key: Vocab.schema.dateCreated, direction: :desc}]
-      end
-
       module ClassMethods
         def default_sort_column
           :created_at

data/lib/linked_rails/model/tables.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Model
+    module Tables
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :defined_columns
+      end
+
+      module ClassMethods
+        def with_columns(opts)
+          initialize_columns
+          defined_columns.merge!(opts)
+        end
+
+        def initialize_columns
+          return if defined_columns && method(:defined_columns).owner == singleton_class
+
+          self.defined_columns = superclass.try(:defined_columns)&.dup || {}.with_indifferent_access
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/model.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative 'model/actionable'
 require_relative 'model/collections'
 require_relative 'model/dirty'
 require_relative 'model/enhancements'
@@ -7,33 +8,42 @@ require_relative 'model/filtering'
 require_relative 'model/indexable'
 require_relative 'model/iri'
 require_relative 'model/iri_mapping'
+require_relative 'model/menuable'
 require_relative 'model/serialization'
+require_relative 'model/singularable'
 require_relative 'model/sorting'
+require_relative 'model/tables'
 
 module LinkedRails
   module Model
     extend ActiveSupport::Concern
+    include Actionable
     include Collections
     include Dirty
     include Enhancements
     include Filtering
     include Indexable
-    include Iri
-    include IriMapping
+    include IRI
+    include IRIMapping
+    include Menuable
     include Serialization
+    include Singularable
     include Sorting
+    include Tables
 
     def build_child(klass, user_context: nil)
       klass.build_new(parent: self, user_context: user_context)
     end
 
-    def singular_resource?
-      false
-    end
-
     module ClassMethods
       def build_new(parent: nil, user_context: nil)
-        new(attributes_for_new(parent: parent, user_context: user_context))
+        raise(ActiveRecord::RecordNotFound) if try(:abstract_class?)
+
+        new(**attributes_for_new(parent: parent, user_context: user_context))
+      end
+
+      def controller_class
+        @controller_class ||= "#{to_s.pluralize}Controller".safe_constantize || superclass.try(:controller_class)
       end
 
       def form_class