deep_unrest 0.1.35 → 0.1.36

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5095cf1fc9c37e899a5dd31faf7c91f4a32abca7fd03eefccb7564d515df60d4
-  data.tar.gz: 9a1e1acb9f55ba94e5c706c44cce09e0ecd25dcca2763d9761954eca09e2f603
+  metadata.gz: 49fe70a86a480793222a007af3de245afc7d2bba795d3e42ba0f2e74a5791c3b
+  data.tar.gz: 64ac3b1ffcb724b5bd5b8c15c37143da18241685cc36f76b3a7e63d9c568b461
 SHA512:
-  metadata.gz: a070c77b4b55d24535fc0047f30ca8f8663a232eb02dc7e226ea10458fbfb3ada8a002ad261118286f1b403de71b790b8b9cfec95334eae0beb012870dd4210e
-  data.tar.gz: e3af192ce56ed378e9ce197f104065079e21fd5a7ea3ae097d2b2d2298893f6360636d7db850e48c5ee78d66ec7fe7cd0d2585c100e3cad2d9ed69b4ad7d02c3
+  metadata.gz: 5b824d05e3a002abd22057c337c6b5b948c9c54c92c148873bf4239aa47a5319bcf68dd212d9dbb3dc9093addda891a3e2bc17329677e8ae05fee5c9a245b451
+  data.tar.gz: eb20d4d68c51fb7bb383f1e34996841195f1c44a880e2348f839c39968048032a1b2bccabfe3d1738af5e31a92f3e11a5ac84f39371182ac8d1116e1dc02ad62

data/app/controllers/deep_unrest/application_controller.rb

@@ -4,8 +4,11 @@ module DeepUnrest
   class ApplicationController < ActionController::API
     include DeepUnrest.authentication_concern
 
+    around_action :allow_nested_arrays, only: :update
+
     @@temp_ids = {}
     @@destroyed_entities = []
+    @@changed_entities = []
 
     def context
       { current_user: current_user }
@@ -38,7 +41,32 @@ module DeepUnrest
       instance_eval &DeepUnrest.before_read if DeepUnrest.before_read
 
       results = DeepUnrest.perform_read(context, data, current_user)
-      render json: results, status: 200
+      render json: results, status: :ok
+    rescue DeepUnrest::Unauthorized => err
+      render json: err.message, status: :forbidden
+    rescue DeepUnrest::UnpermittedParams => err
+      render json: err.message, status: :method_not_allowed
+    end
+
+    def write
+      repaired_params = params[:data]
+      data = repaired_params[:data]
+      context = repaired_params[:context] || {}
+      context[:uuid] = request.uuid
+      context[:current_user] = current_user
+
+      instance_eval &DeepUnrest.before_update if DeepUnrest.before_update
+
+      results = DeepUnrest.perform_write(context, data, current_user)
+      render json: results, status: :ok
+    rescue DeepUnrest::Unauthorized => err
+      render json: err.message, status: :forbidden
+    rescue DeepUnrest::UnpermittedParams => err
+      render json: err.message, status: :method_not_allowed
+    rescue DeepUnrest::Conflict => err
+      render json: err.message, status: :conflict
+    ensure
+      @@temp_ids.delete(request.uuid)
     end
 
     def update
@@ -46,23 +74,26 @@ module DeepUnrest
       context = allowed_write_params[:data][:context] || {}
       context[:uuid] = request.uuid
       context[:current_user] = current_user
-      data = repair_nested_params(allowed_write_params)[:data][:data]
+      data = repair_nested_params(params)[:data][:data]
 
       instance_eval &DeepUnrest.before_update if DeepUnrest.before_update
 
-      results = DeepUnrest.perform_update(context, data)
+      results = DeepUnrest.perform_update(context, data, current_user)
       resp = { destroyed: results[:destroyed],
+               changed: results[:changed],
                tempIds: results[:temp_ids] }
       resp[:redirect] = results[:redirect_regex].call(redirect) if redirect
-      render json: resp, status: 200
+      render json: resp, status: :ok
     rescue DeepUnrest::Unauthorized => err
-      render json: err.message, status: 403
+      render json: err.message, status: :forbidden
     rescue DeepUnrest::UnpermittedParams => err
