thumbsy 1.0.0

data/lib/thumbsy/api/configuration.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Thumbsy
+  module Api
+    class Configuration
+      attr_accessor :require_authentication, :authentication_method, :current_voter_method, :require_authorization,
+                    :authorization_method, :voter_serializer
+
+      def initialize
+        @require_authentication = true
+        @require_authorization = false
+        @authentication_method = nil
+        @current_voter_method = nil
+        @authorization_method = nil
+        @voter_serializer = nil
+      end
+    end
+  end
+end

data/lib/thumbsy/api/controllers/application_controller.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Thumbsy
+  module Api
+    class ApplicationController < ActionController::API
+      before_action :authenticate_voter!, if: :authentication_required?
+      before_action :set_current_voter
+
+      rescue_from ActiveRecord::RecordNotFound, with: :render_not_found
+
+      protected
+
+      def authenticate_voter!
+        if Thumbsy::Api.authentication_method
+          instance_eval(&Thumbsy::Api.authentication_method)
+        else
+          head :unauthorized unless current_voter.present?
+        end
+      end
+
+      def set_current_voter
+        if Thumbsy::Api.current_voter_method
+          @current_voter = instance_eval(&Thumbsy::Api.current_voter_method)
+        elsif respond_to?(:current_user)
+          @current_voter = current_user
+        end
+      end
+
+      attr_reader :current_voter
+
+      def authentication_required?
+        Thumbsy::Api.require_authentication
+      end
+
+      def render_success(data = {}, status = :ok)
+        render json: { data: data }, status: status
+      end
+
+      def render_error(message, status = :bad_request, errors = {})
+        # Convert errors to array format
+        error_array = if errors.is_a?(Hash) && errors.any?
+                        errors.values.flatten
+                      else
+                        []
+                      end
+        render json: { error: message, errors: error_array }, status: status
+      end
+
+      def render_not_found(_exception)
+        render_error("Resource not found", :not_found)
+      end
+
+      def render_unauthorized(message = "Authentication required")
+        render_error(message, :unauthorized)
+      end
+
+      def render_forbidden(message = "Access denied")
+        render_error(message, :forbidden)
+      end
+
+      def render_unprocessable_entity(message = "Validation failed", errors = {})
+        render_error(message, :unprocessable_entity, errors)
+      end
+
+      def render_bad_request(message = "Bad request")
+        render_error(message, :bad_request)
+      end
+    end
+  end
+end

data/lib/thumbsy/api/controllers/votes_controller.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Thumbsy
+  module Api
+    class VotesController < Thumbsy::Api::ApplicationController
+      before_action :find_votable
+      before_action :check_votable_permissions, if: :authorization_required?
+
+      # POST /votes/vote_up
+      def vote_up
+        vote = @votable.vote_up(current_voter, comment: vote_params[:comment],
+                                               feedback_options: vote_params[:feedback_options])
+
+        if vote&.persisted? && vote.errors.empty?
+          render_success(Thumbsy::Api::Serializers::VoteSerializer.new(vote).as_json, :created)
+        else
+          render_unprocessable_entity("Failed to create vote", vote&.errors&.full_messages || [])
+        end
+      end
+
+      # POST /votes/vote_down
+      def vote_down
+        vote = @votable.vote_down(current_voter, comment: vote_params[:comment],
+                                                 feedback_options: vote_params[:feedback_options])
+
+        if vote&.persisted? && vote.errors.empty?
+          render_success(Thumbsy::Api::Serializers::VoteSerializer.new(vote).as_json, :created)
+        else
+          render_unprocessable_entity("Failed to create vote", vote&.errors&.full_messages || [])
+        end
+      end
+
+      # DELETE /votes/remove
+      def remove
+        removed = @votable.remove_vote(current_voter)
+
+        if removed
+          render_success({ message: "Vote removed" })
+        else
+          render_not_found(nil)
+        end
+      end
+
+      # GET /votes/status
+      def status
+        vote = @votable.vote_by(current_voter)
+
+        data = {
+          voted: @votable.voted_by?(current_voter),
+          vote_type: if vote
+                       vote.up_vote? ? "up" : "down"
+                     end,
+          comment: vote&.comment,
+          vote_counts: {
+            total: @votable.votes_count,
+            up: @votable.up_votes_count,
+            down: @votable.down_votes_count,
+            score: @votable.votes_score,
+          },
+        }
+
+        render_success(data)
+      end
+
+      # GET /votes/vote
+      def show
+        vote = @votable.vote_by(current_voter)
+        if vote
+          render_success(Thumbsy::Api::Serializers::VoteSerializer.new(vote).as_json)
+        else
+          render_not_found(nil)
+        end
+      end
+
+      # GET /votes
+      def index
+        votes = filtered_votes
+        data = {
+          votes: votes.map { |vote| Thumbsy::Api::Serializers::VoteSerializer.new(vote).as_json },
+          summary: vote_summary,
+        }
+
+        render_success(data)
+      end
+
+      private
+
+      def filtered_votes
+        votes = @votable.thumbsy_votes.includes(:voter)
+        votes = votes.with_comments if params[:with_comments] == "true"
+        votes = votes.up_votes if params[:vote_type] == "up"
+        votes = votes.down_votes if params[:vote_type] == "down"
+        votes
+      end
+
+      def vote_summary
+        {
+          total: @votable.votes_count,
+          up: @votable.up_votes_count,
+          down: @votable.down_votes_count,
+          score: @votable.votes_score,
+        }
+      end
+
+      def find_votable
+        votable_class = params[:votable_type].constantize
+        @votable = votable_class.find(params[:votable_id])
+      rescue NameError
+        render_bad_request("Invalid votable type")
+      rescue ActiveRecord::RecordNotFound
+        render_not_found(nil)
+      end
+
+      def check_votable_permissions
+        return unless Thumbsy::Api.authorization_method
+
+        authorized = instance_exec(@votable, current_voter, &Thumbsy::Api.authorization_method)
+        render_forbidden unless authorized
+      end
+
+      def authorization_required?
+        Thumbsy::Api.require_authorization
+      end
+
+      def vote_params
+        permitted = params.permit(:comment, { feedback_options: [] }, :feedback_option, :votable_type, :votable_id)
+        # Normalize feedback_option (string) to feedback_options (array)
+        if permitted[:feedback_options].blank? && permitted[:feedback_option].present?
+          permitted[:feedback_options] = [permitted.delete(:feedback_option)]
+        end
+        permitted
+      end
+    end
+  end
+end

