introduce Enum

Author: goshacmd

app/controllers/admin/flags_controller.rb

@@ -21,7 +21,7 @@ def index
 limit 100
 "
 
-    sql.where2 "post_action_type_id in (:flag_types)", flag_types: PostActionType.FlagTypes
+    sql.where2 "post_action_type_id in (:flag_types)", flag_types: PostActionType.flag_types.values
 
 
     # it may make sense to add a view that shows flags on deleted posts,
@@ -62,7 +62,7 @@ def index
 from post_actions a
 /*where*/
 "
-    sql.where("post_action_type_id in (:flag_types)", flag_types: PostActionType.FlagTypes)
+    sql.where("post_action_type_id in (:flag_types)", flag_types: PostActionType.flag_types.values)
     sql.where("post_id in (:posts)", posts: posts.map{|p| p["id"].to_i})
 
     if params[:filter] == 'old'

app/controllers/post_actions_controller.rb

@@ -8,7 +8,7 @@ class PostActionsController < ApplicationController
   def create
     id = params[:post_action_type_id].to_i
     if action = PostActionType.where(id: id).first
-      guardian.ensure_post_can_act!(@post, PostActionType.Types.invert[id])
+      guardian.ensure_post_can_act!(@post, PostActionType.types[id])
 
       post_action = PostAction.act(current_user, @post, action.id, params[:message])
 

app/controllers/posts_controller.rb

@@ -134,9 +134,9 @@ def bookmark
     post = find_post_from_params
     if current_user
       if params[:bookmarked] == "true"
-        PostAction.act(current_user, post, PostActionType.Types[:bookmark])
+        PostAction.act(current_user, post, PostActionType.types[:bookmark])
       else
-        PostAction.remove_act(current_user, post, PostActionType.Types[:bookmark])
+        PostAction.remove_act(current_user, post, PostActionType.types[:bookmark])
       end
     end
     render :nothing => true

app/mailers/user_notifications.rb

@@ -64,7 +64,7 @@ def notification_template(user, opts)
     return unless @post.present?
 
     username = @notification.data_hash[:display_username]
