linked_rails 0.0.1

data/lib/generators/linked_rails/model/model_generator.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'rails/generators/active_record/model/model_generator'
+
+module LinkedRails
+  class ModelGenerator < ActiveRecord::Generators::ModelGenerator
+    include Rails::Generators::ResourceHelpers
+    source_root File.expand_path('templates', __dir__)
+
+    def create_migration_file # rubocop:disable Metrics/AbcSize
+      return unless options[:migration] && options[:parent].nil?
+
+      if options[:indexes] == false
+        attributes.each { |a| a.attr_options.delete(:index) if a.reference? && !a.has_index? }
+      end
+      migration_template 'create_table_migration.rb', File.join(db_migrate_path, "create_#{table_name}.rb")
+    end
+
+    def copy_files # rubocop:disable Metrics/AbcSize
+      template 'action_list.rb', File.join('app', 'actions', class_path, "#{file_name}_action_list.rb")
+      template 'controller.rb', File.join('app', 'controllers', class_path, "#{plural_file_name}_controller.rb")
+      template 'form.rb', File.join('app', 'forms', class_path, "#{file_name}_form.rb")
+      template 'menu_list.rb', File.join('app', 'menus', class_path, "#{file_name}_menu_list.rb")
+      template 'policy.rb', File.join('app', 'policies', class_path, "#{file_name}_policy.rb")
+      template 'serializer.rb', File.join('app', 'serializers', class_path, "#{file_name}_serializer.rb")
+    end
+
+    def insert_route
+      after = after_sorted_match(routes_path, /linked_resource\((\w+\))/)
+
+      opts = after ? {after: after} : {before: 'end'}
+      inject_into_file(routes_path, routes_line, opts)
+    end
+
+    private
+
+    def after_sorted_match(file, matcher, name = class_name)
+      after = nil
+
+      File.open(file).each do |line|
+        match = line.match(matcher)
+        after = line if match.try(:[], 1).present? && match[1] <= name
+      end
+
+      return if after == name
+
+      after
+    end
+
+    def routes_line
+      "  linked_resource(#{class_name})\n"
+    end
+
+    def routes_path
+      File.join('config', 'routes.rb')
+    end
+  end
+end

data/lib/generators/linked_rails/model/templates/action_list.rb.tt

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+<% module_namespacing do -%>
+class <%= class_name %>ActionList < ApplicationActionList
+end
+<% end -%>

data/lib/generators/linked_rails/model/templates/controller.rb.tt

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+<% module_namespacing do -%>
+class <%= controller_class_name %>Controller < ApplicationController
+    active_response :show, :index
+end
+<% end -%>

data/lib/generators/linked_rails/model/templates/create_table_migration.rb.tt

@@ -0,0 +1,24 @@
+class <%= migration_class_name %> < ActiveRecord::Migration[<%= ActiveRecord::Migration.current_version %>]
+  def change
+    create_table :<%= table_name %><%= primary_key_type %> do |t|
+<% attributes.each do |attribute| -%>
+<% if attribute.password_digest? -%>
+      t.string :password_digest<%= attribute.inject_options %>
+<% elsif attribute.token? -%>
+      t.string :<%= attribute.name %><%= attribute.inject_options %>
+<% else -%>
+      t.<%= attribute.type %> :<%= attribute.name %><%= attribute.inject_options %>
+<% end -%>
+<% end -%>
+<% if options[:timestamps] %>
+      t.timestamps
+<% end -%>
+    end
+<% attributes.select(&:token?).each do |attribute| -%>
+    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>, unique: true
+<% end -%>
+<% attributes_with_index.each do |attribute| -%>
+    add_index :<%= table_name %>, :<%= attribute.index_name %><%= attribute.inject_index_options %>
+<% end -%>
+  end
+end

data/lib/generators/linked_rails/model/templates/form.rb.tt

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+<% module_namespacing do -%>
+class <%= class_name %>Form < ApplicationForm
+end
+<% end -%>

data/lib/generators/linked_rails/model/templates/menu_list.rb.tt

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+<% module_namespacing do -%>
+class <%= class_name %>MenuList < ApplicationMenuList
+end
+<% end -%>

data/lib/generators/linked_rails/model/templates/model.rb.tt

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+<% module_namespacing do -%>
+class <%= class_name %> < <%= parent_class_name.classify %>
+<% attributes.select(&:reference?).each do |attribute| -%>
+  belongs_to :<%= attribute.name %><%= ', polymorphic: true' if attribute.polymorphic? %><%= ', required: true' if attribute.required? %>
+<% end -%>
+<% attributes.select(&:token?).each do |attribute| -%>
+  has_secure_token<% if attribute.name != "token" %> :<%= attribute.name %><% end %>
+<% end -%>
+<% if attributes.any?(&:password_digest?) -%>
+  has_secure_password
+<% end -%>
+end
+<% end -%>

data/lib/generators/linked_rails/model/templates/module.rb.tt

@@ -0,0 +1,7 @@
+<% module_namespacing do -%>
+module <%= class_path.map(&:camelize).join('::') %>
+  def self.table_name_prefix
+    '<%= namespaced? ? namespaced_class_path.join('_') : class_path.join('_') %>_'
+  end
+end
+<% end -%>

