vote_fu 0.0.11 → 2.0.0

data/app/controllers/vote_fu/votes_controller.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+module VoteFu
+  class VotesController < ApplicationController
+    before_action :require_voter!
+    before_action :find_voteable
+
+    # POST /vote_fu/votes
+    # Creates or updates a vote
+    def create
+      value = vote_value_from_params
+
+      if VoteFu.configuration.allow_recast
+        @vote = current_voter.vote_on(@voteable, value: value, scope: vote_scope)
+      else
+        existing = find_existing_vote
+        if existing
+          respond_with_error("You have already voted on this item")
+          return
+        end
+        @vote = current_voter.vote_on(@voteable, value: value, scope: vote_scope)
+      end
+
+      respond_with_vote(:created)
+    rescue StandardError => e
+      respond_with_error(e.message)
+    end
+
+    # PATCH/PUT /vote_fu/votes/:id
+    # Updates an existing vote's value
+    def update
+      @vote = Vote.find_by(id: params[:id], voter: current_voter)
+
+      unless @vote
+        respond_with_error("Vote not found")
+        return
+      end
+
+      unless VoteFu.configuration.allow_recast
+        respond_with_error("Vote recasting is disabled")
+        return
+      end
+
+      value = vote_value_from_params
+      @vote.update!(value: value)
+      @voteable.reload
+
+      respond_with_vote(:ok)
+    rescue StandardError => e
+      respond_with_error(e.message)
+    end
+
+    # DELETE /vote_fu/votes/:id
+    # Removes a vote
+    def destroy
+      @vote = if params[:id].present? && params[:id] != "remove"
+                Vote.find_by(id: params[:id], voter: current_voter)
+              else
+                find_existing_vote
+              end
+
+      unless @vote
+        respond_with_error("Vote not found")
+        return
+      end
+
+      @vote.destroy!
+      @voteable.reload
+
+      respond_to do |format|
+        format.turbo_stream { render_vote_turbo_stream(:removed) }
+        format.html { redirect_back fallback_location: main_app.root_path }
+        format.json { render json: vote_json_response(:removed), status: :ok }
+      end
+    rescue StandardError => e
+      respond_with_error(e.message)
+    end
+
+    # POST /vote_fu/votes/toggle
+    # Toggles between upvote/remove or downvote/remove
+    def toggle
+      direction = params[:direction]&.to_sym || :up
+      existing = find_existing_vote
+
+      if existing
+        if (direction == :up && existing.up?) || (direction == :down && existing.down?)
+          # Same direction - remove the vote
+          existing.destroy!
+          @voteable.reload
+          @vote = nil
+
+          respond_to do |format|
+            format.turbo_stream { render_vote_turbo_stream(:removed) }
+            format.html { redirect_back fallback_location: main_app.root_path }
+            format.json { render json: vote_json_response(:removed), status: :ok }
+          end
+        else
+          # Different direction - change the vote (if allowed)
+          if VoteFu.configuration.allow_recast
+            value = direction == :up ? 1 : -1
+            existing.update!(value: value)
+            @vote = existing
+            @voteable.reload
+            respond_with_vote(:ok)
+          else
+            respond_with_error("Vote recasting is disabled")
+          end
+        end
+      else
+        # No existing vote - create one
+        value = direction == :up ? 1 : -1
+        @vote = current_voter.vote_on(@voteable, value: value, scope: vote_scope)
+        respond_with_vote(:created)
+      end
+    rescue StandardError => e
+      respond_with_error(e.message)
+    end
+
+    private
+
+    def vote_scope
+      params[:scope].presence
+    end
+
+    def vote_value_from_params
+      if params[:value].present?
+        params[:value].to_i
+      elsif params[:direction].present?
+        case params[:direction].to_sym
+        when :up, :upvote then 1
+        when :down, :downvote then -1
+        else 1
+        end
+      else
+        1
+      end
+    end
+
+    def find_existing_vote
+      Vote.find_by(
+        voter: current_voter,
+        voteable: @voteable,
+        scope: vote_scope
+      )
+    end
+
+    def respond_with_vote(status)
+      @voteable.reload
+
+      respond_to do |format|
+        format.turbo_stream { render_vote_turbo_stream(status == :created ? :created : :updated) }
+        format.html { redirect_back fallback_location: main_app.root_path }
+        format.json { render json: vote_json_response(:success), status: status }
+      end
+    end
+
+    def respond_with_error(message)
+      respond_to do |format|
+        format.turbo_stream do
+          render turbo_stream: turbo_stream.replace(
+            vote_dom_id(:error),
+            partial: "vote_fu/votes/error",
+            locals: { message: message }
+          ), status: :unprocessable_entity
+        end
+        format.html do
+          redirect_back fallback_location: main_app.root_path, alert: message
+        end
+        format.json do
+          render json: { error: message }, status: :unprocessable_entity
+        end
+      end
+    end
+
+    def render_vote_turbo_stream(action)
+      render turbo_stream: [
+        turbo_stream.replace(
+          vote_dom_id(:widget),
+          partial: "vote_fu/votes/widget",
+          locals: vote_locals.merge(action: action)
+        ),
+        turbo_stream.replace(
+          vote_dom_id(:count),
+          partial: "vote_fu/votes/count",
+          locals: vote_locals
+        )
+      ]
+    end
+
+    def vote_dom_id(suffix)
+      scope_part = vote_scope.present? ? "_#{vote_scope}" : ""
+      "vote_fu_#{@voteable.model_name.singular}_#{@voteable.id}#{scope_part}_#{suffix}"
+    end
+
+    def vote_locals
+      {
+        voteable: @voteable,
+        voter: current_voter,
+        vote: @vote,
+        scope: vote_scope
+      }
+    end
+
+    def vote_json_response(status)
+      {
+        status: status,
+        voteable_type: @voteable.class.name,
+        voteable_id: @voteable.id,
+        scope: vote_scope,
+        vote: @vote&.as_json(only: %i[id value created_at]),
+        stats: {
+          votes_for: @voteable.votes_for(scope: vote_scope),
+          votes_against: @voteable.votes_against(scope: vote_scope),
+          votes_total: @voteable.votes_total(scope: vote_scope),
+          votes_count: @voteable.votes_count(scope: vote_scope),
+          plusminus: @voteable.plusminus(scope: vote_scope),
+          percent_for: @voteable.percent_for(scope: vote_scope)
+        },
+        current_vote_direction: @vote&.direction
+      }
+    end
+  end
+end