-    notification_type = Notification.InvertedTypes[opts[:notification].notification_type].to_s
+    notification_type = Notification.types[opts[:notification].notification_type].to_s
 
     email_opts = {
       topic_title: @notification.data_hash[:topic_title],

app/models/invite.rb

@@ -72,7 +72,7 @@ def redeem
         end
 
           # Notify the invitee
-          invited_by.notifications.create(notification_type: Notification.Types[:invitee_accepted],
+          invited_by.notifications.create(notification_type: Notification.types[:invitee_accepted],
                                           data: { display_username: result.username }.to_json)
 
       else

app/models/notification.rb

@@ -1,5 +1,6 @@
-class Notification < ActiveRecord::Base
+require_dependency 'enum'
 
+class Notification < ActiveRecord::Base
   belongs_to :user
   belongs_to :topic
 
@@ -9,21 +10,11 @@ class Notification < ActiveRecord::Base
   scope :unread, lambda { where(read: false) }
   scope :recent, lambda { order('created_at desc').limit(10) }
 
-  def self.Types
-    {:mentioned => 1,
-     :replied => 2,
-     :quoted => 3,
-     :edited => 4,
-     :liked => 5,
-     :private_message => 6,
-     :invited_to_private_message => 7,
-     :invitee_accepted => 8,
-     :posted => 9,
-     :moved_post => 10}
-  end
-
-  def self.InvertedTypes
-    @inverted_types ||= Notification.Types.invert
+  def self.types
+    @types ||= Enum.new(
+      :mentioned, :replied, :quoted, :edited, :liked, :private_message,
+      :invited_to_private_message, :invitee_accepted, :posted, :moved_post
+    )
   end
 
   def self.mark_posts_read(user, topic_id, post_numbers)
@@ -35,8 +26,8 @@ def self.interesting_after(min_date)
               .includes(:topic)
               .unread
               .limit(20)
-              .order("CASE WHEN notification_type = #{Notification.Types[:replied]} THEN 1
-                           WHEN notification_type = #{Notification.Types[:mentioned]} THEN 2
+              .order("CASE WHEN notification_type = #{Notification.types[:replied]} THEN 1
+                           WHEN notification_type = #{Notification.types[:mentioned]} THEN 2
                            ELSE 3
                       END, created_at DESC").to_a
 
@@ -69,7 +60,7 @@ def data_hash
 
   def text_description
     link = block_given? ? yield : ""
-    I18n.t("notification_types.#{Notification.InvertedTypes[notification_type]}", data_hash.merge(link: link))
+    I18n.t("notification_types.#{Notification.types[notification_type]}", data_hash.merge(link: link))
   end
 
   def url

app/models/post.rb

@@ -279,7 +279,7 @@ def all_versions
   end
 
   def is_flagged?
-    post_actions.where(post_action_type_id: PostActionType.FlagTypes, deleted_at: nil).count != 0
+    post_actions.where(post_action_type_id: PostActionType.flag_types.values, deleted_at: nil).count != 0
   end
 
   def unhide!

app/models/post_action.rb

@@ -20,7 +20,7 @@ class AlreadyFlagged < StandardError; end
 
   def self.update_flagged_posts_count
     posts_flagged_count = PostAction.joins(post: :topic)
-                                    .where('post_actions.post_action_type_id' => PostActionType.FlagTypes,
+                                    .where('post_actions.post_action_type_id' => PostActionType.flag_types.values,
                                            'posts.deleted_at' => nil,
                                            'topics.deleted_at' => nil).count('DISTINCT posts.id')
 
@@ -55,13 +55,12 @@ def self.clear_flags!(post, moderator_id, action_type_id = nil)
     actions = if action_type_id
       [action_type_id]
     else
-      moderator_id == -1 ? PostActionType.AutoActionFlagTypes : PostActionType.FlagTypes
+      moderator_id == -1 ? PostActionType.auto_action_flag_types.values : PostActionType.flag_types.values
     end
 
     PostAction.update_all({ deleted_at: Time.now, deleted_by: moderator_id }, { post_id: post.id, post_action_type_id: actions })
 
-    r = PostActionType.Types.invert
-    f = actions.map { |t| ["#{r[t]}_count", 0] }
+    f = actions.map{|t| ["#{PostActionType.types[t]}_count", 0]}
 
     Post.with_deleted.update_all(Hash[*f.flatten], id: post.id)
 
@@ -87,15 +86,15 @@ def self.remove_act(user, post, post_action_type_id)
   end
 
   def is_bookmark?
-    post_action_type_id == PostActionType.Types[:bookmark]
+    post_action_type_id == PostActionType.types[:bookmark]
   end
 
   def is_like?
-    post_action_type_id == PostActionType.Types[:like]
+    post_action_type_id == PostActionType.types[:like]
   end
 
   def is_flag?
-    PostActionType.FlagTypes.include?(post_action_type_id)
+    PostActionType.flag_types.values.include?(post_action_type_id)
   end
 
   # A custom rate limiter for this model
@@ -124,15 +123,15 @@ def message_quality
   end
 
   before_create do
-    raise AlreadyFlagged if is_flag? && PostAction.where(user_id: user_id,
-                                                         post_id: post_id,
-                                                         post_action_type_id: PostActionType.FlagTypes).exists?
+    raise AlreadyFlagged if is_flag? and PostAction.where(user_id: user_id,
+                                                          post_id: post_id,
+                                                          post_action_type_id: PostActionType.flag_types.values).exists?
   end
 
   after_save do
     # Update denormalized counts
-    post_action_type = PostActionType.Types.invert[post_action_type_id]
-    column = "#{post_action_type}_count"
+    post_action_type = PostActionType.types[post_action_type_id]
+    column = "#{post_action_type.to_s}_count"
     delta = deleted_at.nil? ? 1 : -1
 
     # Voting also changes the sort_order
@@ -144,7 +143,7 @@ def message_quality
     Topic.update_all ["#{column} = #{column} + ?", delta], id: post.topic_id
 
 
-    if PostActionType.FlagTypes.include?(post_action_type_id)
+    if PostActionType.flag_types.values.include?(post_action_type_id)
       PostAction.update_flagged_posts_count
     end
 
@@ -153,7 +152,7 @@ def message_quality
       flag_counts = exec_sql("SELECT SUM(CASE WHEN deleted_at IS NULL THEN 1 ELSE 0 END) AS new_flags,
                                      SUM(CASE WHEN deleted_at IS NOT NULL THEN 1 ELSE 0 END) AS old_flags
                               FROM post_actions
-                              WHERE post_id = ? AND post_action_type_id IN (?)", post.id, PostActionType.AutoActionFlagTypes).first
+                              WHERE post_id = ? AND post_action_type_id IN (?)", post.id, PostActionType.auto_action_flag_types.values).first
       old_flags, new_flags = flag_counts['old_flags'].to_i, flag_counts['new_flags'].to_i
 
       if new_flags >= SiteSetting.flags_required_to_hide_post

app/models/post_action_type.rb

@@ -1,31 +1,28 @@
+require_dependency 'enum'
+
 class PostActionType < ActiveRecord::Base
   attr_accessible :id, :is_flag, :name_key, :icon
 
-  def self.ordered
-    order('position asc').all
-  end
+  class << self
+    def ordered
+      order('position asc').all
+    end
 
-  def self.Types
-    {
-      bookmark: 1,
-      like: 2,
-      off_topic: 3,
-      inappropriate: 4,
-      vote: 5,
-      custom_flag: 6,
-      spam: 8
-    }
-  end
+    def types
+      @types ||= Enum.new(:bookmark, :like, :off_topic, :inappropriate, :vote,
+                          :custom_flag, :spam)
+    end
 
-  def self.is_flag?(sym)
-    self.FlagTypes.include?(self.Types[sym])
-  end
+    def auto_action_flag_types
+      @auto_action_flag_types ||= flag_types.except(:custom_flag)
+    end
 
-  def self.AutoActionFlagTypes
-    @auto_action_flag_types ||= [self.Types[:off_topic], self.Types[:spam], self.Types[:inappropriate]]
-  end
+    def flag_types
+      @flag_types ||= types.only(:off_topic, :spam, :inappropriate, :custom_flag)
+    end
 
-  def self.FlagTypes
-    @flag_types ||= self.AutoActionFlagTypes + [self.Types[:custom_flag]]
+    def is_flag?(sym)
+      flag_types.valid?(sym)
+    end
   end
 end

app/models/post_alert_observer.rb

@@ -38,7 +38,7 @@ def after_create_post_action(post_action)
     return if post.topic.private_message?
 
     create_notification(post.user,
-                        Notification.Types[:liked],
+                        Notification.types[:liked],
                         post,
                         display_username: post_action.user.username,
                         post_action_id: post_action.id)
@@ -52,14 +52,14 @@ def after_create_version(version)
     return if version.user_id == post.user_id
     return if post.topic.private_message?
 
-    create_notification(post.user, Notification.Types[:edited], post, display_username: version.user.username)
+    create_notification(post.user, Notification.types[:edited], post, display_username: version.user.username)
   end
 
   def after_create_post(post)
     if post.topic.private_message?
       # If it's a private message, notify the topic_allowed_users
-      post.topic.topic_allowed_users.reject { |a| a.user_id == post.user_id }.each do |a|
-        create_notification(a.user, Notification.Types[:private_message], post)
+      post.topic.topic_allowed_users.reject{ |a| a.user_id == post.user_id }.each do |a|
+        create_notification(a.user, Notification.types[:private_message], post)
       end
     else
       # If it's not a private message, notify the users
@@ -114,7 +114,7 @@ def extract_quoted_users(post)
     def notify_users(users, type, post)
       users = [users] unless users.is_a?(Array)
       users.each do |u|
-        create_notification(u, Notification.Types[type], post)
+        create_notification(u, Notification.types[type], post)
       end
     end
 
@@ -133,7 +133,7 @@ def notify_post_users(post)
         exclude_user_ids << extract_quoted_users(post).map(&:id)
         exclude_user_ids.flatten!
         TopicUser.where(topic_id: post.topic_id, notification_level: TopicUser::NotificationLevel::WATCHING).includes(:user).each do |tu|
-          create_notification(tu.user, Notification.Types[:posted], post) unless exclude_user_ids.include?(tu.user_id)
+          create_notification(tu.user, Notification.types[:posted], post) unless exclude_user_ids.include?(tu.user_id)
         end
       end
     end