elabs 3.0.0 → 4.0.0

data/app/helpers/elabs/acts_helper.rb

@@ -12,9 +12,9 @@ module Elabs
       actions[action.to_sym] || "[missing: #{action}]"
     end
 
-    def act_notice_string(act)
+    def act_notice_string(act, include_link = true)
       string = format('%<type>s #%<id>i', type: act.content_type.demodulize, id: act.content_id)
-      string = link_to string, act.content unless %w[unpublish destroy lock].include? act.event
+      string = link_to string, act.content unless %w[unpublish destroy lock].include?(act.event) || !include_link
 
       format(_('%<string>s has been %<event>s'), string: string, event: act_action(act.event)).html_safe
     end

data/app/helpers/elabs/application_helper.rb

@@ -1,5 +1,9 @@
 module Elabs
   module ApplicationHelper
+    def random_string(length = 5)
+      [*('a'..'z'), *('0'..'9')].shuffle[0, length].join
+    end
+
     def show_nsfw?
       session[:show_nsfw]
     end
@@ -19,17 +23,28 @@ module Elabs
       ).html_safe
     end
 
-    def boolean_icon_tag(value, true_icon = 'check', false_icon = 'times')
+    def boolean_icon_tag(value, true_icon = 'check', false_icon = 'times', false_class = '', true_class = '')
       icon_class = [
-        "fas fa-#{value ? true_icon : false_icon} fa-fw"
+        "fas fa-#{value ? true_icon : false_icon} fa-fw #{value ? true_class : false_class}"
       ]
       content_tag(:i, nil, class: icon_class)
     end
 
+    def colored_good_or_bad_icon_tag(value, true_icon = 'check', false_icon = 'times', false_is_good = false)
+      if false_is_good
+        false_class = 'is-success'
+        true_class  = 'is-danger'
+      else
+        false_class = 'is-danger'
+        true_class  = 'is-success'
+      end
+      boolean_icon_tag value, true_icon, false_icon, false_class, true_class
+    end
+
     def icon(name, classes = [], base = 'fas')
       icon_class = ["#{base} fa-#{name}"]
       icon_class += classes.map do |c|
-        if %w[2x 3x 4x fw].include? c
+        if %w[2x 3x 4x fw pulse spin].include? c
           "fa-#{c}"
         else
           c
@@ -50,5 +65,17 @@ module Elabs
 
       out.join('::')
     end
+
+    # @author viphe https://stackoverflow.com/users/437585/viphe
+    # This method yields a block.
+    def with_format(format)
+      old_formats = formats
+      begin
+        self.formats = [format]
+        return yield
+      ensure
+        self.formats = old_formats
+      end
+    end
   end
 end

data/app/helpers/elabs/content_helper.rb

@@ -1,9 +1,15 @@
 module Elabs
   module ContentHelper
     def show_online_link(entity)
-      link_to entity,
-              title: _('View online'),
-              class: 'btn btn--small btn--show' do
+      options = {
+        title: _('View online'),
+        class: 'btn btn--small btn--show'
+      }
+      if entity.respond_to?(:publicly_visible?) && !entity.publicly_visible?
+        options[:disabled] = true
+        return content_tag 'a', icon('eye', ['fw']), options
+      end
+      link_to entity, options do
         icon('eye', ['fw'])
       end
     end

data/app/helpers/elabs/content_renderer_helper.rb

@@ -1,13 +1,123 @@
 module Elabs
   module ContentRendererHelper