-      render json: err.message, status: 405
+      render json: err.message, status: :method_not_allowed
     rescue DeepUnrest::Conflict => err
-      render json: err.message, status: 409
+      render json: err.message, status: :conflict
     ensure
       @@temp_ids.delete(request.uuid)
+      @@destroyed_entities.clear
+      @@changed_entities.clear
     end
 
     def current_user
@@ -76,5 +107,11 @@ module DeepUnrest
                                   :errorPath,
                                   { attributes: {} }]])
     end
+
+    def allow_nested_arrays
+      ::ActionController::Parameters::PERMITTED_SCALAR_TYPES << Array
+      yield
+      ::ActionController::Parameters::PERMITTED_SCALAR_TYPES - [Array]
+    end
   end
 end

data/config/routes.rb

@@ -1,4 +1,5 @@
 DeepUnrest::Engine.routes.draw do
   patch 'update', to: 'application#update'
   get 'read', to: 'application#read'
+  patch 'write', to: 'application#write'
 end

data/lib/deep_unrest/authorization/pundit_strategy.rb

@@ -31,12 +31,17 @@ module DeepUnrest
       def self.get_entity_authorization(scope, user)
         if %i[create update_all index destroy_all].include?(scope[:scope_type])
           target = scope[:klass]
-        else
+        elsif scope[:scope]
+          # TODO: deprecate this part of the clause following write endpoint refactor
           target = scope[:scope][:base].send(scope[:scope][:method],
                                              *scope[:scope][:arguments])
+        else
+          target = scope[:klass].find(scope[:query][:id])
         end
 
         Pundit.policy!(user, target).send(get_policy_name(scope[:scope_type]))
+      rescue Pundit::NotDefinedError
+        false
       end
 
       def self.authorize(scopes, user)

data/lib/deep_unrest/concerns/map_temp_ids.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module DeepUnrest
   module Concerns
     module MapTempIds
@@ -5,9 +7,15 @@ module DeepUnrest
 
       included do
         attr_accessor :deep_unrest_context
+        attr_accessor :deep_unrest_query_uuid
         attr_accessor :deep_unrest_temp_id
         after_create :map_temp_id
         after_destroy :track_destruction
+        after_save :track_changes
+      end
+
+      def pk
+        send self.class.primary_key
       end
 
       def map_temp_id
@@ -15,7 +23,7 @@ module DeepUnrest
           '@@temp_ids'
         )
         return unless temp_id_map && @deep_unrest_temp_id
-        temp_id_map[@deep_unrest_context][@deep_unrest_temp_id] = id
+        temp_id_map[@deep_unrest_context][@deep_unrest_temp_id] = pk
       end
 
       # the client needs to know which items were destroyed so it can clean up
@@ -27,10 +35,31 @@ module DeepUnrest
         return unless destroyed
         destroyed << {
           type: self.class.to_s.pluralize.camelize(:lower),
-          id: id,
+          id: pk,
           destroyed: true
         }
       end
+
+      # the client needs to know which items were charged so it can keep its
+      # local sync in store with the db
+      def track_changes
+        changed = DeepUnrest::ApplicationController.class_variable_get(
+          '@@changed_entities'
+        )
+        return unless changed && saved_changes?
+        changed << {
+          klass: self.class,
+          id: pk,
+          attributes: attribute_diff,
+          query_uuid: @deep_unrest_query_uuid
+        }
+      end
+
+      def attribute_diff
+        saved_changes.each_with_object({}) do |(attr_name, (_old, val)), diff|
+          diff[attr_name] = val
+        end
+      end
     end
   end
 end

data/lib/deep_unrest/read.rb

@@ -2,10 +2,6 @@
 
 module DeepUnrest
   module Read
-    # def self.map_included(params, addr)
-    # params[:include].map { |k, v| create_read_mappings({ "#{k}": v }, [*addr, :include]) }
-    # end
-
     def self.create_read_mappings(params, addr = [])
       return unless params
       params.map do |k, v|
@@ -19,7 +15,7 @@ module DeepUnrest
            addr: resource_addr,
            key: k.camelize(:lower),
            uuid: uuid,