data/app/helpers/vote_fu/votes_helper.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module VoteFu
+  module VotesHelper
+    # Renders the full vote widget with upvote/downvote buttons and count
+    #
+    # @param voteable [ActiveRecord::Base] The voteable record
+    # @param options [Hash] Options hash
+    # @option options [Object] :voter The current voter (defaults to current_user if available)
+    # @option options [String, Symbol] :scope Vote scope for scoped voting
+    # @option options [Boolean] :show_count Whether to show vote count (default: true)
+    # @option options [String] :upvote_label Custom upvote button label (default: "▲")
+    # @option options [String] :downvote_label Custom downvote button label (default: "▼")
+    #
+    # @example Basic usage
+    #   <%= vote_widget @post %>
+    #
+    # @example With scope
+    #   <%= vote_widget @post, scope: :quality %>
+    #
+    # @example Custom labels
+    #   <%= vote_widget @post, upvote_label: "👍", downvote_label: "👎" %>
+    #
+    def vote_widget(voteable, options = {})
+      voter = options.fetch(:voter) { default_voter }
+
+      render partial: "vote_fu/votes/widget", locals: {
+        voteable: voteable,
+        voter: voter,
+        scope: options[:scope],
+        show_count: options.fetch(:show_count, true),
+        upvote_label: options.fetch(:upvote_label, "▲"),
+        downvote_label: options.fetch(:downvote_label, "▼")
+      }
+    end
+
+    # Renders the vote count for a voteable
+    #
+    # @param voteable [ActiveRecord::Base] The voteable record
+    # @param options [Hash] Options hash
+    # @option options [String, Symbol] :scope Vote scope
+    # @option options [Symbol] :format Display format (:plusminus, :total, :percentage, :split)
+    #
+    # @example Basic usage
+    #   <%= vote_count @post %>
+    #
+    # @example With format
+    #   <%= vote_count @post, format: :percentage %>
+    #
+    def vote_count(voteable, options = {})
+      render partial: "vote_fu/votes/count", locals: {
+        voteable: voteable,
+        scope: options[:scope],
+        format: options.fetch(:format, :plusminus)
+      }
+    end
+
+    # Renders a like button (upvote-only, social media style)
+    #
+    # @param voteable [ActiveRecord::Base] The voteable record
+    # @param options [Hash] Options hash
+    # @option options [Object] :voter The current voter
+    # @option options [String, Symbol] :scope Vote scope
+    # @option options [String] :liked_label Label when liked (default: "♥")
+    # @option options [String] :unliked_label Label when not liked (default: "♡")
+    # @option options [Boolean] :show_count Show like count (default: true)
+    # @option options [String] :class Additional CSS classes
+    #
+    # @example Basic usage
+    #   <%= like_button @photo %>
+    #
+    # @example With custom labels
+    #   <%= like_button @photo, liked_label: "❤️", unliked_label: "🤍" %>
+    #
+    def like_button(voteable, options = {})
+      voter = options.fetch(:voter) { default_voter }
+
+      render partial: "vote_fu/votes/like_button", locals: {
+        voteable: voteable,
+        voter: voter,
+        scope: options[:scope],
+        liked_label: options.fetch(:liked_label, "♥"),
+        unliked_label: options.fetch(:unliked_label, "♡"),
+        show_count: options.fetch(:show_count, true),
+        class: options[:class]
+      }
+    end
+
+    # Renders a standalone upvote button
+    #
+    # @param voteable [ActiveRecord::Base] The voteable record
+    # @param options [Hash] Options hash
+    #
+    def upvote_button(voteable, options = {})
+      voter = options.fetch(:voter) { default_voter }
+
+      render partial: "vote_fu/votes/upvote_button", locals: {
+        voteable: voteable,
+        voter: voter,
+        scope: options[:scope],
+        label: options.fetch(:label, "▲"),
+        class: options[:class]
+      }
+    end
+
+    # Renders a standalone downvote button
+    #
+    # @param voteable [ActiveRecord::Base] The voteable record
+    # @param options [Hash] Options hash
+    #
+    def downvote_button(voteable, options = {})
+      voter = options.fetch(:voter) { default_voter }
+
+      render partial: "vote_fu/votes/downvote_button", locals: {
+        voteable: voteable,
+        voter: voter,
+        scope: options[:scope],
+        label: options.fetch(:label, "▼"),
+        class: options[:class]
+      }
+    end
+
+    # Returns the DOM ID for a voteable's widget
+    #
+    # @param voteable [ActiveRecord::Base] The voteable record
+    # @param suffix [Symbol, String] ID suffix (:widget, :count, :error)
+    # @param scope [String, Symbol, nil] Vote scope
+    # @return [String] The DOM ID
+    #
+    def vote_dom_id(voteable, suffix = :widget, scope: nil)
+      scope_part = scope.present? ? "_#{scope}" : ""
+      "vote_fu_#{voteable.model_name.singular}_#{voteable.id}#{scope_part}_#{suffix}"
+    end
+
+    # Checks if the current voter has voted on the voteable
+    #
+    # @param voteable [ActiveRecord::Base] The voteable record
+    # @param options [Hash] Options hash
+    # @option options [Object] :voter The voter to check
+    # @option options [Symbol] :direction :up or :down to check specific direction
+    # @option options [String, Symbol] :scope Vote scope
+    # @return [Boolean]
+    #
+    def voted_on?(voteable, options = {})
+      voter = options.fetch(:voter) { default_voter }
+      return false unless voter
+
+      voteable.voted_by?(voter, direction: options[:direction], scope: options[:scope])
+    end
+
+    # Returns the current vote direction for a voter on a voteable
+    #
+    # @param voteable [ActiveRecord::Base] The voteable record
+    # @param options [Hash] Options hash
+    # @return [Symbol, nil] :up, :down, or nil if not voted
+    #
+    def current_vote_direction(voteable, options = {})
+      voter = options.fetch(:voter) { default_voter }
+      return nil unless voter
+
+      scope = options[:scope]
+      vote = voteable.received_votes.find_by(voter: voter, scope: scope)
+      vote&.direction
+    end
+
+    private
+
+    def default_voter
+      if respond_to?(:current_user, true)
+        send(:current_user)
+      elsif defined?(Current) && Current.respond_to?(:user)
+        Current.user
+      end
+    end
+  end
+end

