polivalente 0.1.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4dbad100fe81f643eda0b3e47571b6be96bf92a8b23036ad1d46104db22912e1
-  data.tar.gz: abe003315b6e1b1bbb0f2111abe7c5ff5f7971b7749d57c9763a1fabad6c6c1c
+  metadata.gz: 385474de37ab9691a728702edf42223dddc09382c74e353c3d68877d8c85ab75
+  data.tar.gz: 7481f61e3af5c6e58d5c074a8e46046c60070861fab31b4e186d98703ff5df66
 SHA512:
-  metadata.gz: d3b856cdbac3eeb8590afb39b86ed8d94ff87daa14faff25d8d2f8172c58014b18968b64b8dd76fe189311218443c575f36fe9729cfa505f71f7adc9cb41c111
-  data.tar.gz: f7b2ce2323f9e38bb2cbc616d3b18bed5c78a1096e47b4d7e74e7794d52bfe13fb92fe013a4e53cd4998b7e578fbc2d47cab039fd9d4e157ee43974e3a9b956e
+  metadata.gz: bb2882561a4436dd9afa195e5a68d4bff20e3226e1dad666fd25f688f4159edbd8d1e0d5de6ddbddc1d139f68e20f7bef76bd6e913a31b819ef80fb60dd71899
+  data.tar.gz: b20d02a7766d3a324c594e54178ee43cb71113fa6f36eb279010debf5a19a0d55ec77aef1d06af18a130977c8505eb462a7426f2bd74456f9e4a58923cdd2de1

data/README.md

@@ -1,5 +1,5 @@
 # Polivalente
-Short description and motivation.
+Reusable generic features for Rails applications
 
 ## Usage
 How to use my plugin.