-           query: deep_underscore_keys(v) },
+           query: DeepUnrest.deep_underscore_keys(v) },
          *create_read_mappings(v[:include], [*resource_addr, :include])]
       end.flatten.compact
     end
@@ -28,31 +24,9 @@ module DeepUnrest
       str.pluralize == str && str.singularize != str
     end
 
-    def self.serialize_result(ctx, item)
-      JSONAPI::ResourceSerializer.new(item[:resource],
-                                      fields: {
-                                        "#{item[:key].pluralize}": item[:query][:fields].map(&:underscore).map(&:to_sym)
-                                      }).serialize_to_hash(item[:resource].new(item[:record], ctx))[:data]
-    end
-
     def self.serialize_results(ctx, data)
       data.each do |item|
-        item[:serialized_result] = serialize_result(ctx, item)
-      end
-    end
-
-    def self.deep_underscore_keys(query)
-      query.deep_transform_keys! do |key|
-        k = begin
-              key.to_s.underscore
-            rescue StandardError
-              key
-            end
-        begin
-          k.to_sym
-        rescue StandardError
-          key
-        end
+        item[:serialized_result] = DeepUnrest.serialize_result(ctx, item)
       end
     end
 
@@ -184,53 +158,24 @@ module DeepUnrest
       [included, meta]
     end
 
-    def self.set_attr(hash, path, val, cursor = nil)
-      cursor ||= hash
-      key = path.shift
-
-      if path.empty?
-        case cursor
-        when Array
-          cursor << val
-        when Hash
-          cursor[key] = val
-        end
-        return hash
-      end
-
-      next_cursor = case key
-                    when /\[\]$/
-                      cursor[key.gsub('[]', '')] ||= []
-                    else
-                      cursor[key] ||= {}
-                    end
-
-      set_attr(hash, path, val, next_cursor)
-    end
 
     def self.format_response(mappings)
       response = {}
       mappings.each do |mapping|
-        set_attr(response, mapping[:addr], mapping[:serialized_result])
+        DeepUnrest.set_attr(response, mapping[:addr], mapping[:serialized_result])
       end
       response
     end
 
-    def self.collect_authorized_scopes(mappings, user)
-      mappings.each do |mapping|
-        mapping[:scope] = DeepUnrest.authorization_strategy.get_authorized_scope(user, mapping[:klass])
-      end
-    end
-
     def self.read(ctx, params, user)
       # create mappings for assembly / disassembly
       mappings = create_read_mappings(params.to_unsafe_h)
 
       # authorize user for requested scope(s)
-      DeepUnrest.authorization_strategy.authorize(mappings, user).flatten
+      DeepUnrest.authorization_strategy.authorize(mappings, user)
 
       # collect authorized scopes
-      collect_authorized_scopes(mappings, user)
+      DeepUnrest.collect_authorized_scopes(mappings, user)
 
       # read data
       data, meta = execute_queries(mappings)

data/lib/deep_unrest/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeepUnrest
-  VERSION = '0.1.35'
+  VERSION = '0.1.36'
 end