data/lib/generators/linked_rails/model/templates/policy.rb.tt

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+<% module_namespacing do -%>
+class <%= class_name %>Policy < ApplicationPolicy
+end
+<% end -%>

data/lib/generators/linked_rails/model/templates/serializer.rb.tt

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+<% module_namespacing do -%>
+class <%= class_name %>Serializer < ApplicationSerializer
+<% attributes.each do |attribute| -%>
+    attribute :<%= attribute.name %>, predicate: LinkedRails.app_vocab[:<%= attribute.name %>]
+<% end -%>
+end
+<% end -%>

data/lib/linked_rails/active_response/controller/collections.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module ActiveResponse
+    module Controller
+      module Collections
+        private
+
+        def index_association; end
+
+        def index_includes
+          requested_resource.preview_includes
+        end
+
+        def index_iri
+          RDF::URI(request.original_url)
+        end
+
+        def index_meta
+          if requested_resource.is_a?(LinkedRails.collection_class) ||
+              requested_resource.is_a?(LinkedRails::Sequence) ||
+              index_association.nil?
+            return []
+          end
+
+          RDF::List.new(
+            graph: RDF::Graph.new,
+            subject: index_iri,
+            values: index_association.map(&:iri)
+          ).triples
+        end
+
+        def index_success_options_rdf
+          {
+            collection: requested_resource,
+            include: index_includes,
+            meta: index_meta
+          }
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/active_response/controller/crud_defaults.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module ActiveResponse
+    module Controller
+      module CrudDefaults
+        private
+
+        def clean_built_associations
+          current_resource!
+            .class
+            .try(:reflect_on_all_associations)
+            .select(&:collection?)
+            .each { |association| current_resource!.association(association.name).reset }
+        end
+
+        def create_execute
+          clean_built_associations
+          super
+        end
+
+        def create_success_options_rdf
+          opts = create_success_options
+          opts[:meta] = create_meta
+          opts
+        end
+
+        def create_meta
+          resource_added_delta(current_resource)
+        end
+
+        def current_resource_for_params
+          current_resource
+        end
+
+        def destroy_success_options_rdf
+          opts = destroy_success_options
+          opts[:meta] = destroy_meta
+          opts
+        end
+
+        def destroy_meta
+          resource_removed_delta(current_resource)
+        end
+
+        def preview_includes
+          current_resource.try(:preview_includes)
+        end
+
+        def requested_resource
+          @requested_resource ||= controller_class.try(
+            :requested_resource,
+            LinkedRails.iri_mapper.route_params_to_opts(params.dup),
+            user_context
+          )
+        end
+
+        def requested_resource!
+          requested_resource || raise(ActiveRecord::RecordNotFound)
+        end
+
+        def show_includes
+          current_resource.try(:show_includes)
+        end
+
+        def show_success_options_rdf
+          opts = show_success_options.except(:locals)
+          opts[:meta] = request.head? ? [] : show_meta
+          opts
+        end
+
+        def show_meta
+          []
+        end
+
+        def update_success_options_rdf
+          opts = update_success_options
+          opts[:meta] = update_meta
+          opts
+        end
+
+        def update_meta
+          changes_triples + changed_relations_triples
+        end
+
+        def user_context
+          current_user
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/active_response/controller/params.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module LinkedRails
+  module ActiveResponse
+    module Controller
+      module Params
+        private
+
+        def allow_empty_params?
+          false
+        end
+
+        def params_parser
+          @params_parser ||= LinkedRails::ParamsParser.new(params)
+        end
+
+        def parsed_filter_params
+          filters = params_parser.filter_params
+
+          ActionController::Parameters.new(controller_class.try(:attributes_from_filters, filters) || {})
+        end
+
+        def permit_filter_params
+          @permit_filter_params ||= parsed_filter_params.permit(*permit_param_keys)
+        end
+
+        def permit_params
+          @permit_params ||= resource_params.permit(*permit_param_keys)
+        end
+
+        def permit_param_key
+          controller_name.singularize
+        end
+
+        def permit_param_keys
+          @permit_param_keys ||= policy(current_resource_for_params).try(:permitted_attributes)
+        end
+
+        def permit_params_with_filters
+          permit_filter_params.merge(permit_params.to_h)
+        end
+
+        def resource_params
+          return ActionController::Parameters.new if !params.key?(permit_param_key) && allow_empty_params?
+
+          params.require(permit_param_key)
+        end
+      end
+    end
+  end
+end