-    ALPHABET = ('a'..'z').to_a
-
-    def markdown(text)
-      area_id = Array.new(5) { ALPHABET.sample }.join
-      content = ''.html_safe
-      content += content_tag('pre', text, id: "raw-#{area_id}")
-      content += javascript_tag("renderMdFromId('#{area_id}')").html_safe
-      content_tag('div', content, id: "markdown-#{area_id}").html_safe
+    SHORT_CODES = {
+      /\[album:(\d+)\]/                                          => [:shortcode_album, { size: :inline }],
+      /\[article:(\d+)\]/                                        => [:shortcode_article, { size: :inline }],
+      /\[note:(\d+)\]/                                           => [:shortcode_note, { size: :inline }],
+      /\[project:(\d+)\]/                                        => [:shortcode_project, { size: :inline }],
+      /\[upload:(\d+)\]/                                         => [:shortcode_upload, { size: :inline }],
+      /\[user:(\d+)\]/                                           => [:shortcode_user, { size: :inline }],
+      /\[album-card:(\d+)\]/                                     => [:shortcode_album, { size: :large }],
+      /\[article-card:(\d+)\]/                                   => [:shortcode_article, { size: :large }],
+      /\[note-card:(\d+)\]/                                      => [:shortcode_note, { size: :large }],
+      /\[project-card:(\d+)\]/                                   => [:shortcode_project, { size: :large }],
+      /\[upload-card:(\d+)\]/                                    => [:shortcode_upload, { size: :large }],
+      /\[user-card:(\d+)\]/                                      => [:shortcode_user, { size: :large }],
+      %r{\[github-repo:([a-zA-Z0-9\-_]+/[a-zA-Z0-9\-_]+)\]}      => [:shortcode_github_repo_inline, { size: :inline }],
+      %r{\[github-repo-card:([a-zA-Z0-9\-_]+/[a-zA-Z0-9\-_]+)\]} => [:shortcode_github_repo, {}],
+      /\[github-user-card:([a-zA-Z0-9\-_]+)\]/                   => [:shortcode_github_user, {}],
+      %r{\[gitlab-repo:(https://.*)\]}                           => [:shortcode_gitlab_repo_inline, { size: :inline }],
+      %r{\[gitlab-repo-card:(https://.*)\]}                      => [:shortcode_gitlab_repo, {}],
+      %r{\[gitlab-user-card:(https://.*)\]}                      => [:shortcode_gitlab_user, {}],
+      %r{\[gitlab-group-card:(https://.*)\]}                     => [:shortcode_gitlab_group, {}]
+    }.freeze
+
+    def markdown(text, reference_entity = nil, show_short_codes = true)
+      process_short_codes CommonMarker.render_html(text, [:SAFE], [:table]).html_safe,
+                          reference_entity,
+                          show_short_codes
+    end
+
+    def render_entity_content(entity, field, show_short_codes = true)
+      markdown entity[field], entity, show_short_codes
+    end
+
+    def process_short_codes(text, original_entity = nil, display = true)
+      SHORT_CODES.each do |key, method|
+        text.gsub! key do |match|
+          if display || (method[1][:size] && method[1][:size] == :inline)
+            send(method[0], original_entity, match.sub(key, '\1'), method[1])
+          else
+            render(partial: 'elabs/layouts/shortcode_open_to_see') unless display
+          end
+        end
+      end
+      text.html_safe
+    end
+
+    private
+
+    def shortcode_album(original_entity, id, options = {})
+      shortcode_content 'album', original_entity, id, options
+    end
+
+    def shortcode_article(original_entity, id, options = {})
+      shortcode_content 'article', original_entity, id, options
+    end
+
+    def shortcode_note(original_entity, id, options = {})
+      shortcode_content 'note', original_entity, id, options
+    end
+
+    def shortcode_project(original_entity, id, options = {})
+      shortcode_content 'project', original_entity, id, options
+    end
+
+    def shortcode_upload(original_entity, id, options = {})
+      shortcode_content 'upload', original_entity, id, options
+    end
+
+    def shortcode_user(original_entity, id, options = {})
+      shortcode_content 'user', original_entity, id, options
+    end
+
+    def shortcode_content(type, original_entity, id, options = { size: :large })
+      model       = "Elabs::#{type.classify}".constantize
+      widget_size = case options[:size]
+                    when :inline
+                      '_inline'
+                    else
+                      ''
+                    end
+      return render "elabs/layouts/shortcode_infinite_loop#{widget_size}", format: :html if original_entity && original_entity.id == id.to_i && original_entity.class == model
+
+      entity = model.find_by(id: id)
+      return render "elabs/layouts/shortcode_missing_content#{widget_size}", format: :html unless entity
+
+      render partial: "elabs/#{type.pluralize}/#{type}#{widget_size}", locals: { type.to_sym => entity }, format: :html
+    end
+
+    def shortcode_github_repo(_original_entity, repo_url, _options = {})
+      render partial: 'elabs/layouts/widgets/github_repo_card', locals: { repo_url: repo_url }
+    end
+
+    def shortcode_github_repo_inline(_original_entity, repo_url, _options = {})
+      url_matches = %r{([a-zA-Z0-9\-_]+)/([a-zA-Z0-9\-_]+)}.match repo_url
+      render partial: 'elabs/layouts/widgets/github_repo_inline', locals: { url_matches: url_matches }
+    end
+
+    def shortcode_github_user(_original_entity, user_name, _options = {})
+      render partial: 'elabs/layouts/widgets/github_user_card', locals: { user_name: user_name }
+    end
+
+    def shortcode_gitlab_repo(_original_entity, repo_url, _options = {})
+      url_matches = %r{(?:https://)?([a-z0-9\-_\.]+)/(.+)}.match repo_url
+      render partial: 'elabs/layouts/widgets/gitlab_repo_card', locals: { url_matches: url_matches }
+    end
+
+    def shortcode_gitlab_repo_inline(_original_entity, repo_url, _options = {})
+      url_matches = %r{(.*)/([a-zA-Z0-9\-_]+)/([a-zA-Z0-9\-_]+)}.match repo_url
+      render partial: 'elabs/layouts/widgets/gitlab_repo_inline', locals: { url_matches: url_matches }
+    end
+
+    def shortcode_gitlab_user(_original_entity, user_url, _options = {})
+      url_matches = %r{(?:https://)?([a-z0-9\-_\.]*)/([a-zA-Z0-9\-_]+)}.match user_url
+      render partial: 'elabs/layouts/widgets/gitlab_user_card', locals: { url_matches: url_matches }
+    end
+
+    def shortcode_gitlab_group(_original_entity, group_url, _options = {})
+      url_matches = %r{(?:https://)?([a-z0-9\-_\.]*)/([a-zA-Z0-9\-_]+)}.match group_url
+      render partial: 'elabs/layouts/widgets/gitlab_group_card', locals: { url_matches: url_matches }
     end
   end
 end

data/app/helpers/elabs/rss_helper.rb

@@ -0,0 +1,9 @@
+module Elabs
+  module RssHelper
+    def rss_title(entity, field)
+      sfw      = entity.sfw ? '[SFW]' : '[NSFW]'
+      language = "[#{entity.language.iso639_1}]"
+      "#{language} #{sfw} - #{entity[field]}"
+    end
+  end
+end

data/app/helpers/elabs/thumbnails_helper.rb

@@ -1,13 +1,20 @@
 module Elabs
   module ThumbnailsHelper
-    def thumbnail_center_crop_properties(size = :medium)
-      dimensions = case size
-                   when :small
-                     '50x50'
-                   else
-                     '300x300' # medium size
-                   end
-      { gravity: 'Center', resize: "#{dimensions}^", extent: dimensions }
+    THUMBNAILS_DIMENSIONS = {
+      small:  '50x50',
+      medium: '300x300'
+    }.freeze
+
+    AVATAR_DIMENSIONS = {
+      large:  '512',
+      medium: '256',
+      small:  '64'
+    }.freeze
+
+    def thumbnail_center_crop(document, size = :medium)
+      return resize_and_center_crop(document, AVATAR_DIMENSIONS[size]) if document.representable?
+
+      thumbnail_preview_placeholder_file
     end
 
     def thumbnail_preview_placeholder_file
@@ -26,18 +33,16 @@ module Elabs
     end
 
     def avatar_image(avatar, size = :medium)
-      x           = avatar.blob.metadata[:width].to_f
-      y           = avatar.blob.metadata[:height].to_f
+      resize_and_center_crop avatar, AVATAR_DIMENSIONS[size]
+    end
+
+    def resize_and_center_crop(entity, size)
+      x           = entity.blob.metadata[:width].to_f
+      y           = entity.blob.metadata[:height].to_f
       bigger_size = x < y ? x : y
-      dimensions  = case size
-                    when :large
-                      '512'
-                    when :medium
-                      '256'
-                    when :small
-                      '64'
-                    end
-      avatar.variant(combine_options: { gravity: 'center', crop: "#{bigger_size}x#{bigger_size}+0+0", resize: dimensions.to_s }).processed
+
+      options = { combine_options: { gravity: 'center', crop: "#{bigger_size}x#{bigger_size}+0+0", resize: size.to_s } }
+      main_app.url_for(entity.representation(options).processed)
     end
   end
 end

data/app/helpers/elabs/time_helper.rb

@@ -20,7 +20,13 @@ module Elabs
     def short_date(date)
       return nil if date.nil?
 
-      I18n.l date, format: :short
+      I18n.l date.to_date, format: :default
+    end
+
+    def medium_datetime(date)
+      return nil if date.nil?
+
+      I18n.l date, format: :medium
     end
   end
 end

data/app/models/elabs/album.rb

@@ -2,12 +2,14 @@ module Elabs
   class Album < ApplicationContentRecord
     self.table_name = 'albums'
 
+    SLUGGABLE_FIELD = :name
     ADDITIONAL_HABTM_COUNTER_CACHES = [
       %w[projects albums]
     ].freeze
 
     validates :name,        presence: true
     validates :description, presence: true
+    validates :slug,        presence: true, uniqueness: true
     validates_with AssociatedAuthorValidator, relations: %w[project upload]
 
     belongs_to :user

data/app/models/elabs/application_content_record.rb

@@ -5,6 +5,9 @@ module Elabs
     include Elabs::Concerns::CountableEntity
     include Elabs::Concerns::NotifiableEntity
     include Elabs::Concerns::Taggable
+    include Elabs::Concerns::Sluggable
+
+    SLUG_FIELD = :slug
 
     self.abstract_class = true
   end

data/app/models/elabs/article.rb

@@ -2,6 +2,7 @@ module Elabs
   class Article < ApplicationContentRecord
     self.table_name = 'articles'
 
+    SLUGGABLE_FIELD = :title
     ADDITIONAL_HABTM_COUNTER_CACHES = [
       %w[projects articles]
     ].freeze
@@ -9,6 +10,7 @@ module Elabs
     validates :title,   presence: true
     validates :excerpt, presence: true
     validates :content, presence: true
+    validates :slug,    presence: true, uniqueness: true
     validates_with AssociatedAuthorValidator, relations: %w[project]
 
     belongs_to :user

data/app/models/elabs/concerns/actable_entity.rb

@@ -4,6 +4,9 @@ module Elabs
       extend ActiveSupport::Concern
 
       included do
+        attr_accessor :update_description
+        attr_reader :minor_update
+
         has_many :acts, as: :content
 
         before_save :update_acts?
@@ -12,10 +15,21 @@ module Elabs
         before_destroy :update_acts_on_delete
       end
 
+      def minor_update=(value)
+        @minor_update = ['t', '1', 1, true].include? value
+      end
+
+      def minor_update?
+        @minor_update || false
+      end
+
       private
 
       def update_acts?
-        @action = if changed.include?('published')
+        # byebug
+        @action = if minor_update?
+                    :nothing
+                  elsif changed.include?('published')
                     current_publish_action
                   elsif changed.include?('locked') && published?
                     current_lock_action
@@ -28,7 +42,8 @@ module Elabs
 
       def update_acts
         acts.destroy_all if %i[lock unpublish].include? @action
-        Act.create content: self, event: @action unless @action == :nothing || hidden_in_history
+        reason = update_description.nil? ? nil : update_description
+        Act.create content: self, event: @action, reason: reason unless @action == :nothing || hidden_in_history
       end
 
       # TODO: check if used ? (dependent: destroy may do the trick.)

data/app/models/elabs/concerns/content_entity.rb

@@ -80,8 +80,8 @@ module Elabs
       end
 
       class_methods do
-        def find_publicly_visible(id)
-          entity = where(id: id).published.first
+        def find_publicly_visible(slug)
+          entity = where(slug: slug).published.first
 
           raise ActiveRecord::RecordNotFound if entity.nil?
 

data/app/models/elabs/concerns/sluggable.rb

@@ -0,0 +1,40 @@
+module Elabs
+  module Concerns
+    # For this concern to work, a SLUGGABLE_FIELD constant should be declared in the model
+    module Sluggable
+      extend ActiveSupport::Concern
+
+      included do
+        before_validation :fill_slug, on: :create
+      end
+
+      def fill_slug
+        return unless self.class::SLUGGABLE_FIELD
+
+        slug       = make_slug_from_field
+        slug_field = self.class::SLUG_FIELD || :slug
+
+        same_slugs = self.class
+                         .where("#{slug_field} LIKE ?", "#{slug}%")
+                         .pluck(slug_field)
+                         .count { |r| r[/^#{slug}(-\d+)?$/] }
+
+        slug += "-#{same_slugs}" if same_slugs.positive?
+
+        self.slug = slug
+      end
+
+      def to_param
+        slug
+      end
+
+      private
+
+      def make_slug_from_field
+        return Time.new.strftime('%Y-%m-%d-%H-%M-%S') if self.class::SLUGGABLE_FIELD == :created_at
+
+        send(self.class::SLUGGABLE_FIELD).parameterize
+      end
+    end
+  end
+end

data/app/models/elabs/language.rb

@@ -1,6 +1,10 @@
 module Elabs
   class Language < ApplicationRecord
     self.table_name = 'languages'
+    include Elabs::Concerns::Sluggable
+
+    SLUGGABLE_FIELD = nil
+    SLUG_FIELD = :iso639_1
 
     validates :iso639_1, presence: true
     validates :name,     presence: true
@@ -14,5 +18,9 @@ module Elabs
     scope :with_content_only, -> { where.not(albums_count: 0).or(where.not(articles_count: 0)).or(where.not(notes_count: 0)).or(where.not(projects_count: 0)).or(where.not(uploads_count: 0)) }
     scope :available_site_translations, -> { select(:id, :name, :iso639_1).where(iso639_1: I18n.available_locales) }
     scope :for_list, -> { order(:name).pluck(:name, :id) }
+
+    def to_param
+      iso639_1
+    end
   end
 end