data/lib/deep_unrest/write.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+
+module DeepUnrest
+  module Write
+    def self.get_scope_type(item)
+      return :destroy if item[:destroy]
+      return :show if item[:readOnly] || item[:attributes].blank?
+      return :create if item[:id] && DeepUnrest.temp_id?(item[:id].to_s)
+      :update
+    end
+
+    def self.create_write_mappings(params, addr = [])
+      return unless params
+      params.map do |k, v|
+        resource_addr = [*addr, k]
+        uuid = SecureRandom.uuid
+        v[:uuid] = uuid
+        [{ klass: k.singularize.classify.constantize,
+           policy: "#{k.singularize.classify}Policy".constantize,
+           resource: "#{k.singularize.classify}Resource".constantize,
+           scope_type: get_scope_type(v),
+           addr: resource_addr,
+           key: k.camelize(:lower),
+           uuid: uuid,
+           query: DeepUnrest.deep_underscore_keys(v) },
+         *create_write_mappings(v[:included], [*resource_addr, :include])]
+      end.flatten.compact
+    end
+
+    def self.append_ar_paths(mappings)
+      mappings.each do |item|
+        item[:ar_addr] = []
+        item[:addr].each_with_index do |segment, i|
+          next if segment == :include
+          item[:ar_addr] << if item[:addr][i - 1] == :include
+                              "#{segment}_attributes".to_sym
+                            else
+                              segment
+                            end
+        end
+      end
+    end
+
+    def self.authorize_attributes(mappings, ctx)
+      unauthorized_items = []
+
+      mappings.reject { |m| m[:scope_type] == :show }
+              .reject { |m| m[:destroy] }
+              .each do |item|
+        attributes = item.dig(:query, :attributes) || {}
+        resource = item[:resource]
+        p = JSONAPI::RequestParser.new
+        p.resource_klass = resource
+        opts = if item[:scope_type] == :create
+                 resource.creatable_fields(ctx)
+               else
+                 resource.updatable_fields(ctx)
+               end
+
+        p.parse_params({ attributes: attributes }, opts)[:attributes]
+      rescue JSONAPI::Exceptions::ParameterNotAllowed
+        unpermitted_keys = attributes.keys.map(&:to_sym) - opts
+        item[:errors] = unpermitted_keys.each_with_object({}) do |attr_key, memo|
+          memo[attr_key] = 'Unpermitted parameter'
+        end
+        unauthorized_items << item
+      end
+
+      return if unauthorized_items.blank?
+
+      msg = serialize_errors(unauthorized_items)
+      raise DeepUnrest::UnpermittedParams, msg
+    end
+
+    def self.build_mutation_bodies(mappings)
+      mappings.reject { |m| m[:scope_type] == :show }
+              .each_with_object({}) do |item, memo|
+        # TODO: use pkey instead of "id"
+        next_attrs = item.dig(:query, :attributes || {})
+                         .deep_symbolize_keys
+        update_body = { id: item.dig(:query, :id),
+                        deep_unrest_query_uuid: item.dig(:query, :uuid),
+                        **next_attrs }
+        update_body[:_destroy] = true if item[:scope_type] == :destroy
+        DeepUnrest.set_attr(memo, item[:ar_addr].clone, update_body)
+
+        item[:mutate] = memo.fetch(*item[:ar_addr]) if item[:ar_addr].size == 1
+      end
+    end
+
+    def self.execute_queries(mappings, context)
+      ActiveRecord::Base.transaction do
+        mappings.select { |m| m[:mutate] }.map do |item|
+          record = case item[:scope_type]
+                   when :update
+                     model = item[:klass].find(item.dig(:query, :id))
+                     model.assign_attributes(item[:mutate])
+                     resource = item[:resource].new(model, context)
+                     resource.run_callbacks :save do
+                       resource.run_callbacks :update do
+                         model.save
+                         model
+                       end
+                     end
+                   when :create
+                     model = item[:klass].new(item[:mutate])
+                     resource = item[:resource].new(model, context)
+                     resource.run_callbacks :save do
+                       resource.run_callbacks :create do
+                         resource._model.save
+                         resource._model
+                       end
+                     end
+                   when :destroy
+                     model = item[:klass].find(id)
+                     resource = item[:resource].new(model, context)
+                     resource.run_callbacks :remove do
+                       item[:klass].destroy(id)
+                     end
+                   end
+
+          result = { record: record }
+          if item[:temp_id]
+            result[:temp_ids] = {}
+            result[:temp_ids][item[:temp_id]] = record.id
+          end
+          result
+        end
+      end
+    end
+
+    def self.serialize_changes(ctx, mappings, changed)
+      changed.select { |c| c[:query_uuid] }
+             .each_with_object({}) do |c, memo|
+               mapping = mappings.find { |m| m.dig(:query, :uuid) == c[:query_uuid] }
+               mapping[:query][:fields] = c[:attributes].keys
+               mapping[:record] = c[:klass].new(id: c[:id])
+               mapping[:record].assign_attributes(c[:attributes])
+               result = DeepUnrest.serialize_result(ctx, mapping)
+               DeepUnrest.set_attr(memo, mapping[:addr], result)
+             end
+    end
+
+    def self.serialize_errors(mappings)
+      { errors: mappings.each_with_object({}) do |item, memo|
+        err = {
+          id: item.dig(:query, :id),
+          type: item.dig(:query, :type),
+          attributes: item[:errors,]
+        }
+        DeepUnrest.set_attr(memo, [*item[:addr]], err)
+      end }.to_json
+    end
+
+    def self.write(ctx, params, user)
+      temp_id_map = DeepUnrest::ApplicationController.class_variable_get(
+        '@@temp_ids'
+      )
+
+      # create mappings for assembly / disassembly
+      mappings = create_write_mappings(params.to_unsafe_h)
+
+      # authorize user for requested scope(s)
+      DeepUnrest.authorization_strategy.authorize(mappings, user)
+
+      authorize_attributes(mappings, ctx)
+
+      # collect authorized scopes
+      # DeepUnrest.collect_authorized_scopes(mappings, user)
+      append_ar_paths(mappings)
+
+      # bulid update arguments
+      build_mutation_bodies(mappings)
+
+      # convert temp_ids from ids to non-activerecord attributes
+      DeepUnrest.convert_temp_ids!(ctx[:uuid], mappings)
+
+      # save data, run callbaks
+      results = execute_queries(mappings, ctx)
+
+      # check results for errors
+      errors = results.map { |res| DeepUnrest.format_error_keys(res) }
+                      .compact
+                      .reject(&:empty?)
+                      .compact
+
+      if errors.empty?
+        destroyed = DeepUnrest::ApplicationController.class_variable_get(
+          '@@destroyed_entities'
+        )
+
+        changed = DeepUnrest::ApplicationController.class_variable_get(
+          '@@changed_entities'
+        )
+
+        return {
+          temp_ids: temp_id_map[ctx[:uuid]],
+          destroyed: destroyed,
+          changed: serialize_changes(ctx, mappings, changed)
+        }
+      end
+
+      # map errors to their sources
+      formatted_errors = { errors: map_errors_to_param_keys(scopes, errors) }
+
+      # raise error if there are any errors
+      raise DeepUnrest::Conflict, formatted_errors.to_json
+    end
+  end
+end

