linked_rails 0.0.1

data/lib/linked_rails/model/collections.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Model
+    module Collections
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :collections
+      end
+
+      # Initialises a {Collection} for one of the collections defined by {has_collection}
+      # @see Ldable#has_collection
+      # @param [Hash] name as defined with {has_collection}
+      # @param [Class] user_context
+      # @param [Hash] filter
+      # @param [Integer, String] page
+      # @param [ApplicationRecord] part_of
+      # @param [Hash] opts Additional options to be passed to the collection.
+      # @return [Collection]
+      def collection_for(name, instance_opts = {})
+        collection_opts = collections.detect { |c| c[:name] == name }.try(:[], :options).dup
+        return if collection_opts.blank?
+
+        collection_opts[:name] = name
+        collection_opts[:parent] = self
+        collection_opts[:part_of] = collection_opts.key?(:part_of) ? send(collection_opts[:part_of]) : self
+        collection_class = collection_opts.delete(:collection_class) || LinkedRails.collection_class
+        collection_class.collection_or_view(collection_opts, instance_opts)
+      end
+
+      def parent_collections(user_context)
+        return [] if try(:parent).try(:collections).blank?
+
+        parent_collections_for(parent, user_context)
+      end
+
+      private
+
+      def parent_collections_for(parent, user_context)
+        parent
+          .collections
+          .select { |collection| is_a?(collection[:options][:association_class]) }
+          .map { |collection| parent.collection_for(collection[:name], user_context: user_context) }
+      end
+
+      module ClassMethods
+        def collections_add(opts)
+          initialize_collections
+          collections.delete_if { |c| c[:name] == opts[:name] }
+          collections.append(opts)
+        end
+
+        def initialize_collections
+          return if collections && method(:collections).owner == singleton_class
+
+          self.collections = superclass.try(:collections)&.dup || []
+        end
+
+        # Defines a collection to be used in {collection_for}
+        # @see Ldable#collection_for
+        # @note Adds a instance_method <name>_collection
+        # @param [Hash] name as to be used in {collection_for}
+        # @param [Hash] options
+        # @option options [Sym] association the name of the association
+        # @option options [Class] association_class the class of the association
+        # @option options [Sym] joins the associations to join
+        # @return [Collection]
+        def with_collection(name, options = {})
+          options[:association] ||= name.to_sym
+          options[:association_class] ||= name.to_s.classify.constantize
+
+          collections_add(name: name, options: options)
+
+          define_method "#{name.to_s.singularize}_collection" do |opts = {}|
+            collection_for(name, opts)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/model/dirty.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Model
+    module Dirty
+      extend ActiveSupport::Concern
+
+      included do
+        def assign_nested_attributes_for_one_to_one_association(association_name, attributes)
+          association_has_destructed(association_name) if will_destruct_association?(association_name, attributes)
+
+          super
+        end
+
+        def assign_nested_attributes_for_collection_association(association_name, attrs)
+          attributes = attrs
+          attributes = attrs.with_indifferent_access.key?(:id) ? [attrs] : attrs.values if attrs.is_a?(Hash)
+
+          association_has_destructed(association_name) if will_destruct_association?(association_name, attributes)
+
+          super
+        end
+      end
+
+      def previous_changes_by_predicate
+        serializer_class = RDF::Serializers.serializer_for(self)
+        return {} unless respond_to?(:previous_changes) && serializer_class
+
+        Hash[
+          previous_changes
+            .map { |k, v| [serializer_class.attributes_to_serialize[k.to_sym]&.predicate, v] }
+            .select { |k, _v| k.present? }
+        ]
+      end
+
+      def previously_changed_relations
+        serializer_class = RDF::Serializers.serializer_for(self)
+        return {} unless serializer_class.try(:relationships_to_serialize)
+
+        serializer_class.relationships_to_serialize.select do |key, _value|
+          if respond_to?(key)
+            association_key = key.to_s.ends_with?('_collection') ? send(key).association : key
+            association_has_destructed?(association_key) || association_changed?(association_key)
+          end
+        end.with_indifferent_access
+      end
+
+      private
+
+      def association_changed?(association) # rubocop:disable Metrics/AbcSize
+        ids_method = "#{association.to_s.singularize}_ids"
+        return true if previous_changes.include?("#{association}_id") || previous_changes.include?(ids_method)
+        return false unless try(:association_cached?, association)
+
+        if self.class.reflect_on_association(association).collection?
+          send(association).any? { |a| a.previous_changes.present? }
+        else
+          send(association)&.previous_changes&.present?
+        end
+      end
+
+      def association_has_destructed(association_key)
+        @destructed_association_members ||= []
+        @destructed_association_members << association_key.to_sym
+      end
+
+      def association_has_destructed?(association_key)
+        @destructed_association_members&.include?(association_key.to_sym)
+      end
+
+      def will_destruct_association?(association_name, attributes)
+        return false unless nested_attributes_options[association_name][:allow_destroy]
+
+        if attributes.is_a?(Array)
+          attributes.any? { |attrs| has_destroy_flag?(attrs.with_indifferent_access) }
+        else
+          has_destroy_flag?(attributes.with_indifferent_access)
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/model/enhancements.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Model
+    module Enhancements
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :enhancements
+        self.enhancements ||= {}
+      end
+
+      def enhanced_with?(enhancement)
+        self.class.enhancements.include?(enhancement)
+      end
+
+      module ClassMethods
+        # Adds an enhancement to a model and includes the Model module.
+        def enhance(enhancement, opts = {})
+          initialize_enhancements
+          already_included = enhanced_with?(enhancement)
+
+          self.enhancements[enhancement] = opts
+          return if already_included
+
+          enhance_routing(enhancement) if enhancement.const_defined?(:Routing) && enhanced_with?(enhancement, :Routing)
+          include enhancement::Model if enhancement.const_defined?(:Model) && enhanced_with?(enhancement, :Model)
+        end
+
+        def enhanced_with?(enhancement, const = nil)
+          return false unless self.enhancements.key?(enhancement)
+          return true if const.nil?
+
+          opts = self.enhancements[enhancement]
+
+          return opts[:only].include?(const) if opts.key?(:only)
+
+          !opts.key?(:except) || !opts[:except].include?(const)
+        end
+
+        def enhancement_modules(const)
+          enhancements
+            .select { |enhancement, _opts| enhancement.const_defined?(const) && enhanced_with?(enhancement, const) }
+            .map { |enhancement, _opts| enhancement.const_get(const) }
+        end
+
+        private
+
+        def enhance_routing(enhancement)
+          LinkedRails::Enhancements::RouteConcerns.add_concern(enhancement)
+        end
+
+        def initialize_enhancements
+          return if enhancements && method(:enhancements).owner == singleton_class
+
+          self.enhancements = superclass.try(:enhancements)&.dup || {}
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/model/filtering.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Model
+    module Filtering
+      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
+        def filter_options
+          class_variables.include?(:@@filter_options) ? super : {}
+        end
+
+        def filterable(options = {})
+          initialize_filter_options
+
+          self.filter_options = HashWithIndifferentAccess.new(options).merge(filter_options)
+
+          options.map { |k, filter| define_filter_method(k, filter) }
+        end
+
+        private
+
+        def boolean_filter(true_filter, false_filter, options = {})
+          {
+            filter: resolve_boolean_filter(true_filter, false_filter),
+            values: [true, false]
+          }.merge(options)
+        end
+
+        def initialize_filter_options
+          return if filter_options && method(:filter_options).owner == singleton_class
+
+          self.filter_options = superclass.try(:filter_options)&.dup || {}
+        end
+
+        def define_filter_method(key, filter)
+          method = predicate_mapping[key]&.key
+          return if !method || method_defined?(method) || !filter[:attr]
+
+          enum_map = defined_enums[method.to_s]
+
+          if enum_map
+            define_enum_filter_method(method, filter, enum_map)
+          else
+            define_plain_filter_method(method, filter)
+          end
+        end
+
+        def define_enum_filter_method(key, filter, enum_map)
+          define_method key do
+            filter[:values].key(enum_map[send(filter[:attr] || key)])
+          end
+
+          define_method "#{key}=" do |value|
+            send("#{filter[:attr]}=", enum_map.key(filter[:values][value&.to_sym]))
+          end
+        end
+
+        def define_plain_filter_method(key, filter)
+          define_method key do
+            filter[:values][send(filter[:attr])]
+          end
+
+          define_method "#{key}=" do |value|
+            send("#{filter[:attr]}=", filter[:values].key(value))
+          end
+        end
+
+        def resolve_boolean_filter(true_filter, false_filter)
+          lambda { |scope, values|
+            if values.include?(true) && values.include?(false)
+              scope
+            else
+              values.reduce(scope) do |_sub_scope, val|
+                val ? true_filter.call(scope) : false_filter.call(scope)
+              end
+            end
+          }
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/model/indexable.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Model
+    module Indexable
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def collection_from_parent(params)
+          parent = parent_from_params(params, params[:user_context])
+          return if parent.blank?
+
+          collection_name = collection_from_parent_name(parent, params)
+
+          parent.send(collection_name, params) if collection_name
+        end
+
+        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
+        end
+
+        private
+
+        def collection_from_parent_name(parent, _params)
+          collection_name = "#{name.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
+      end
+    end
+  end
+end