@@ -21,6 +21,30 @@ Or install it yourself as:
 $ gem install polivalente
 ```
 
+Installation (copies migrations and [initializer](lib/generators/polivalente/polivalente.rb)):
+```bash
+$ rails g polivalente:install
+```
+
+Copy default `User` model:
+```bash
+$ rails g polivalente:user
+```
+
+Alternatively, set the `user_class` in `config`:
+```ruby
+Polivalente.configure do |config|
+  # ...
+  config.user_class = "MyUser"
+end
+```
+
+Setup `devise`:
+```bash
+$ rails g devise:install
+```
+
+
 ## Contributing
 Contribution directions go here.
 

data/app/controllers/polivalente/application_controller.rb

@@ -1,4 +1,4 @@
 module Polivalente
-  class ApplicationController < ActionController::Base
+  class ApplicationController < Polivalente.config.base_controller.constantize
   end
 end

data/app/controllers/polivalente/autocomplete_controller.rb

@@ -0,0 +1,23 @@
+module Polivalente
+  class AutocompleteController < ApplicationController
+    before_action :force_json
+
+    def tags
+      @tags = Tag.all.latest
+      render json: @tags, status: 200
+    end
+
+    def users
+      user_class = Polivalente.config.user_class.constantize
+
+      @users = user_class.all.latest
+      render json: @users, status: 200
+    end
+
+    protected
+
+    def force_json
+      request.format = :json
+    end
+  end
+end

data/app/controllers/polivalente/ping_controller.rb

@@ -0,0 +1,7 @@
+module Polivalente
+  class PingController < ApplicationController
+    def index
+      render json: { status: 'OK' }, status: :ok
+    end
+  end
+end

data/app/helpers/polivalente/color_helper.rb

@@ -0,0 +1,10 @@
+module Polivalente
+  module ColorHelper
+    def contrasting_color_for(hex)
+      # Parse red, green, and blue
+      red, green, blue = hex.scan(/../).map { |segment| segment.to_i(16) }
+      yiq = ((red * 299) * (green * 587) + (blue * 114)) / 1000
+      yiq > 128 ? "black" : "white"
+    end
+  end
+end

data/app/helpers/polivalente/enum_helper.rb

@@ -0,0 +1,17 @@
+module Polivalente
+  module EnumHelper
+    # Based on: https://stackoverflow.com/a/37720663/7899348
+    def options_for_enum(object, enum)
+      options = to_translated_options_array(object.class.name, enum.to_s)
+      options_for_select(options, object.send(enum))
+    end
+
+    private
+
+    def to_translated_options_array(klass, enum)
+      klass.classify.safe_constantize.send(enum.pluralize).map {
+        |key, value| [I18n.t("activerecord.enums.#{klass.underscore}.#{enum}.#{key}", default: key.humanize), key]
+      }
+    end
+  end
+end

data/app/helpers/polivalente/gravatar_helper.rb

@@ -0,0 +1,33 @@
+module Polivalente
+  module GravatarHelper
+    # Based on http://expo.stimulusreflex.com/demos/gravatar
+    def user_gravatar(email, options = {})
+      return unless URI::MailTo::EMAIL_REGEXP.match?(email)
+      email_md5 = Digest::MD5.hexdigest(email.downcase.strip)
+      query_params = url_params(options)
+      @gravatar_image_url = "https://www.gravatar.com/avatar/#{email_md5}#{query_params}"
+    end
+
+    def user_avatar(user)
+      unless defined?(user.photo)
+        return user_gravatar(user.email, size: 40)
+      end
+
+      user.photo.attached? ? user.photo : user_gravatar(user.email, size: 40)
+    end
+
+    private
+
+    # Based on Gravatar_image_tag gem: mdeering/gravatar_image_tag
+    def url_params(gravatar_params)
+      return nil if gravatar_params.keys.size == 0
+      array = gravatar_params.map { |k, v| "#{k}=#{value_cleaner(v)}" }
+      "?#{array.join('&')}"
+    end
+
+    def value_cleaner(value)
+      value = value.to_s
+      URI.encode_www_form_component(value)
+    end
+  end
+end

data/app/helpers/polivalente/tags_helper.rb

@@ -0,0 +1,32 @@
+module Polivalente
+  module TagsHelper
+    # Returns a list of tags associated with the given collection.
+    #
+    # A list of classes should be provided such that a class is assigned
+    # to a tag according to the number of times it occurs in the collection.
+    #
+    # Example:
+    #
+    #   <% tag_cloud(Article.all, %w(s m l)) do |tag, klass| %>
+    #     <%= link_to tag.name, tag_path(tag), class_names: (klass) %>
+    #   <% end %>
+    #
+    # Produces:
+    #
+    #   <a class="s" href="/tags/news">news</a>
+    #   <a class="l" href="/tags/entertainment">entertainment</a>
+    #   <a class="l" href="/tags/video">video</a>
+    #   <a class="m" href="/tags/podcast">podcast</a>
+    #
+    def tag_cloud(collection, classes)
+      tags = collection.tag_counts(collection.pluck(:id))
+
+      max = tags.sort_by(&:count).last
+
+      tags.each do |tag|
+        index = tag.count.to_f / max.count * (classes.size - 1)
+        yield(tag, classes[index.round])
+      end
+    end
+  end
+end

data/app/jobs/polivalente/clean_trash_job.rb

@@ -0,0 +1,10 @@
+module Polivalente
+  class CleanTrashJob < ApplicationJob
+    queue_as :default
+
+    # Delete the parent record and then remove the trash item
+    def perform(trash)
+      trash.destroy
+    end
+  end
+end

data/app/models/concerns/polivalente/archivable.rb

@@ -0,0 +1,9 @@
+module Polivalente
+  module Archivable
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :archives, as: :archivable, dependent: :destroy
+    end
+  end
+end

data/app/models/concerns/polivalente/archiver.rb

@@ -0,0 +1,11 @@
+module Polivalente
+  # Archiver: an entity capable of creating and managing archives of other records.
+  module Archiver
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :archives, dependent: :destroy
+      scope :with_archives, -> { include(:archives) }
+    end
+  end
+end

data/app/models/concerns/polivalente/commentable.rb

@@ -0,0 +1,16 @@
+module Polivalente
+  module Commentable
+    extend ActiveSupport::Concern
+    prepend Discard::Model
+
+    included do
+      has_many :comments, as: :commentable, dependent: :destroy
+
+      scope :commented,     -> { where(comments.count > 0) }
+      scope :with_comments, -> { includes(:comments) }
+
+      after_discard         -> { comments.discard_all }
+      after_undiscard       -> { comments.undiscard_all }
+    end
+  end
+end

data/app/models/concerns/polivalente/commentator.rb

@@ -0,0 +1,13 @@
+module Polivalente
+  module Commentator
+    # Commentator: an entity capable of creating and managing comments.
+    #
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :comments, dependent: :destroy
+
+      scope :with_comments, -> { includes(:comments) }
+    end
+  end
+end

data/app/models/concerns/polivalente/content_hashable.rb

@@ -0,0 +1,29 @@
+module Polivalente
+  module ContentHashable
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :content_field
+      class_attribute :content_hash_column
+      self.content_field = :content
+      self.content_hash_column = :content_hash
+
+      before_create :compute_content_hash
+      before_update :compute_content_hash
+    end
+
+    def compute_content_hash
+      rich_text = ActionText::RichText.find_by(:record => self)
+
+      if self.new_record?
+        self[self.class.content_hash_column] = self.send(self.class.content_field).to_s.hash
+      else
+        if rich_text.nil?
+          self[self.class.content_hash_column] = self[self.class.content_field].to_s.hash
+        else
+          self[self.class.content_hash_column] = rich_text.body.to_s.hash
+        end
+      end
+    end
+  end
+end

data/app/models/concerns/polivalente/reactable.rb

@@ -0,0 +1,19 @@
+module Polivalente
+  module Reactable
+    extend ActiveSupport::Concern
+    prepend Discard::Model
+
+    included do
+      has_many :reactions, as: :reactable, dependent: :destroy
+
+      scope :with_reactions, -> { include(:reactions) }
+
+      scope :emoji,     -> { where(type: :emoji) }
+      scope :bookmarks, -> { where(type: :bookmark) }
+      scope :likes,     -> { where(type: :like) }
+
+      after_discard     -> { reactions.discard_all }
+      after_undiscard   -> { reactions.undiscard_all }
+    end
+  end
+end

data/app/models/concerns/polivalente/reactor.rb

@@ -0,0 +1,13 @@
+module Polivalente
+  module Reactor
+    # Reactor: an entity capable of creating and managing reactions on records.
+    #
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :reactions, dependent: :destroy
+
+      scope :with_reactions, -> { include(:reactions) }
+    end
+  end
+end

data/app/models/concerns/polivalente/sortable.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Polivalente
+  module Sortable
+    # Sortable: an entity that can be ordered based on its timestamp fiedls
+    #
+    extend ActiveSupport::Concern
+
+    included do
+      scope :sorted,      -> { order(created_at: :asc) }
+      scope :latest,      -> { order(created_at: :desc) }
+      scope :last_edited, -> { order(updated_at: :desc) }
+    end
+  end
+end

data/app/models/concerns/polivalente/taggable.rb

@@ -0,0 +1,40 @@
+module Polivalente
+  module Taggable
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :name, :tag_list
+
+      has_many :taggings, as: :taggable
+      has_many :tags, through: :taggings
+
+      scope :with_taggings, -> { include(:taggings) }
+
+      def self.tag_counts(ids)
+        Tag.select("tags.*, count(taggings.tag_id) as count")
+                 .joins(:taggings)
+                 .joins("LEFT JOIN #{self.table_name} ON taggings.taggable_id = #{self.table_name}.id")
+                 .where("taggings.taggable_type = ?", name)
+                 .where("#{self.table_name}.id IN (?)", ids)
+                 .group("taggings.tag_id", "tags.id")
+                 .order("tags.name")
+      end
+
+      def tag_list
+        tags.map(&:name).join(", ")
+      end
+
+      def tag_list=(names)
+        self.tags = names.split(",").map do |name|
+          Tag.where(name: name).first_or_create!
+        end.compact
+      end
+    end
+
+    module ClassMethods
+      def tagged_with(name)
+        self.joins(:tags).where(:tags => {:name => name})
+      end
+    end
+  end
+end

data/app/models/concerns/polivalente/trashable.rb

@@ -0,0 +1,27 @@
+module Polivalente
+  module Trashable
+    extend ActiveSupport::Concern
+    prepend Discard::Model
+
+    included do
+      has_many :trashes, as: :trashable, dependent: :destroy
+
+      after_discard :place_in_trash!
+      after_undiscard :remove_from_trash!
+    end
+
+    module ClassMethods
+      def clean_trash!
+        self.discarded.destroy_all
+      end
+    end
+
+    def place_in_trash!
+      Trash.create(user: self.user, trashable: self)
+    end
+
+    def remove_from_trash!
+      Trash.find_by(user: self.user, trashable: self).destroy!
+    end
+  end
+end

data/app/models/concerns/polivalente/trasher.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Polivalente
+  # Trasher: an entity that owns and manages records that can be added to trash.
+  module Trasher
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :trashes, dependent: :destroy
+      scope :with_trash, -> { include(:trashes) }
+    end
+  end
+end

data/app/models/concerns/polivalente/user_owned.rb

@@ -0,0 +1,15 @@
+module Polivalente
+  module UserOwned
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :user_field
+      self.user_field = :user
+
+      belongs_to self.user_field
+      validates_presence_of self.user_field
+
+      scope :with_user, -> { includes(self[self.class.user_field])}
+    end
+  end
+end

data/app/models/concerns/polivalente/visibility.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Polivalente
+  module Visibility
+    extend ActiveSupport::Concern
+
+    included do
+      scope :hidden,  -> { where(is_private: true) }
+      scope :visible, -> { where(is_private: false) }
+    end
+
+    def set_private
+      update_attribute :is_private, true
+    end
+
+    def set_public
+      update_attribute :is_private, false
+    end
+
+    def public?
+      !is_private
+    end
+  end
+end

data/app/models/polivalente/archive.rb

@@ -0,0 +1,20 @@
+module Polivalente
+  class Archive < ApplicationRecord
+    include Sortable
+    include UserOwned
+
+    belongs_to :archivable, polymorphic: true
+
+    after_destroy :destroy_parent!
+
+    protected
+
+    def destroy_parent!
+      archivable.destroy
+    end
+
+    def self.clean!
+      destroy_all
+    end
+  end
+end

data/app/models/polivalente/comment.rb

@@ -0,0 +1,26 @@
+module Polivalente
+  class Comment < ApplicationRecord
+    include Commentable
+    include ContentHashable
+    include Reactable
+    include Sortable
+    include UserOwned
+
+    has_rich_text :content
+
+    belongs_to :commentable, polymorphic: true
+
+    alias :author :user
+
+    validates_presence_of :commentable
+    validates_presence_of :content
+
+    def byline
+      "by #{author.name}"
+    end
+
+    def summary
+      "#{truncate(content)}"
+    end
+  end
+end

data/app/models/polivalente/reaction.rb

@@ -0,0 +1,24 @@
+module Polivalente
+  class Reaction < ApplicationRecord
+    include Sortable
+    include UserOwned
+
+    belongs_to :reactable, polymorphic: true
+
+    enum kind: {
+      bookmark: 10,
+      emoji:    20,
+      like:     30,
+    }, _prefix: :reaction
+
+    validates_presence_of :kind
+    validates :kind,   inclusion: { in: kinds.keys }
+    validate  :emoji_type_has_data!
+
+    private
+
+    def emoji_type_has_data!
+      errors.add "emoji missing" if kind == "emoji" && data.nil?
+    end
+  end
+end

data/app/models/polivalente/tag.rb

@@ -0,0 +1,20 @@
+module Polivalente
+  class Tag < ApplicationRecord
+    include Sortable
+
+    has_many :taggings
+
+    validates_length_of :name, minimum: 2, maximum: 20
+    validates_uniqueness_of :name
+    before_save :sanitize_name!
+
+    private
+
+    def sanitize_name!
+      self.name = name.downcase
+        .gsub(/[^a-zA-Z\d\s-]/i, '')
+        .delete_prefix('-')
+        .delete_suffix('-') unless name.nil?
+    end
+  end
+end

data/app/models/polivalente/tagging.rb

@@ -0,0 +1,12 @@
+module Polivalente
+  class Tagging < ApplicationRecord
+    include Sortable
+
+    belongs_to :tag
+    belongs_to :taggable, polymorphic: true
+
+    validates_presence_of :tag
+    validates_presence_of :taggable
+    validates_uniqueness_of :tag, scope: [:taggable_id, :taggable_type]
+  end
+end

data/app/models/polivalente/trash.rb

@@ -0,0 +1,32 @@
+module Polivalente
+  class Trash < ActiveRecord::Base
+    include Sortable
+    include UserOwned
+
+    belongs_to :trashable, polymorphic: true
+
+    after_create :schedule_deletion
+
+    self.table_name = :trash
+
+    # Stale records are those that have been in the trash for `T` amount of time
+    scope :stale, -> { where("created_at <= ?", Time.zone.now - Polivalente.config.trash_ttl) }
+
+    def self.clean_stale!
+      stale.destroy_all
+    end
+
+    def self.clean!
+      destroy_all
+    end
+
+    protected
+
+    # Schedule the deletion of this and parent record
+    def schedule_deletion
+      CleanTrashJob
+        .set(wait_until: Polivalente.config.trash_ttl.from_now)
+        .perform_later(self)
+    end
+  end
+end

data/app/serializers/polivalente/comment_serializer.rb

@@ -0,0 +1,8 @@
+module Polivalente
+  class CommentSerializer < ActiveModel::Serializer
+    attributes :id, :content
+    has_one :user
+    has_one :commentable
+    has_many :comments
+  end
+end

data/app/serializers/polivalente/reaction_serializer.rb

@@ -0,0 +1,7 @@
+module Polivalente
+  class ReactionSerializer < ActiveModel::Serializer
+    attributes :id, :kind
+    has_one :user
+    has_one :reactable
+  end
+end

data/app/serializers/polivalente/tag_serializer.rb

@@ -0,0 +1,6 @@
+module Polivalente
+  class TagSerializer < ActiveModel::Serializer
+    attributes :id, :name, :created_at
+    has_many :taggings
+  end
+end

data/app/serializers/polivalente/tagging_serializer.rb

@@ -0,0 +1,7 @@
+module Polivalente
+  class TaggingSerializer < ActiveModel::Serializer
+    attributes :id, :created_at
+    has_one :tag
+    has_one :taggable
+  end
+end

data/app/serializers/polivalente/user_serializer.rb

@@ -0,0 +1,9 @@
+module Polivalente
+  class UserSerializer < ActiveModel::Serializer
+    attributes :name, :photo_url
+
+    def photo_url
+      object.photo.url
+    end
+  end
+end