data/app/javascript/vote_fu/channels/consumer.js

@@ -0,0 +1,3 @@
+import { createConsumer } from "@rails/actioncable"
+
+export default createConsumer()

data/app/javascript/vote_fu/channels/index.js

@@ -0,0 +1,2 @@
+export { default as consumer } from "./consumer"
+export { subscribeToVotes, autoSubscribe } from "./votes_channel"

data/app/javascript/vote_fu/channels/votes_channel.js

@@ -0,0 +1,93 @@
+import consumer from "./consumer"
+
+/**
+ * VoteFu ActionCable Channel
+ *
+ * Subscribe to real-time vote updates for a voteable.
+ *
+ * @example
+ * import { subscribeToVotes } from "vote_fu/channels/votes_channel"
+ *
+ * const subscription = subscribeToVotes({
+ *   voteableType: "Post",
+ *   voteableId: 123,
+ *   scope: null,
+ *   onUpdate: (data) => {
+ *     console.log("Vote updated:", data)
+ *   }
+ * })
+ *
+ * // Later: subscription.unsubscribe()
+ */
+export function subscribeToVotes({ voteableType, voteableId, scope = null, onUpdate }) {
+  return consumer.subscriptions.create(
+    {
+      channel: "VoteFu::VotesChannel",
+      voteable_type: voteableType,
+      voteable_id: voteableId,
+      scope: scope
+    },
+    {
+      connected() {
+        console.log(`VoteFu: Connected to ${voteableType}#${voteableId}`)
+      },
+
+      disconnected() {
+        console.log(`VoteFu: Disconnected from ${voteableType}#${voteableId}`)
+      },
+
+      received(data) {
+        if (data.type === "vote_update") {
+          // Update DOM elements automatically
+          this.updateVoteWidget(data)
+
+          // Call custom callback
+          if (onUpdate) {
+            onUpdate(data)
+          }
+        }
+      },
+
+      updateVoteWidget(data) {
+        const { voteable_type, voteable_id, scope, stats } = data
+        const scopeSuffix = scope ? `_${scope}` : ""
+        const baseId = `vote_fu_${voteable_type.toLowerCase()}_${voteable_id}${scopeSuffix}`
+
+        // Update count display
+        const countEl = document.getElementById(`${baseId}_count`)
+        if (countEl) {
+          countEl.textContent = stats.plusminus
+          countEl.classList.add("vote-fu-count-updated")
+          setTimeout(() => countEl.classList.remove("vote-fu-count-updated"), 300)
+        }
+
+        // Dispatch custom event for advanced handling
+        document.dispatchEvent(new CustomEvent("vote-fu:updated", {
+          detail: data,
+          bubbles: true
+        }))
+      }
+    }
+  )
+}
+
+/**
+ * Auto-subscribe to all vote widgets on the page
+ *
+ * Call this on page load to automatically subscribe to all voteable elements.
+ */
+export function autoSubscribe() {
+  const widgets = document.querySelectorAll("[data-vote-fu-subscribe]")
+
+  widgets.forEach((widget) => {
+    const voteableType = widget.dataset.voteFuVoteableType
+    const voteableId = widget.dataset.voteFuVoteableId
+    const scope = widget.dataset.voteFuScope || null
+
+    if (voteableType && voteableId) {
+      subscribeToVotes({ voteableType, voteableId, scope })
+    }
+  })
+}
+
+export default { subscribeToVotes, autoSubscribe }

data/app/javascript/vote_fu/controllers/application.js

@@ -0,0 +1,9 @@
+import { Application } from "@hotwired/stimulus"
+
+const application = Application.start()
+
+// Configure Stimulus development experience
+application.debug = false
+window.Stimulus = application
+
+export { application }

data/app/javascript/vote_fu/controllers/index.js

@@ -0,0 +1,9 @@
+import { application } from "./application"
+
+import VoteFuController from "./vote_fu_controller"
+import VoteFuStarsController from "./vote_fu_stars_controller"
+import VoteFuReactionsController from "./vote_fu_reactions_controller"
+
+application.register("vote-fu", VoteFuController)
+application.register("vote-fu-stars", VoteFuStarsController)
+application.register("vote-fu-reactions", VoteFuReactionsController)

data/app/javascript/vote_fu/controllers/vote_fu_controller.js

@@ -0,0 +1,148 @@
+import { Controller } from "@hotwired/stimulus"
+
+/**
+ * VoteFu Stimulus Controller
+ *
+ * Provides optimistic UI updates for voting actions.
+ * Works with Turbo Streams for server reconciliation.
+ *
+ * @example
+ * <div data-controller="vote-fu"
+ *      data-vote-fu-voteable-type-value="Post"
+ *      data-vote-fu-voteable-id-value="123"
+ *      data-vote-fu-scope-value=""
+ *      data-vote-fu-voted-value="false"
+ *      data-vote-fu-direction-value="">
+ *   ...
+ * </div>
+ */
+export default class extends Controller {
+  static targets = ["upvoteBtn", "downvoteBtn", "likeBtn", "count"]
+
+  static values = {
+    voteableType: String,
+    voteableId: Number,
+    scope: String,
+    voted: Boolean,
+    direction: String
+  }
+
+  connect() {
+    this.originalCount = this.countTarget?.textContent?.trim()
+  }
+
+  /**
+   * Handle vote form submission with optimistic update
+   */
+  vote(event) {
+    const form = event.target.closest("form")
+    const direction = form.querySelector("[name='direction']")?.value
+
+    // Optimistic update
+    this.updateUI(direction)
+  }
+
+  /**
+   * Update UI optimistically based on vote direction
+   */
+  updateUI(direction) {
+    const wasVoted = this.votedValue
+    const previousDirection = this.directionValue
+
+    // Toggle logic
+    if (wasVoted && previousDirection === direction) {
+      // Removing vote
+      this.votedValue = false
+      this.directionValue = ""
+      this.updateCount(-this.voteIncrement(previousDirection))
+      this.clearActiveStates()
+    } else if (wasVoted && previousDirection !== direction) {
+      // Changing vote direction
+      this.directionValue = direction
+      this.updateCount(
+        this.voteIncrement(direction) - this.voteIncrement(previousDirection)
+      )
+      this.setActiveState(direction)
+    } else {
+      // New vote
+      this.votedValue = true
+      this.directionValue = direction
+      this.updateCount(this.voteIncrement(direction))
+      this.setActiveState(direction)
+    }
+  }
+
+  /**
+   * Get vote increment for a direction
+   */
+  voteIncrement(direction) {
+    return direction === "up" ? 1 : -1
+  }
+
+  /**
+   * Update the vote count display
+   */
+  updateCount(delta) {
+    if (!this.hasCountTarget) return
+
+    const currentCount = parseInt(this.countTarget.textContent, 10) || 0
+    const newCount = currentCount + delta
+    this.countTarget.textContent = newCount
+
+    // Add animation class
+    this.countTarget.classList.add("vote-fu-count-updated")
+    setTimeout(() => {
+      this.countTarget.classList.remove("vote-fu-count-updated")
+    }, 300)
+  }
+
+  /**
+   * Clear all active states from buttons
+   */
+  clearActiveStates() {
+    if (this.hasUpvoteBtnTarget) {
+      this.upvoteBtnTarget.classList.remove("vote-fu-active")
+    }
+    if (this.hasDownvoteBtnTarget) {
+      this.downvoteBtnTarget.classList.remove("vote-fu-active")
+    }
+    if (this.hasLikeBtnTarget) {
+      this.likeBtnTarget.classList.remove("vote-fu-active")
+    }
+    this.element.classList.remove("vote-fu-voted-up", "vote-fu-voted-down", "vote-fu-liked")
+  }
+
+  /**
+   * Set active state for a direction
+   */
+  setActiveState(direction) {
+    this.clearActiveStates()
+
+    if (direction === "up") {
+      if (this.hasUpvoteBtnTarget) {
+        this.upvoteBtnTarget.classList.add("vote-fu-active")
+      }
+      if (this.hasLikeBtnTarget) {
+        this.likeBtnTarget.classList.add("vote-fu-active")
+      }
+      this.element.classList.add("vote-fu-voted-up", "vote-fu-liked")
+    } else if (direction === "down") {
+      if (this.hasDownvoteBtnTarget) {
+        this.downvoteBtnTarget.classList.add("vote-fu-active")
+      }
+      this.element.classList.add("vote-fu-voted-down")
+    }
+  }
+
+  /**
+   * Reset to server state (called on Turbo Stream failure)
+   */
+  reset() {
+    if (this.hasCountTarget && this.originalCount) {
+      this.countTarget.textContent = this.originalCount
+    }
+    this.clearActiveStates()
+    this.votedValue = false
+    this.directionValue = ""
+  }
+}