data/lib/linked_rails/model/iri.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module Model
+    module Iri
+      extend ActiveSupport::Concern
+
+      def anonymous_iri
+        @anonymous_iri ||= RDF::Node.new
+      end
+
+      def anonymous_iri?
+        self.class < ActiveRecord::Base && new_record?
+      end
+
+      # @return [RDF::URI].
+      def iri(opts = {})
+        return anonymous_iri if anonymous_iri?
+        return iri_with_root(root_relative_iri(opts)) if opts.present?
+
+        @iri ||= iri_with_root(root_relative_iri)
+      end
+
+      # @return [Hash]
+      def iri_opts
+        @iri_opts ||= {
+          fragment: route_fragment,
+          id: to_param
+        }
+      end
+
+      def rdf_type
+        self.class.iri
+      end
+
+      def reload(_opts = {})
+        @iri = nil
+        super
+      end
+
+      # @return [RDF::URI]
+      def root_relative_iri(opts = {})
+        RDF::URI(expand_iri_template(iri_opts.merge(opts)))
+      end
+
+      # @return [String, Symbol]
+      def route_fragment; end
+
+      private
+
+      # @return [String]
+      def expand_iri_template(args = {})
+        iri_template.expand(args)
+      end
+
+      # @return [RDF::URI]
+      def iri_with_root(root_relative_iri)
+        iri = root_relative_iri.dup
+        iri.scheme = LinkedRails.scheme
+        iri.host = LinkedRails.host
+        iri
+      end
+
+      # @return [URITemplate]
+      def iri_template
+        self.class.iri_template
+      end
+
+      # @return [URITemplate]
+      def iri_template_expand_path(template_base, path)
+        tokens = template_base.tokens
+
+        ind = tokens.find_index do |t|
+          t.is_a?(URITemplate::RFC6570::Expression::FormQuery) || t.is_a?(URITemplate::RFC6570::Expression::Fragment)
+        end
+
+        prefix = ind ? tokens[0...ind] : tokens
+        suffix = ind ? tokens[ind..-1] : []
+        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
+        {}
+      end
+
+      module ClassMethods
+        def iri
+          @iri ||= iri_namespace[iri_value] if iri_namespace
+        end
+
+        def iri_namespace
+          return if self == ApplicationRecord
+
+          superclass.try(:iri_namespace) ||
+            (linked_rails_module? ? Vocab.ontola : LinkedRails.app_vocab)
+        end
+
+        def iri_value
+          linked_rails_module? ? name.demodulize : name
+        end
+
+        def iri_template
+          @iri_template ||= URITemplate.new("/#{route_key}{/id}{#fragment}")
+        end
+
+        def linked_rails_module?
+          (Rails.version < '6' ? parents : module_parents).include?(LinkedRails)
+        end
+
+        delegate :route_key, to: :model_name
+      end
+    end
+  end
+end