data/lib/deep_unrest.rb

@@ -2,6 +2,7 @@
 
 require 'deep_unrest/engine'
 require 'deep_unrest/read'
+require 'deep_unrest/write'
 
 # workaronud for rails bug with association indices.
 # see https://github.com/rails/rails/pull/24728
@@ -15,7 +16,7 @@ module ActiveRecord
                                                new_record,
                                                autosave)
       if new_record || autosave
-        association && association.target
+        association&.target
       else
         association.target.find_all(&:new_record?)
       end
@@ -167,7 +168,7 @@ module DeepUnrest
            end
 
     p.parse_params({ attributes: attributes }, opts)[:attributes]
-  rescue JSONAPI::Exceptions::ParametersNotAllowed
+  rescue JSONAPI::Exceptions::ParameterNotAllowed
     unpermitted_keys = attributes.keys.map(&:to_sym) - opts
     msg = "Attributes #{unpermitted_keys} of #{type.classify} not allowed"
     msg += " to #{user.class} with id '#{user.id}'" if user
@@ -213,6 +214,7 @@ module DeepUnrest
 
   def self.parse_id(id_str)
     return false if id_str.nil?
+    return id_str if id_str.is_a? Integer
     id_match = id_str.match(/^\.?(?<id>[\w\-]+)$/)
     id_match && id_match[:id]
   end
@@ -368,10 +370,34 @@ module DeepUnrest
     (non_dupes + merged).flatten
   end
 
+  def self.set_attr(hash, path, val, cursor = nil)
+    cursor ||= hash
+    key = path.shift
+
+    if path.empty?
+      case cursor
+      when Array
+        cursor << val
+      when Hash
+        cursor[key] = val
+      end
+      return hash
+    end
+
+    next_cursor = case key
+                  when /\[\]$/
+                    cursor[key.gsub('[]', '')] ||= []
+                  else
+                    cursor[key] ||= {}
+                  end
+
+    set_attr(hash, path, val, next_cursor)
+  end
+
   def self.build_mutation_body(ops, scopes, user)
     err_path_memo = {}
     ops.each_with_object(HashWithIndifferentAccess.new({})) do |op, memo|
