Mj (#1231)

* ah MJ

* sighh....

Author: cskartikey

app/controllers/showcase_controller.rb

@@ -0,0 +1,68 @@
+class ShowcaseController < ApplicationController
+  before_action :authenticate_user!
+
+  def new
+    @project = Showcase::Matchmaker.new(user: current_user).pick
+
+    if @project.nil?
+      redirect_to explore_path, alert: "No eligible projects available right now." and return
+    end
+
+    ActiveRecord::Associations::Preloader
+      .new(records: [ @project ], associations: [ { banner_attachment: :blob } ])
+      .call
+
+    @devlogs = Devlog.where(project_id: @project.id)
+                     .includes({ user: :user_badges }, { file_attachment: :blob })
+                     .order(:created_at)
+
+    @grade_labels = VoteMf::GRADE_LABELS
+    @criteria = VoteMf::CRITERIA
+    @vote_mf = VoteMf.new(project: @project, voter: current_user)
+
+    session[:showcase_started_at] = Time.current.to_i
+  end
+
+  def create
+    # yes, this is indeed vibecoded. I do not have motivation to work on SoM's codebase. check out battlemage tho. that said, i wrote the matchmakign service and the models by hand
+    @project = Project.find(params.require(:project_id))
+    if @project.user_id == current_user.id
+      redirect_to showcase_path, alert: "You cannot vote on your own project." and return
+    end
+
+    raw_ballot = params.require(:vote_mf).permit(ballot: {})[:ballot] || {}
+
+    time_spt_ms = nil
+    if session[:showcase_started_at].present?
+      begin
+        started_at = Time.at(session[:showcase_started_at].to_i)
+        time_spt_ms = ((Time.current - started_at) * 1000).to_i.clamp(0, 86_400_000)
+      rescue StandardError
+        time_spt_ms = nil
+      end
+    end
+
+    @vote_mf = VoteMf.new(
+      project: @project,
+      voter: current_user,
+      ballot: raw_ballot,
+      time_spent_voting_ms: time_spt_ms
+    )
+
+    if @vote_mf.save
+      session.delete(:showcase_started_at)
+      redirect_to showcase_path, notice: "Thanks! Your vote was recorded."
+    else
+      ActiveRecord::Associations::Preloader
+        .new(records: [ @project ], associations: [ { banner_attachment: :blob } ])
+        .call
+      @devlogs = Devlog.where(project_id: @project.id)
+                       .includes({ user: :user_badges }, { file_attachment: :blob })
+                       .order(:created_at)
+      @grade_labels = VoteMf::GRADE_LABELS
+      @criteria = VoteMf::CRITERIA
+      flash.now[:alert] = @vote_mf.errors.full_messages.join(", ")
+      render :new, status: :unprocessable_entity
+    end
+  end
+end

app/models/vote_mf.rb

@@ -0,0 +1,97 @@
+# == Schema Information
+#
+# Table name: vote_mfs
+#
+#  id                   :bigint           not null, primary key
+#  ballot               :jsonb            not null
+#  time_spent_voting_ms :integer
+#  created_at           :datetime         not null
+#  updated_at           :datetime         not null
+#  project_id           :bigint           not null
+#  voter_id             :bigint           not null
+#
+# Indexes
+#
+#  index_vote_mfs_on_project_id  (project_id)
+#  index_vote_mfs_on_voter_id    (voter_id)
+#
+# Foreign Keys
+#
+#  fk_rails_...  (project_id => projects.id)
+#  fk_rails_...  (voter_id => users.id)
+#
+class VoteMf < ApplicationRecord
+    belongs_to :project
+    belongs_to :voter, class_name: "User"
+
+    CRITERIA = %w[technical creativity storytelling originality].freeze
+
+    # 6-point scale, because 5-point scale leads to pepople picking the nice middle. "In 2006 the majority judgment experiment used five grades (see table 21.1b).
+    # This was not the optimal choice; too often, judges waffled by giving the middle
+    # grade, Good."
+
+    GRADE_LABELS = [
+        "Poor",         # 0
+        "Mediocre",     # 1
+        "Fair",         # 2
+        "Good",         # 3
+        "Very good",    # 4
+        "Excellent"     # 5
+    ].freeze
+
+    GRADE_LABEL_TO_INT = GRADE_LABELS.each_with_index.to_h.transform_keys { |k| k.downcase }
+
+    before_validation :normalize_ballot!
+
+    validates :time_spent_voting_ms, numericality: { greater_than: 0 }
+    validates :voter_id, uniqueness: { scope: :project_id }
+    validate :validate_ballot
+
+  # it will return a 0.0..1.0 (b/w 0 and 1) normalized composite score across all criteria – sum / n_critieria * (label - 1)
+  def normalized_total_score
+    values = ballot.is_a?(Hash) ? ballot.values : []
+    return nil if values.empty?
+
+    int_values = values.map(&:to_i)
+    max_total = (CRITERIA.size * (GRADE_LABELS.size - 1)).to_f
+    return 0.0 if max_total <= 0
+
+    (int_values.sum / max_total).clamp(0.0, 1.0)
+  end
+
+    def ballot_labels
+        return {} unless ballot.is_a?(Hash)
+        ballot.to_h.transform_values do |v|
+            int = v.is_a?(String) ? GRADE_LABEL_TO_INT[v.downcase] : v
+            GRADE_LABELS[int.to_i] if int.is_a?(Integer) && int.between?(0, 5)
+        end.compact
+    end
+
+    private
+
+    def normalize_ballot!
+        b = ballot.dup
+        normalized = {}
+        CRITERIA.each do |criterion|
+            raw = b[criterion]
+            next if raw.nil?
+            value = GRADE_LABEL_TO_INT[raw.strip.downcase]
+            normalized[criterion] = value unless value.nil?
+        end
+        self.ballot = normalized
+    end
+
+    def validate_ballot
+        errors.add(:ballot, "must be a JSON object") and return unless ballot.is_a?(Hash)
+
+        missing = CRITERIA - ballot.keys.map(&:to_s)
+        errors.add(:ballot, "is missing required criteria: #{missing.join(', ')}") unless missing.empty?
+
+        ballot.each do |criterion, value|
+            unless CRITERIA.include?(criterion.to_s)
+                errors.add(:ballot, "contains unknown criterion '#{criterion}'")
+                next
+            end
+        end
+    end
+end

app/services/showcase/matchmaker.rb

@@ -0,0 +1,195 @@
+module Showcase
+    class Matchmaker
+        # my SO is a great matchmaker. hit me up on slack if you want lore!
+
+        MAX_COMPOSITE_STDDEV = 0.5
+        TARGET_VOTERS = 15
+        WEIGHT_EXPOSURE = 0.6
+        WEIGHT_UNCERTAINTY = 0.4
+        SOFTMAX_TEMPERATURE = 1.0
+
+        def initialize(user:)
+            @user = user
+        end
+
+        def pick
+            pool_project_ids = build_pool_project_ids
+            return nil if pool_project_ids.empty?
+
+            user_project = Project.where(id: pool_project_ids, user_id: @user.id).pluck(:id)
+            already_voted = VoteMf.where(voter_id: @user.id, project_id: pool_project_ids).pluck(:project_id)
+
+            excluded_ids = (user_project + already_voted).uniq
+            candidate = pool_project_ids - excluded_ids
+            return nil if candidate.empty?
+
+            exposure_by_id = exposure_scores(candidate)
+            uncertainty_by_id = uncertainty_scores(candidate)
+
+            scores = candidate.index_with do |pid|
+                (WEIGHT_EXPOSURE * (exposure_by_id[pid] || 0.0)) + (WEIGHT_UNCERTAINTY * (uncertainty_by_id[pid] || 0.0))
+            end
+
+            chosen_id = softmax(scores)
+            Project.find_by(id: chosen_id)
+        end
+
+        private
+
+        def build_pool_project_ids
+              p = [ 2160,
+                1779,
+                9722,
+                11764,
+                792,
+                2701,
+                11177,
+                11979,
+                1469,
+                12938,
+                991,
+                3423,
+                1598,
+                6392,
+                12342,
+                13073,
+                10944,
+                13782,
+                169,
+                6838,
+                1775,
+                914,
+                1014,
+                2521,
+                133,
+                8597,
+                12542,
+                1727,
+                9530,
+                947,
+                10359,
+                837,
+                1932,
+                12484,
+                4041,
+                53,
+                398,
+                7260,
+                10992,
+                4192,
+                2179,
+                2290,
+                9969,
+                12762,
+                2365,
+                5812,
+                2753,
+                13844,
+                8326,
+                6472,
+                12114,
+                3529,
+                29,
+                13227,
+                1730,
+                11304,
+                1537,
+                8244,
+                161,
+                196,
+                4283,
+                10458,
+                4637,
+                1131,
+                13321,
+                2787,
+                4032,
+                723,
+                11162,
+                7236,
+                311,
+                2470,
+                7613,
+                12158,
+                13678,
+                4907,
+                2181,
+                9065,
+                4310,
+                10026,
+                2429,
+                13952,
+                3152,
+                12344,
+                3888,
+                5038,
+                664,
+                3761,
+                15,
+                11442,
+                6059,
+                8920,
+                5328,
+                6737,
+                12728,
+                8994,
+                791,
+                5187,
+                10803,
+                5942 ]
+              p & Project.where(id: p).pluck(:id)
+        end
+
+        def exposure_scores(project_ids)
+            return {} if project_ids.empty?
+
+            voters_count = VoteMf.where(project_id: project_ids).group(:project_id).distinct.count(:voter_id)
+            project_ids.index_with do |p|
+                v = voters_count[p].to_i
+                ((TARGET_VOTERS - v) / TARGET_VOTERS.to_f).clamp(0.0, 1.0)
+            end
+        end
+
+        def uncertainty_scores(project_ids)
+            return {} if project_ids.empty?
+
+            scores_by_project_id = Hash.new { |h, k| h[k] = [] }
+            VoteMf.where(project_id: project_ids).select(:project_id, :ballot).find_each(batch_size: 50) do |vmf|
+                s = vmf.normalized_total_score
+                scores_by_project_id[vmf.project_id] << s if s
+            end
+
+            project_ids.index_with do |pid|
+                scores = scores_by_project_id[pid]
+                next 1.0 if scores.empty?
+
+                mean = scores.sum.to_f / scores.size
+                var = scores.sum { |x| (x - mean) ** 2 } / scores.size.to_f
+                std = Math.sqrt(var)
+                (std / MAX_COMPOSITE_STDDEV).clamp(0.0, 1.0)
+            end
+        end
+
+        def softmax(scores_by_id)
+            return nil if scores_by_id.empty?
+
+            ids = scores_by_id.keys
+            values = ids.map { |id| scores_by_id[id].to_f }
+
+            max_v = values.max
+            temperature = [ SOFTMAX_TEMPERATURE.to_f, 1e-6 ].max
+            exps = values.map { |v| Math.exp((v - max_v) / temperature) }
+            sum = exps.sum
+            return ids[values.index(max_v)] if sum <= 0.0
+
+            probs = exps.map { |x| x / sum }
+            r = rand
+            cumulative = 0.0
+            ids.each_with_index do |id, idx|
+                cumulative += probs[idx]
+                return id if r <= cumulative
+            end
+            ids.last
+        end
+    end
+end