glib-web 0.5.75 → 0.5.76

data/app/helpers/glib/urls_helper.rb

@@ -1,12 +1,12 @@
-module Glib
-  module UrlsHelper
-    def glib_url_current(new_params)
-      url_for(params.to_unsafe_h.merge(new_params.merge(only_path: false)))
-    end
-
-    def glib_url_equals_current?(url)
-      route = Rails.application.routes.recognize_path(url)
-      route[:controller] == controller_name && route[:action] == action_name
-    end
-  end
-end
+module Glib
+  module UrlsHelper
+    def glib_url_current(new_params)
+      url_for(params.to_unsafe_h.merge(new_params.merge(only_path: false)))
+    end
+
+    def glib_url_equals_current?(url)
+      route = Rails.application.routes.recognize_path(url)
+      route[:controller] == controller_name && route[:action] == action_name
+    end
+  end
+end

data/app/models/concerns/glib/soft_deletable.rb

@@ -1,68 +1,68 @@
-module Glib
-  module SoftDeletable
-    extend ActiveSupport::Concern
-
-    included do
-      default_scope { where(deleted_at: nil) }
-      scope :with_deleted, -> { unscope(where: :deleted_at) }
-
-      # "Soft delete" - set deleted_at if it is nil, actually destroy the record
-      # if forced.
-      #
-      # @param force [Boolean]
-      def destroy(force = nil)
-        return force_destroy_record if force == :force
-        return self if deleted?
-
-        soft_destroy_record
-      end
-
-      # Revive a soft-deleted record and associated records if soft-deleted,
-      # otherwise return self
-      def revive
-        return self unless deleted?
-
-        ActiveRecord::Base.transaction do
-          update(deleted_at: nil)
-          revive_associated_records
-        end
-      end
-
-      # Whether or not a record is deleted
-      def deleted?
-        deleted_at.present?
-      end
-
-      private
-        def force_destroy_record
-          ActiveRecord::Base.transaction do
-            destroy_associated_records(:force)
-            method(:destroy).super_method.call
-          end
-        end
-
-        def soft_destroy_record
-          ActiveRecord::Base.transaction do
-            destroy_associated_records
-            update(deleted_at: Time.zone.now)
-          end
-        end
-
-        def destroy_associated_records(force = nil)
-          associated_records.each { |r| r.destroy(force) }
-        end
-
-        def revive_associated_records
-          associated_records.each(&:revive)
-        end
-
-        # This should return an array of all associated records of an object that
-        # should be soft deleted with it (i.e. those that have dependent: :destroy
-        # set). In principle we could figure this out automatically but in the
-        # interest of simplicity we'll just define it manually for each class.
-        def associated_records
-          []
-        end
-    end
-  end
-end
+module Glib
+  module SoftDeletable
+    extend ActiveSupport::Concern
+
+    included do
+      default_scope { where(deleted_at: nil) }
+      scope :with_deleted, -> { unscope(where: :deleted_at) }
+
+      # "Soft delete" - set deleted_at if it is nil, actually destroy the record
+      # if forced.
+      #
+      # @param force [Boolean]
+      def destroy(force = nil)
+        return force_destroy_record if force == :force
+        return self if deleted?
+
+        soft_destroy_record
+      end
+
+      # Revive a soft-deleted record and associated records if soft-deleted,
+      # otherwise return self
+      def revive
+        return self unless deleted?
+
+        ActiveRecord::Base.transaction do
+          update(deleted_at: nil)
+          revive_associated_records
+        end
+      end
+
+      # Whether or not a record is deleted
+      def deleted?
+        deleted_at.present?
+      end
+
+      private
+        def force_destroy_record
+          ActiveRecord::Base.transaction do
+            destroy_associated_records(:force)
+            method(:destroy).super_method.call
+          end
+        end
+
+        def soft_destroy_record
+          ActiveRecord::Base.transaction do
+            destroy_associated_records
+            update(deleted_at: Time.zone.now)
+          end
+        end
+
+        def destroy_associated_records(force = nil)
+          associated_records.each { |r| r.destroy(force) }
+        end
+
+        def revive_associated_records
+          associated_records.each(&:revive)
+        end
+
+        # This should return an array of all associated records of an object that
+        # should be soft deleted with it (i.e. those that have dependent: :destroy
+        # set). In principle we could figure this out automatically but in the
+        # interest of simplicity we'll just define it manually for each class.
+        def associated_records
+          []
+        end
+    end
+  end
+end

data/app/models/glib/active_storage/attachment.rb

@@ -1,9 +1,9 @@
-module Glib
-  module ActiveStorage
-    class Attachment < ::ActiveStorage::Attachment
-      if Glib::DynamicText::Config.database_url.present?
-        connects_to database: { writing: :dynamic_text, reading: :dynamic_text }
-      end
-    end
-  end
-end
+module Glib
+  module ActiveStorage
+    class Attachment < ::ActiveStorage::Attachment
+      if Glib::DynamicText::Config.database_url.present?
+        connects_to database: { writing: :dynamic_text, reading: :dynamic_text }
+      end
+    end
+  end
+end

data/app/models/glib/active_storage/blob.rb

@@ -1,9 +1,9 @@
-module Glib
-  module ActiveStorage
-    class Blob < ::ActiveStorage::Blob
-      if Glib::DynamicText::Config.database_url.present?
-        connects_to database: { writing: :dynamic_text, reading: :dynamic_text }
-      end
-    end
-  end
-end
+module Glib
+  module ActiveStorage
+    class Blob < ::ActiveStorage::Blob
+      if Glib::DynamicText::Config.database_url.present?
+        connects_to database: { writing: :dynamic_text, reading: :dynamic_text }
+      end
+    end
+  end
+end

data/app/models/glib/application_record.rb

@@ -1,18 +1,18 @@
-module Glib
-  class ApplicationRecord < ActiveRecord::Base
-    self.abstract_class = true
-
-    scope :created_asc, -> { order(created_at: :asc) }
-    scope :created_desc, -> { order(created_at: :desc) }
-
-    def glib_enum_humanize(enum_name, default_value = nil)
-      self.class.glib_enum_humanize(enum_name, send(enum_name), default_value)
-    end
-
-    def self.glib_enum_humanize(enum_name, enum_value, default_value = nil)
-      if enum_value
-        I18n.t("activerecord.attributes.#{model_name.i18n_key}.#{enum_name.to_s.pluralize}.#{enum_value}", default: default_value)
-      end
-    end
-  end
-end
+module Glib
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+
+    scope :created_asc, -> { order(created_at: :asc) }
+    scope :created_desc, -> { order(created_at: :desc) }
+
+    def glib_enum_humanize(enum_name, default_value = nil)
+      self.class.glib_enum_humanize(enum_name, send(enum_name), default_value)
+    end
+
+    def self.glib_enum_humanize(enum_name, enum_value, default_value = nil)
+      if enum_value
+        I18n.t("activerecord.attributes.#{model_name.i18n_key}.#{enum_name.to_s.pluralize}.#{enum_value}", default: default_value)
+      end
+    end
+  end
+end

data/app/models/glib/dynamic_text_record.rb

@@ -1,9 +1,9 @@
-module Glib
-  class DynamicTextRecord < ActiveRecord::Base
-    self.abstract_class = true
-
-    if Glib::DynamicText::Config.database_url.present?
-      connects_to database: { writing: :dynamic_text, reading: :dynamic_text }
-    end
-  end
-end
+module Glib
+  class DynamicTextRecord < ActiveRecord::Base
+    self.abstract_class = true
+
+    if Glib::DynamicText::Config.database_url.present?
+      connects_to database: { writing: :dynamic_text, reading: :dynamic_text }
+    end
+  end
+end

data/app/models/glib/text.rb