-      memo.deep_merge!(build_mutation_fragment(op, scopes, user, err_path_memo)) do |key, a, b|
+      memo.deep_merge!(build_mutation_fragment(op, scopes, user, err_path_memo)) do |_key, a, b|
         if a.is_a? Array
           combine_arrays(a, b)
         else
@@ -516,7 +542,43 @@ module DeepUnrest
     DeepUnrest::Read.read(ctx, params, user)
   end
 
-  def self.perform_update(ctx, params)
+  def self.perform_write(ctx, params, user)
+    DeepUnrest::Write.write(ctx, params, user)
+  end
+
+  def self.serialize_changes(diffs, user)
+    ctx = { current_user: user }
+    diffs.each do |diff|
+      diff[:resource] = diff[:attributes]
+      pk = diff[:klass].primary_key
+      diff[:resource][pk] = diff[:id]
+      diff[:model] = diff[:klass].new(diff[:resource])
+    end
+
+    allowed_models = diffs.select do |diff|
+      scope = DeepUnrest.authorization_strategy
+                        .get_authorized_scope(user,
+                                              diff[:klass])
+      scope.exists?(diff[:id])
+    rescue NameError
+      false
+    end
+
+    resources = allowed_models.map do |diff|
+      resource_klass = get_resource(diff[:klass].to_s)
+      fields = {}
+      keys = diff[:resource].keys.map(&:to_sym)
+      fields[to_assoc(diff[:klass].to_s.pluralize)] = keys
+
+      JSONAPI::ResourceSerializer.new(
+        resource_klass,
+        fields: fields
+      ).serialize_to_hash(resource_klass.new(diff[:model], ctx))[:data]
+    end
+    resources.select { |item| item.dig('attributes') }.compact
+  end
+
+  def self.perform_update(ctx, params, user)
     temp_id_map = DeepUnrest::ApplicationController.class_variable_get(
       '@@temp_ids'
     )
@@ -556,10 +618,18 @@ module DeepUnrest
       destroyed = DeepUnrest::ApplicationController.class_variable_get(
         '@@destroyed_entities'
       )
+
+      changed = DeepUnrest::ApplicationController.class_variable_get(
+        '@@changed_entities'
+      )
+
+      diff = serialize_changes(changed, user)
+
       return {
         redirect_regex: build_redirect_regex(temp_id_map[uuid]),
         temp_ids: temp_id_map[uuid],
-        destroyed: destroyed
+        destroyed: destroyed,
+        changed: diff
       }
     end
 
@@ -569,4 +639,38 @@ module DeepUnrest
     # raise error if there are any errors
     raise Conflict, formatted_errors.to_json unless formatted_errors.empty?
   end
+
+  ### SHARED ###
+  def self.deep_underscore_keys(query)
+    query.deep_transform_keys! do |key|
+      k = begin
+            key.to_s.underscore
+          rescue StandardError
+            key
+          end
+      begin
+        k.to_sym
+      rescue StandardError
+        key
+      end
+    end
+  end
+
+  def self.collect_authorized_scopes(mappings, user)
+    mappings.each do |mapping|
+      mapping[:scope] = DeepUnrest.authorization_strategy.get_authorized_scope(user, mapping[:klass])
+    end
+  end
+
+  def self.serialize_result(ctx, item)
+    # item[:resource].exclude_links :none
+    resource_instance = item[:resource].new(item[:record], ctx)
+    JSONAPI::ResourceSerializer.new(
+      item[:resource],
+      fields: {
+        "#{item[:key].pluralize}": item[:query][:fields].map(&:underscore)
+                                                        .map(&:to_sym)
+      }
+    ).serialize_to_hash(resource_instance)[:data]
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deep_unrest
 version: !ruby/object:Gem::Version
-  version: 0.1.35
+  version: 0.1.36
 platform: ruby
 authors:
 - Lynn Hurley
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-02 00:00:00.000000000 Z
+date: 2019-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -151,6 +151,7 @@ files:
 - lib/deep_unrest/paginators/basic.rb
 - lib/deep_unrest/read.rb
 - lib/deep_unrest/version.rb
+- lib/deep_unrest/write.rb
 - lib/tasks/deep_unrest_tasks.rake
 homepage: https://github.com/graveflex/deep_unrest
 licenses: