vote_fu 0.0.11 → 2.0.0

data/app/components/vote_fu/reaction_bar_component.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module VoteFu
+  class ReactionBarComponent < ViewComponent::Base
+    # Reaction bar component for emoji reactions (like Slack, GitHub, etc.)
+    #
+    # Uses scoped voting where each reaction type is a scope.
+    # Vote values indicate the reaction emoji index.
+    #
+    # @param voteable [ActiveRecord::Base] The voteable record
+    # @param voter [ActiveRecord::Base, nil] The current voter
+    # @param reactions [Array<Hash>] Array of reaction configs: { emoji:, label:, scope: }
+    # @param show_counts [Boolean] Show reaction counts
+    # @param show_users [Boolean] Show who reacted (requires extra query)
+    # @param max_users [Integer] Max user names to show per reaction
+    # @param allow_multiple [Boolean] Allow user to add multiple reactions
+    def initialize(
+      voteable:,
+      voter: nil,
+      reactions: default_reactions,
+      show_counts: true,
+      show_users: false,
+      max_users: 3,
+      allow_multiple: true
+    )
+      @voteable = voteable
+      @voter = voter
+      @reactions = reactions
+      @show_counts = show_counts
+      @show_users = show_users
+      @max_users = max_users
+      @allow_multiple = allow_multiple
+    end
+
+    def call
+      tag.div(**wrapper_attributes) do
+        safe_join([
+          reactions_container,
+          (add_reaction_button if @voter && @allow_multiple)
+        ].compact)
+      end
+    end
+
+    private
+
+    def default_reactions
+      [
+        { emoji: "👍", label: "Like", scope: "like" },
+        { emoji: "❤️", label: "Love", scope: "love" },
+        { emoji: "😂", label: "Laugh", scope: "laugh" },
+        { emoji: "😮", label: "Wow", scope: "wow" },
+        { emoji: "😢", label: "Sad", scope: "sad" },
+        { emoji: "😡", label: "Angry", scope: "angry" }
+      ]
+    end
+
+    def wrapper_attributes
+      {
+        id: dom_id(:reactions),
+        class: "vote-fu-reaction-bar",
+        data: stimulus_data
+      }
+    end
+
+    def stimulus_data
+      {
+        controller: "vote-fu-reactions",
+        vote_fu_reactions_voteable_type_value: @voteable.class.name,
+        vote_fu_reactions_voteable_id_value: @voteable.id,
+        vote_fu_reactions_allow_multiple_value: @allow_multiple
+      }
+    end
+
+    def reactions_container
+      tag.div(class: "vote-fu-reactions") do
+        safe_join(@reactions.map { |reaction| reaction_button(reaction) })
+      end
+    end
+
+    def reaction_button(reaction)
+      scope = reaction[:scope]
+      count = reaction_count(scope)
+      user_reacted = user_reacted?(scope)
+
+      return nil if count.zero? && !@voter
+
+      tag.div(
+        class: reaction_wrapper_classes(user_reacted, count),
+        data: { scope: scope }
+      ) do
+        if @voter
+          interactive_reaction(reaction, count, user_reacted)
+        else
+          readonly_reaction(reaction, count)
+        end
+      end
+    end
+
+    def interactive_reaction(reaction, count, user_reacted)
+      form_with(url: toggle_path, method: :post, data: turbo_form_data) do |f|
+        safe_join([
+          f.hidden_field(:voteable_type, value: @voteable.class.name),
+          f.hidden_field(:voteable_id, value: @voteable.id),
+          f.hidden_field(:scope, value: reaction[:scope]),
+          f.hidden_field(:direction, value: :up),
+          tag.button(
+            reaction_content(reaction, count),
+            type: :submit,
+            class: reaction_button_classes(user_reacted),
+            title: reaction_title(reaction, user_reacted),
+            data: { vote_fu_reactions_target: "reaction" }
+          )
+        ])
+      end
+    end
+
+    def readonly_reaction(reaction, count)
+      tag.span(
+        reaction_content(reaction, count),
+        class: "vote-fu-reaction vote-fu-reaction--readonly",
+        title: reaction[:label]
+      )
+    end
+
+    def reaction_content(reaction, count)
+      parts = [tag.span(reaction[:emoji], class: "vote-fu-reaction-emoji")]
+      parts << tag.span(count.to_s, class: "vote-fu-reaction-count") if @show_counts && count.positive?
+
+      if @show_users && count.positive?
+        parts << tag.span(
+          reaction_users(reaction[:scope]),
+          class: "vote-fu-reaction-users"
+        )
+      end
+
+      safe_join(parts)
+    end
+
+    def reaction_wrapper_classes(user_reacted, count)
+      classes = ["vote-fu-reaction-wrapper"]
+      classes << "vote-fu-reaction-wrapper--active" if user_reacted
+      classes << "vote-fu-reaction-wrapper--empty" if count.zero?
+      classes.join(" ")
+    end
+
+    def reaction_button_classes(user_reacted)
+      classes = ["vote-fu-reaction"]
+      classes << "vote-fu-reaction--active" if user_reacted
+      classes.join(" ")
+    end
+
+    def reaction_title(reaction, user_reacted)
+      if user_reacted
+        "Remove #{reaction[:label]} reaction"
+      else
+        "React with #{reaction[:label]}"
+      end
+    end
+
+    def add_reaction_button
+      tag.div(class: "vote-fu-add-reaction") do
+        tag.button(
+          "➕",
+          class: "vote-fu-add-reaction-btn",
+          title: "Add reaction",
+          data: {
+            action: "click->vote-fu-reactions#showPicker",
+            vote_fu_reactions_target: "addButton"
+          }
+        )
+      end
+    end
+
+    def turbo_form_data
+      { turbo_stream: true, action: "submit->vote-fu-reactions#toggle" }
+    end
+
+    def reaction_count(scope)
+      @reaction_counts ||= {}
+      @reaction_counts[scope] ||= @voteable.votes_for(scope: scope)
+    end
+
+    def user_reacted?(scope)
+      return false unless @voter
+
+      @user_reactions ||= {}
+      @user_reactions[scope] ||= @voteable.voted_by?(@voter, scope: scope)
+    end
+
+    def reaction_users(scope)
+      voters = @voteable.voters_for(scope: scope).limit(@max_users)
+      names = voters.map { |v| v.try(:name) || v.try(:username) || "Someone" }
+
+      remaining = reaction_count(scope) - names.size
+      names << "#{remaining} more" if remaining.positive?
+
+      names.join(", ")
+    end
+
+    def toggle_path
+      VoteFu::Engine.routes.url_helpers.toggle_votes_path
+    end
+
+    def dom_id(suffix)
+      "vote_fu_#{@voteable.model_name.singular}_#{@voteable.id}_#{suffix}"
+    end
+  end
+end

data/app/components/vote_fu/star_rating_component.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+module VoteFu
+  class StarRatingComponent < ViewComponent::Base
+    # Star rating component for 1-5 star ratings
+    #
+    # Uses vote values 1-5 to represent star ratings.
+    #
+    # @param voteable [ActiveRecord::Base] The voteable record
+    # @param voter [ActiveRecord::Base, nil] The current voter
+    # @param scope [String, Symbol, nil] Vote scope
+    # @param max_stars [Integer] Maximum number of stars (default: 5)
+    # @param filled_star [String] Character for filled star
+    # @param empty_star [String] Character for empty star
+    # @param half_star [String] Character for half star (used in average display)
+    # @param show_average [Boolean] Show average rating
+    # @param show_count [Boolean] Show vote count
+    # @param readonly [Boolean] Disable voting (show average only)
+    def initialize(
+      voteable:,
+      voter: nil,
+      scope: nil,
+      max_stars: 5,
+      filled_star: "★",
+      empty_star: "☆",
+      half_star: "⯨",
+      show_average: true,
+      show_count: true,
+      readonly: false
+    )
+      @voteable = voteable
+      @voter = voter
+      @scope = scope
+      @max_stars = max_stars
+      @filled_star = filled_star
+      @empty_star = empty_star
+      @half_star = half_star
+      @show_average = show_average
+      @show_count = show_count
+      @readonly = readonly
+    end
+
+    def call
+      tag.div(**wrapper_attributes) do
+        safe_join([
+          star_container,
+          (rating_info if @show_average || @show_count)
+        ].compact)
+      end
+    end
+
+    private
+
+    def wrapper_attributes
+      {
+        id: dom_id(:widget),
+        class: wrapper_classes,
+        data: stimulus_data
+      }
+    end
+
+    def wrapper_classes
+      classes = ["vote-fu-star-rating"]
+      classes << "vote-fu-star-rating--readonly" if @readonly || @voter.nil?
+      classes << "vote-fu-star-rating--voted" if current_vote.present?
+      classes.join(" ")
+    end
+
+    def stimulus_data
+      {
+        controller: "vote-fu-stars",
+        vote_fu_stars_voteable_type_value: @voteable.class.name,
+        vote_fu_stars_voteable_id_value: @voteable.id,
+        vote_fu_stars_scope_value: @scope,
+        vote_fu_stars_current_rating_value: current_rating,
+        vote_fu_stars_max_stars_value: @max_stars
+      }
+    end
+
+    def star_container
+      tag.div(class: "vote-fu-stars") do
+        if interactive?
+          interactive_stars
+        else
+          readonly_stars
+        end
+      end
+    end
+
+    def interactive_stars
+      safe_join(
+        (1..@max_stars).map { |value| interactive_star(value) }
+      )
+    end
+
+    def interactive_star(value)
+      form_with(url: vote_path, method: :post, data: turbo_form_data) do |f|
+        safe_join([
+          f.hidden_field(:voteable_type, value: @voteable.class.name),
+          f.hidden_field(:voteable_id, value: @voteable.id),
+          f.hidden_field(:scope, value: @scope),
+          f.hidden_field(:value, value: value),
+          tag.button(
+            value <= current_rating ? @filled_star : @empty_star,
+            type: :submit,
+            class: star_button_classes(value),
+            title: "Rate #{value} star#{value == 1 ? "" : "s"}",
+            data: {
+              vote_fu_stars_target: "star",
+              star_value: value
+            }
+          )
+        ])
+      end
+    end
+
+    def readonly_stars
+      safe_join(
+        (1..@max_stars).map { |value| readonly_star(value) }
+      )
+    end
+
+    def readonly_star(value)
+      avg = average_rating
+      star_char = if value <= avg.floor
+                    @filled_star
+                  elsif value - 0.5 <= avg
+                    @half_star
+                  else
+                    @empty_star
+                  end
+
+      tag.span(star_char, class: star_classes(value, avg))
+    end
+
+    def star_button_classes(value)
+      classes = ["vote-fu-star-btn"]
+      classes << "vote-fu-star-filled" if value <= current_rating
+      classes.join(" ")
+    end
+
+    def star_classes(value, avg)
+      classes = ["vote-fu-star"]
+      classes << "vote-fu-star-filled" if value <= avg.floor
+      classes << "vote-fu-star-half" if value > avg.floor && value - 0.5 <= avg
+      classes.join(" ")
+    end
+
+    def rating_info
+      tag.div(class: "vote-fu-star-info") do
+        parts = []
+        parts << tag.span("#{average_rating.round(1)}", class: "vote-fu-star-average") if @show_average
+        parts << tag.span("(#{vote_count})", class: "vote-fu-star-count") if @show_count
+        safe_join(parts, " ")
+      end
+    end
+
+    def turbo_form_data
+      { turbo_stream: true, action: "submit->vote-fu-stars#rate" }
+    end
+
+    def interactive?
+      !@readonly && @voter.present?
+    end
+
+    def current_vote
+      return @current_vote if defined?(@current_vote)
+
+      @current_vote = @voter && @voteable.received_votes.find_by(
+        voter: @voter,
+        scope: @scope
+      )
+    end
+
+    def current_rating
+      current_vote&.value.to_i
+    end
+
+    def average_rating
+      return @average_rating if defined?(@average_rating)
+
+      votes = @voteable.received_votes.with_scope(@scope)
+      @average_rating = votes.any? ? votes.average(:value).to_f : 0.0
+    end
+
+    def vote_count
+      @voteable.received_votes.with_scope(@scope).count
+    end
+
+    def vote_path
+      VoteFu::Engine.routes.url_helpers.votes_path
+    end
+
+    def dom_id(suffix)
+      scope_part = @scope.present? ? "_#{@scope}" : ""
+      "vote_fu_#{@voteable.model_name.singular}_#{@voteable.id}#{scope_part}_#{suffix}"
+    end
+  end
+end

data/app/components/vote_fu/vote_widget_component.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module VoteFu
+  class VoteWidgetComponent < ViewComponent::Base
+    # The voteable record
+    attr_reader :voteable
+
+    # @param voteable [ActiveRecord::Base] The voteable record
+    # @param voter [ActiveRecord::Base, nil] The current voter
+    # @param scope [String, Symbol, nil] Vote scope for scoped voting
+    # @param variant [Symbol] Widget style (:default, :compact, :vertical, :large)
+    # @param upvote_label [String] Upvote button label
+    # @param downvote_label [String] Downvote button label
+    # @param show_count [Boolean] Whether to show vote count
+    # @param count_format [Symbol] Count format (:plusminus, :total, :split)
+    def initialize(
+      voteable:,
+      voter: nil,
+      scope: nil,
+      variant: :default,
+      upvote_label: "▲",
+      downvote_label: "▼",
+      show_count: true,
+      count_format: :plusminus
+    )
+      @voteable = voteable
+      @voter = voter
+      @scope = scope
+      @variant = variant
+      @upvote_label = upvote_label
+      @downvote_label = downvote_label
+      @show_count = show_count
+      @count_format = count_format
+    end
+
+    def call
+      tag.div(**wrapper_attributes) do
+        safe_join([
+          upvote_button,
+          (count_display if @show_count),
+          downvote_button
+        ].compact)
+      end
+    end
+
+    private
+
+    def wrapper_attributes
+      {
+        id: dom_id(:widget),
+        class: wrapper_classes,
+        data: stimulus_data
+      }
+    end
+
+    def wrapper_classes
+      classes = ["vote-fu-widget"]
+      classes << "vote-fu-widget--#{@variant}" unless @variant == :default
+      classes << "vote-fu-voted-up" if voted_up?
+      classes << "vote-fu-voted-down" if voted_down?
+      classes.join(" ")
+    end
+
+    def stimulus_data
+      {
+        controller: "vote-fu",
+        vote_fu_voteable_type_value: @voteable.class.name,
+        vote_fu_voteable_id_value: @voteable.id,
+        vote_fu_scope_value: @scope,
+        vote_fu_voted_value: current_vote.present?,
+        vote_fu_direction_value: current_vote&.direction
+      }
+    end
+
+    def upvote_button
+      if @voter
+        form_with(url: toggle_path, method: :post, data: turbo_form_data) do |f|
+          safe_join([
+            f.hidden_field(:voteable_type, value: @voteable.class.name),
+            f.hidden_field(:voteable_id, value: @voteable.id),
+            f.hidden_field(:scope, value: @scope),
+            f.hidden_field(:direction, value: :up),
+            tag.button(
+              @upvote_label,
+              type: :submit,
+              class: upvote_button_classes,
+              title: voted_up? ? "Remove upvote" : "Upvote",
+              data: { vote_fu_target: "upvoteBtn" }
+            )
+          ])
+        end
+      else
+        tag.span(@upvote_label, class: "vote-fu-btn vote-fu-upvote vote-fu-disabled")
+      end
+    end
+
+    def downvote_button
+      if @voter
+        form_with(url: toggle_path, method: :post, data: turbo_form_data) do |f|
+          safe_join([
+            f.hidden_field(:voteable_type, value: @voteable.class.name),
+            f.hidden_field(:voteable_id, value: @voteable.id),
+            f.hidden_field(:scope, value: @scope),
+            f.hidden_field(:direction, value: :down),
+            tag.button(
+              @downvote_label,
+              type: :submit,
+              class: downvote_button_classes,
+              title: voted_down? ? "Remove downvote" : "Downvote",
+              data: { vote_fu_target: "downvoteBtn" }
+            )
+          ])
+        end
+      else
+        tag.span(@downvote_label, class: "vote-fu-btn vote-fu-downvote vote-fu-disabled")
+      end
+    end
+
+    def count_display
+      tag.span(
+        formatted_count,
+        id: dom_id(:count),
+        class: "vote-fu-count",
+        data: { vote_fu_target: "count" }
+      )
+    end
+
+    def formatted_count
+      case @count_format
+      when :total
+        @voteable.votes_total(scope: @scope)
+      when :split
+        "+#{@voteable.votes_for(scope: @scope)} / -#{@voteable.votes_against(scope: @scope)}"
+      else
+        @voteable.plusminus(scope: @scope)
+      end
+    end
+
+    def upvote_button_classes
+      classes = ["vote-fu-btn", "vote-fu-upvote"]
+      classes << "vote-fu-active" if voted_up?
+      classes.join(" ")
+    end
+
+    def downvote_button_classes
+      classes = ["vote-fu-btn", "vote-fu-downvote"]
+      classes << "vote-fu-active" if voted_down?
+      classes.join(" ")
+    end
+
+    def turbo_form_data
+      { turbo_stream: true, action: "submit->vote-fu#vote" }
+    end
+
+    def current_vote
+      return @current_vote if defined?(@current_vote)
+
+      @current_vote = @voter && @voteable.received_votes.find_by(
+        voter: @voter,
+        scope: @scope
+      )
+    end
+
+    def voted_up?
+      current_vote&.up?
+    end
+
+    def voted_down?
+      current_vote&.down?
+    end
+
+    def toggle_path
+      VoteFu::Engine.routes.url_helpers.toggle_votes_path
+    end
+
+    def dom_id(suffix)
+      scope_part = @scope.present? ? "_#{@scope}" : ""
+      "vote_fu_#{@voteable.model_name.singular}_#{@voteable.id}#{scope_part}_#{suffix}"
+    end
+  end
+end

data/app/controllers/vote_fu/application_controller.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module VoteFu
+  class ApplicationController < ::ApplicationController
+    protect_from_forgery with: :exception
+
+    private
+
+    def find_voteable
+      @voteable_type = params[:voteable_type]
+      @voteable_id = params[:voteable_id]
+
+      unless @voteable_type.present? && @voteable_id.present?
+        raise VoteFu::Errors::VoteableNotFound, "voteable_type and voteable_id are required"
+      end
+
+      begin
+        @voteable_class = @voteable_type.constantize
+      rescue NameError
+        raise VoteFu::Errors::VoteableNotFound, "Unknown voteable type: #{@voteable_type}"
+      end
+
+      @voteable = @voteable_class.find_by(id: @voteable_id)
+      raise VoteFu::Errors::VoteableNotFound, "Voteable not found" unless @voteable
+    end
+
+    def current_voter
+      # Override this in your ApplicationController to return the current user
+      # Default implementation tries common patterns
+      return @current_voter if defined?(@current_voter)
+
+      @current_voter = if respond_to?(:current_user, true)
+                         send(:current_user)
+                       elsif defined?(Current) && Current.respond_to?(:user)
+                         Current.user
+                       end
+    end
+
+    def require_voter!
+      return if current_voter.present?
+
+      respond_to do |format|
+        format.turbo_stream { head :unauthorized }
+        format.html { redirect_to main_app.root_path, alert: "You must be signed in to vote" }
+        format.json { render json: { error: "Unauthorized" }, status: :unauthorized }
+      end
+    end
+  end
+end