@@ -1,96 +1,96 @@
-module Glib
-  class Text < Glib::DynamicTextRecord
-    class << self
-      def dt_has_many_attached(name, dependent: :purge_later)
-        generated_association_methods.class_eval <<-CODE, __FILE__, __LINE__ + 1
-          def #{name}
-            @active_storage_attached_#{name} ||= ::ActiveStorage::Attached::Many.new("#{name}", self)
-          end
-
-          def #{name}=(attachables)
-            if ActiveStorage.replace_on_assign_to_many
-              attachment_changes["#{name}"] =
-                if Array(attachables).none?
-                  ::ActiveStorage::Attached::Changes::DeleteMany.new("#{name}", self)
-                else
-                  ::ActiveStorage::Attached::Changes::CreateMany.new("#{name}", self, attachables)
-                end
-            else
-              if Array(attachables).any?
-                attachment_changes["#{name}"] =
-                  ::ActiveStorage::Attached::Changes::CreateMany.new("#{name}", self, #{name}.blobs + attachables)
-              end
-            end
-          end
-        CODE
-
-        has_many :"#{name}_attachments", -> { where(name: name) }, as: :record, class_name: "Glib::ActiveStorage::Attachment", inverse_of: :record, dependent: :destroy do
-          def purge
-            each(&:purge)
-            reset
-          end
-
-          def purge_later
-            each(&:purge_later)
-            reset
-          end
-        end
-        has_many :"#{name}_blobs", through: :"#{name}_attachments", class_name: "Glib::ActiveStorage::Blob", source: :blob
-
-        scope :"with_attached_#{name}", -> { includes("#{name}_attachments": :blob) }
-
-        after_save { attachment_changes[name.to_s]&.save }
-
-        after_commit(on: %i[ create update ]) { attachment_changes.delete(name.to_s).try(:upload) }
-
-        ActiveRecord::Reflection.add_attachment_reflection(
-          self,
-          name,
-          ActiveRecord::Reflection.create(:has_many_attached, name, nil, { dependent: dependent }, self)
-        )
-      end
-    end
-
-    dt_has_many_attached :images
-
-    validates :scope, presence: true
-    validates :lang, presence: true
-    validates :key, presence: true, uniqueness: { scope: [:scope, :lang] }
-    validates :content, presence: true
-
-    after_save :update_to_redis
-
-    def self.redis
-      Glib::DynamicText::Config.redis
-    end
-
-    def self.get_content(key, default_value, options:)
-      scope_key = "#{options[:scope]}.#{options[:lang]}.#{key}"
-
-      content = redis.get(scope_key)
-      text = find_by(scope: options[:scope], lang: options[:lang], key: key)
-
-      if !(content && text)
-        if text = find_by(scope: options[:scope], lang: options[:lang], key: key)
-          update_content(scope_key, text.content)
-          content = text.content
-        else
-          text = create(scope: options[:scope], lang: options[:lang], key: key, content: default_value)
-          update_content(scope_key, default_value)
-          content = default_value
-        end
-      end
-
-      [content, text]
-    end
-
-    private
-      def self.update_content(scope_key, content)
-        redis.set(scope_key, content)
-      end
-
-      def update_to_redis
-        Glib::Text.update_content("#{scope}.#{lang}.#{key}", content)
-      end
-  end
+module Glib
+  class Text < Glib::DynamicTextRecord
+    class << self
+      def dt_has_many_attached(name, dependent: :purge_later)
+        generated_association_methods.class_eval <<-CODE, __FILE__, __LINE__ + 1
+          def #{name}
+            @active_storage_attached_#{name} ||= ::ActiveStorage::Attached::Many.new("#{name}", self)
+          end
+
+          def #{name}=(attachables)
+            if ActiveStorage.replace_on_assign_to_many
+              attachment_changes["#{name}"] =
+                if Array(attachables).none?
+                  ::ActiveStorage::Attached::Changes::DeleteMany.new("#{name}", self)
+                else
+                  ::ActiveStorage::Attached::Changes::CreateMany.new("#{name}", self, attachables)
+                end
+            else
+              if Array(attachables).any?
+                attachment_changes["#{name}"] =
+                  ::ActiveStorage::Attached::Changes::CreateMany.new("#{name}", self, #{name}.blobs + attachables)
+              end
+            end
+          end
+        CODE
+
+        has_many :"#{name}_attachments", -> { where(name: name) }, as: :record, class_name: "Glib::ActiveStorage::Attachment", inverse_of: :record, dependent: :destroy do
+          def purge
+            each(&:purge)
+            reset
+          end
+
+          def purge_later
+            each(&:purge_later)
+            reset
+          end
+        end
+        has_many :"#{name}_blobs", through: :"#{name}_attachments", class_name: "Glib::ActiveStorage::Blob", source: :blob
+
+        scope :"with_attached_#{name}", -> { includes("#{name}_attachments": :blob) }
+
+        after_save { attachment_changes[name.to_s]&.save }
+
+        after_commit(on: %i[ create update ]) { attachment_changes.delete(name.to_s).try(:upload) }
+
+        ActiveRecord::Reflection.add_attachment_reflection(
+          self,
+          name,
+          ActiveRecord::Reflection.create(:has_many_attached, name, nil, { dependent: dependent }, self)
+        )
+      end
+    end
+
+    dt_has_many_attached :images
+
+    validates :scope, presence: true
+    validates :lang, presence: true
+    validates :key, presence: true, uniqueness: { scope: [:scope, :lang] }
+    validates :content, presence: true
+
+    after_save :update_to_redis
+
+    def self.redis
+      Glib::DynamicText::Config.redis
+    end
+
+    def self.get_content(key, default_value, options:)
+      scope_key = "#{options[:scope]}.#{options[:lang]}.#{key}"
+
+      content = redis.get(scope_key)
+      text = find_by(scope: options[:scope], lang: options[:lang], key: key)
+
+      if !(content && text)
+        if text = find_by(scope: options[:scope], lang: options[:lang], key: key)
+          update_content(scope_key, text.content)
+          content = text.content
+        else
+          text = create(scope: options[:scope], lang: options[:lang], key: key, content: default_value)
+          update_content(scope_key, default_value)
+          content = default_value
+        end
+      end
+
+      [content, text]
+    end
+
+    private
+      def self.update_content(scope_key, content)
+        redis.set(scope_key, content)
+      end
+
+      def update_to_redis
+        Glib::Text.update_content("#{scope}.#{lang}.#{key}", content)
+      end
+  end
 end