data/lib/thumbsy/api/engine.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Thumbsy
+  module Api
+    class Engine < ::Rails::Engine
+      isolate_namespace Thumbsy::Api
+
+      # Load API routes from routes.rb file
+      config.after_initialize do
+        require "thumbsy/api/routes"
+      end
+    end
+  end
+end

data/lib/thumbsy/api/routes.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+Thumbsy::Api::Engine.routes.draw do
+  # Flexible routes that can be mounted anywhere
+  scope ":votable_type/:votable_id" do
+    post "votes/vote_up", to: "votes#vote_up"
+    post "votes/vote_down", to: "votes#vote_down"
+    delete "votes/remove", to: "votes#remove"
+    get "votes/status", to: "votes#status"
+    get "votes/vote", to: "votes#show"
+    get "votes", to: "votes#index"
+
+    # Alternative shorter routes
+    post "vote_up", to: "votes#vote_up"
+    post "vote_down", to: "votes#vote_down"
+    delete "vote", to: "votes#remove"
+    get "vote", to: "votes#show"
+  end
+
+  # Bulk operations (optional)
+  resources :votes, only: %i[index show] do
+    collection do
+      get :summary
+    end
+  end
+end

data/lib/thumbsy/api/serializers/vote_serializer.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Thumbsy
+  module Api
+    module Serializers
+      class VoteSerializer
+        def initialize(vote)
+          @vote = vote
+        end
+
+        def as_json
+          {
+            id: @vote.id,
+            vote_type: @vote.up_vote? ? "up" : "down",
+            comment: @vote.comment,
+            feedback_options: @vote.feedback_options || [],
+            voter: voter_data(@vote.voter),
+          }
+        end
+
+        private
+
+        def voter_data(voter)
+          if Thumbsy::Api.voter_serializer
+            instance_exec(voter, &Thumbsy::Api.voter_serializer)
+          else
+            {
+              id: voter.id,
+              type: voter.class.name,
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/thumbsy/api.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Thumbsy
+  module Api
+    def self.require_authentication
+      Thumbsy.api_config.require_authentication
+    end
+
+    def self.authentication_method
+      Thumbsy.api_config.authentication_method
+    end
+
+    def self.current_voter_method
+      Thumbsy.api_config.current_voter_method
+    end
+
+    def self.require_authorization
+      Thumbsy.api_config.require_authorization
+    end
+
+    def self.require_authorization=(value)
+      Thumbsy.api_config.require_authorization = value
+    end
+
+    def self.authorization_method
+      Thumbsy.api_config.authorization_method
+    end
+
+    def self.authorization_method=(value)
+      Thumbsy.api_config.authorization_method = value
+    end
+
+    def self.voter_serializer
+      Thumbsy.api_config.voter_serializer
+    end
+
+    def self.voter_serializer=(value)
+      Thumbsy.api_config.voter_serializer = value
+    end
+
+    def self.configure
+      yield(Thumbsy.api_config)
+    end
+
+    # Load API components
+    def self.load!
+      require "thumbsy/api/engine"
+      require "thumbsy/api/controllers/application_controller"
+      require "thumbsy/api/controllers/votes_controller"
+      require "thumbsy/api/serializers/vote_serializer"
+    end
+
+    # Custom exceptions
+    class AuthenticationError < StandardError; end
+    class AuthorizationError < StandardError; end
+  end
+end

data/lib/thumbsy/configuration.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Thumbsy
+  class Configuration
+    attr_accessor :api_config
+
+    def initialize
+      @api_config = Thumbsy::Api::Configuration.new
+    end
+
+    def api
+      yield @api_config if block_given?
+      @api_config
+    end
+
+    def feedback_options=(options)
+      @feedback_options = options
+      # Automatically set up validation if ThumbsyVote is loaded
+      ThumbsyVote.setup_feedback_options_validation! if defined?(ThumbsyVote)
+    end
+
+    attr_reader :feedback_options
+  end
+end

data/lib/thumbsy/engine.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Thumbsy
+  # Only define Rails engine when Rails is available
+  if defined?(Rails)
+    class Engine < ::Rails::Engine
+      isolate_namespace Thumbsy
+
+      config.generators do |g|
+        g.test_framework :rspec
+      end
+
+      initializer "thumbsy.active_record" do
+        ActiveSupport.on_load(:active_record) do
+          extend Thumbsy::Extension
+        end
+      end
+    end
+  end
+end

data/lib/thumbsy/extension.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Thumbsy
+  module Extension
+    def votable(_options = {})
+      include Thumbsy::Votable
+    end
+
+    def voter(_options = {})
+      include Thumbsy::Voter
+    end
+  end
+end

data/lib/thumbsy/models/thumbsy_vote.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "active_record"
+require_relative "../validators/array_inclusion_validator"
+
+class ThumbsyVote < ActiveRecord::Base
+  serialize :feedback_options
+
+  after_initialize :set_default_feedback_options
+
+  def feedback_options=(value)
+    super(value.nil? ? [] : value)
+  end
+
+  # Dynamically (re)setup feedback_options validation
+  def self.setup_feedback_options_validation!
+    return unless Thumbsy.feedback_options.present?
+
+    _validators.delete(:feedback_options)
+    validates :feedback_options, array_inclusion: { in: Thumbsy.feedback_options }, allow_nil: false
+  end
+
+  belongs_to :votable, polymorphic: true
+  belongs_to :voter, polymorphic: true
+
+  validates :votable, presence: true
+  validates :voter, presence: true
+  validates :vote, inclusion: { in: [true, false] }
+  validates :voter_id, uniqueness: { scope: %i[voter_type votable_type votable_id] }
+
+  scope :up_votes, -> { where(vote: true) }
+  scope :down_votes, -> { where(vote: false) }
+  scope :with_comments, -> { where.not(comment: [nil, ""]) }
+
+  def up_vote?
+    vote == true
+  end
+
+  def down_vote?
+    vote == false
+  end
+
+  def self.vote_for(votable, voter, vote_value, comment: nil, feedback_options: nil)
+    raise ArgumentError, "Voter cannot be nil" if voter.nil?
+    raise ArgumentError, "Votable cannot be nil" if votable.nil?
+
+    existing_vote = find_by(
+      votable: votable,
+      voter: voter,
+    )
+
+    if existing_vote
+      existing_vote.update!(
+        vote: vote_value,
+        comment: comment,
+        feedback_options: feedback_options,
+      )
+      existing_vote
+    else
+      create!(
+        votable: votable,
+        voter: voter,
+        vote: vote_value,
+        comment: comment,
+        feedback_options: feedback_options,
+      )
+    end
+  end
+
+  private
+
+  def set_default_feedback_options
+    self.feedback_options = [] if feedback_options.nil?
+  end
+end

data/lib/thumbsy/validators/array_inclusion_validator.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Thumbsy
+  class InvalidFeedbackOptionError < ArgumentError; end
+end
+
+module ActiveModel
+  module Validations
+    class ArrayInclusionValidator < EachValidator
+      def validate_each(record, attribute, value)
+        return if value.nil?
+
+        allowed = options[:in] || []
+        return if value.is_a?(Array) && value.all? { |v| allowed.include?(v) }
+
+        record.errors.add(attribute, "contains invalid feedback option(s)")
+      end
+    end
+  end
+end

data/lib/thumbsy/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Thumbsy
+  VERSION = "1.0.0"
+end

data/lib/thumbsy/votable.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Thumbsy
+  module Votable
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :thumbsy_votes, as: :votable, class_name: "ThumbsyVote", dependent: :destroy
+      scope :with_votes, -> { joins(:thumbsy_votes) }
+      scope :with_up_votes, -> { joins(:thumbsy_votes).where(thumbsy_votes: { vote: true }) }
+      scope :with_down_votes, -> { joins(:thumbsy_votes).where(thumbsy_votes: { vote: false }) }
+      scope :with_comments, -> { joins(:thumbsy_votes).where.not(thumbsy_votes: { comment: [nil, ""] }) }
+    end
+
+    def vote_up(voter, comment: nil, feedback_options: nil)
+      return false if voter && !voter.respond_to?(:thumbsy_votes)
+
+      ThumbsyVote.vote_for(self, voter, true, comment: comment, feedback_options: feedback_options)
+    rescue ActiveRecord::RecordInvalid => e
+      e.record # Return the invalid vote instance with errors
+    end
+
+    def vote_down(voter, comment: nil, feedback_options: nil)
+      raise ArgumentError, "Voter is invalid" if voter && !voter.respond_to?(:thumbsy_votes)
+
+      ThumbsyVote.vote_for(self, voter, false, comment: comment, feedback_options: feedback_options)
+    rescue ActiveRecord::RecordInvalid => e
+      e.record # Return the invalid vote instance with errors
+    end
+
+    # rubocop:disable Naming/PredicateMethod
+    def remove_vote(voter)
+      destroyed = thumbsy_votes.where(voter: voter).destroy_all
+      destroyed.any?
+    end
+    # rubocop:enable Naming/PredicateMethod
+
+    def voted_by?(voter)
+      thumbsy_votes.exists?(voter: voter)
+    end
+
+    def up_voted_by?(voter)
+      thumbsy_votes.exists?(voter: voter, vote: true)
+    end
+
+    def down_voted_by?(voter)
+      thumbsy_votes.exists?(voter: voter, vote: false)
+    end
+
+    def vote_by(voter)
+      thumbsy_votes.find_by(voter: voter)
+    end
+
+    def votes_count
+      thumbsy_votes.count
+    end
+
+    def up_votes_count
+      thumbsy_votes.where(vote: true).count
+    end
+
+    def down_votes_count
+      thumbsy_votes.where(vote: false).count
+    end
+
+    def votes_score
+      up_votes_count - down_votes_count
+    end
+
+    def votes_with_comments
+      thumbsy_votes.where.not(comment: [nil, ""])
+    end
+
+    def up_votes_with_comments
+      thumbsy_votes.where(vote: true).where.not(comment: [nil, ""])
+    end
+
+    def down_votes_with_comments
+      thumbsy_votes.where(vote: false).where.not(comment: [nil, ""])
+    end
+  end
+end

data/lib/thumbsy/voter.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Thumbsy
+  module Voter
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :thumbsy_votes, as: :voter, class_name: "ThumbsyVote", dependent: :destroy
+    end
+
+    def vote_up_for(votable, comment: nil)
+      return false unless votable.respond_to?(:thumbsy_votes)
+
+      votable.vote_up(self, comment: comment)
+    end
+
+    def vote_down_for(votable, comment: nil)
+      return false unless votable.respond_to?(:thumbsy_votes)
+
+      votable.vote_down(self, comment: comment)
+    end
+
+    def remove_vote_for(votable)
+      return false unless votable.respond_to?(:thumbsy_votes)
+
+      votable.remove_vote(self)
+    end
+
+    def voted_for?(votable)
+      return false unless votable.respond_to?(:thumbsy_votes)
+
+      votable.voted_by?(self)
+    end
+
+    def up_voted_for?(votable)
+      return false unless votable.respond_to?(:thumbsy_votes)
+
+      votable.up_voted_by?(self)
+    end
+
+    def down_voted_for?(votable)
+      return false unless votable.respond_to?(:thumbsy_votes)
+
+      votable.down_voted_by?(self)
+    end
+
+    def voted_for(votable_class)
+      vote_records = thumbsy_votes.where(votable_type: votable_class.name)
+      votable_ids = vote_records.pluck(:votable_id)
+      votable_class.where(id: votable_ids)
+    end
+
+    def up_voted_for_class(votable_class)
+      vote_records = thumbsy_votes.where(votable_type: votable_class.name, vote: true)
+      votable_ids = vote_records.pluck(:votable_id)
+      votable_class.where(id: votable_ids)
+    end
+
+    def down_voted_for_class(votable_class)
+      vote_records = thumbsy_votes.where(votable_type: votable_class.name, vote: false)
+      votable_ids = vote_records.pluck(:votable_id)
+      votable_class.where(id: votable_ids)
+    end
+  end
+end