data/lib/linked_rails/active_response/controller.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'pundit'
+
+require_relative 'controller/collections'
+require_relative 'controller/crud_defaults'
+require_relative 'controller/params'
+
+module LinkedRails
+  module Controller
+    include Pundit
+    include LinkedRails::ActiveResponse::Controller::Collections
+    include LinkedRails::ActiveResponse::Controller::CrudDefaults
+    include LinkedRails::ActiveResponse::Controller::Params
+
+    def _render_with_renderer_json(record, options)
+      self.content_type = Mime[:json]
+
+      return record if record.is_a?(String)
+      return record.to_json if record.is_a?(Hash)
+
+      serializer_opts = RDF::Serializers::Renderers.transform_opts(
+        options,
+        serializer_params
+      )
+
+      serializer = RDF::Serializers.serializer_for(record)&.new(record, serializer_opts)
+      return record.to_json unless serializer
+
+      Oj.dump(serializer.serializable_hash, mode: :compat)
+    end
+
+    def serializer_params
+      {}
+    end
+  end
+end

data/lib/linked_rails/active_response/responders/rdf.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+require 'active_response/responders/html'
+
+module LinkedRails
+  module ActiveResponse
+    module Responders
+      class RDF < ::ActiveResponse::Responders::HTML # rubocop:disable Metrics/ClassLength
+        respond_to(*LinkedRails::Renderers.rdf_content_types)
+
+        include LinkedRails::Helpers::OntolaActionsHelper
+
+        def collection(opts)
+          opts[:resource] = opts.delete(:collection)
+          controller.respond_with_resource opts
+        end
+
+        def destroyed(opts)
+          response_headers(opts)
+          if opts[:meta].present?
+            controller.render(format => [], location: opts[:location], meta: opts[:meta])
+          else
+            controller.head 200, location: opts[:location], content_type: content_type
+          end
+        end
+
+        def form(**opts)
+          response_headers(opts)
+          controller.respond_with_resource(
+            resource: opts[:action],
+            include: opts[:include],
+            meta: opts[:meta]
+          )
+        end
+
+        def invalid_resource(**opts)
+          response_headers(opts)
+          controller.respond_with_resource(
+            resource: nil,
+            meta: error_meta(opts[:resource]),
+            status: :unprocessable_entity
+          )
+        end
+
+        def new_resource(**opts)
+          opts[:status] = :created
+          controller.respond_with_resource(opts)
+        end
+
+        def redirect(**opts) # rubocop:disable Metrics/AbcSize
+          return super if controller.request.head?
+
+          response_headers(opts)
+          add_exec_action_header(
+            controller.response.headers,
+            ontola_redirect_action(opts[:location], reload: opts[:reload])
+          )
+          controller.head 200, content_type: content_type, location: opts[:location]
+        end
+
+        def resource(**opts) # rubocop:disable Metrics/AbcSize
+          response_headers(opts)
+
+          if (opts[:resource].blank? && opts[:meta].blank?) || head_request?
+            controller.head(opts[:status] || 200, location: opts[:location], content_type: content_type)
+          else
+            opts[format] = opts.delete(:resource) || []
+            controller.render opts
+          end
+        end
+
+        def updated_resource(**opts)
+          response_headers(opts)
+          if opts[:meta].present?
+            controller.render(format => [], meta: opts[:meta], location: opts[:location])
+          else
+            controller.head 200, location: opts[:location], content_type: content_type
+          end
+        end
+
+        private
+
+        def error_mapping(form_iri, error_object)
+          [
+            ::RDF::URI(form_iri),
+            Vocab.ll[:errorResponse],
+            error_object,
+            Vocab.ontola[:replace]
+          ]
+        end
+
+        def error_statements(iri, resource)
+          index = 0
+          resource.errors.messages.map do |key, values|
+            predicate = resource.class.predicate_for_key(key.to_s.split('.').first)
+            if predicate
+              error_statements_for(iri, predicate, values)
+            else
+              index += 1
+              unassigned_error_statements(resource, iri, index - 1, key, values)
+            end
+          end.compact.flatten(1)
+        end
+
+        def error_statements_for(iri, predicate, values)
+          values.map { |value| [iri, predicate, value.sub(/\S/, &:upcase)] }
+        end
+
+        def error_meta(resource)
+          form_iri = controller.request.headers['Request-Referrer']
+          return [] unless form_iri && resource.respond_to?(:errors)
+
+          error_object = ::RDF::Node.new
+          [
+            error_mapping(form_iri, error_object),
+            error_type(error_object),
+            error_status(error_object)
+          ] + error_statements(error_object, resource)
+        end
+
+        def error_type(error_object)
+          [
+            error_object,
+            Vocab.rdfv.type,
+            Vocab.ll[:ErrorResponse],
+            Vocab.ontola[:replace]
+          ]
+        end
+
+        def error_status(error_object)
+          [
+            error_object,
+            ::RDF::URI('http://www.w3.org/2011/http#statusCode'),
+            200,
+            Vocab.ll[:meta]
+          ]
+        end
+
+        def head_request?
+          controller.request.method == 'HEAD'
+        end
+
+        def response_headers(opts)
+          headers = controller.response.headers
+          add_exec_action_header(headers, ontola_snackbar_action(opts[:notice])) if opts[:notice].present?
+        end
+
+        def unassigned_error_statements(resource, iri, index, key, values)
+          error_statements_for(
+            iri,
+            ::RDF["_#{index}"],
+            values.map { |value| resource.errors.full_message(key, value) }
+          )
+        end
+      end
+    end
+  end
+end