ballot 1.0

data/lib/generators/ballot.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+##
+module Ballot
+  # The namespace for Ballot generators for Rails.
+  module Generators
+    ##
+    # :attr_reader:
+    # The ORM to use when generating the migrations.
+    def orm
+      if defined?(::Rails::Generators.options)
+        ::Rails::Generators.options[:rails][:orm]
+      else
+        @orm || :active_record
+      end
+    end
+
+    ##
+    # Set the ORM to use when generating the migrations. Ignored under Rails.
+    attr_writer :orm
+
+    # The source root for the generator templates.
+    def source_root
+      File.expand_path(
+        File.join('..', 'ballot', generator_name, 'templates', orm.to_s),
+        __FILE__
+      )
+    end
+
+    # Indicates whether the ORM is supported by these generators.
+    def orm_has_migration?
+      %i(active_record sequel).include? orm
+    end
+
+    # The next migration number.
+    def next_migration_number(_path)
+      Time.now.utc.strftime('%Y%m%d%H%M%S')
+    end
+  end
+end

data/lib/generators/ballot/install/install_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'generators/ballot'
+
+##
+module Ballot
+  module Generators
+    # The Rails generator to install the ballot_votes table.
+    class InstallGenerator < ::Rails::Generators::Base
+      include ::Rails::Generators::Migration if defined?(::Rails::Generators::Migration)
+      extend Ballot::Generators
+
+      desc <<-DESC
+Description:
+    Create the ballot_votes migration.
+      DESC
+
+      def create_migration_file #:nodoc:
+        if self.class.orm_has_migration?
+          migration_template 'migration.rb', 'db/migrate/install_ballot_vote_migration.rb'
+        else
+          warn "Unsupported ORM #{self.class.orm}"
+        end
+      end
+    end
+  end
+end

data/lib/generators/ballot/install/templates/active_record/migration.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class InstallBallotVoteMigration < ActiveRecord::Migration
+  def change
+    create_table :ballot_votes do |t|
+      t.references :votable, polymorphic: true
+      t.references :voter, polymorphic: true
+
+      t.boolean :vote, null: false, default: true
+      t.string :scope
+      t.integer :weight
+
+      t.timestamps null: false
+    end
+
+    add_index :ballot_votes, %i(voter_id voter_type scope)
+    add_index :ballot_votes, %i(votable_id votable_type scope)
+  end
+end

data/lib/generators/ballot/install/templates/sequel/migration.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  change do
+    create_table :ballot_votes do
+      primary_key :id
+
+      Integer :votable_id
+      String :votable_type
+
+      Integer :voter_id
+      String :voter_type
+
+      Boolean :vote, null: false, default: true
+      String :scope
+      Integer :weight
+
+      DateTime :created_at, null: false, default: Sequel::CURRENT_TIMESTAMP
+      DateTime :updated_at, null: false, default: Sequel::CURRENT_TIMESTAMP
+
+      add_index %i(votable_type votable_id scope), name: :ballot_votes_votable_by_scope
+      add_index %i(voter_type voter_id scope), name: :ballot_votes_voter_by_scope
+    end
+  end
+end

data/lib/generators/ballot/standalone.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+#:nocov:
+
+##
+module Ballot
+  module Generators
+    # The Ballot standalone generator.
+    class Standalone
+      # Create and run the standalone generator with the command-line arguments.
+      def self.run(argv)
+        new(argv).run
+      end
+
+      # The arguments provided to the Standalone generator.
+      attr_reader :argv
+
+      # Create the standalone generator.
+      def initialize(argv)
+        @argv = argv
+      end
+
+      # Run the standalone generator.
+      def run
+        op = OptionParser.new { |opts|
+          opts.banner = 'Usage: ballot_generator [options]'
+
+          opts.on('--orm ORM', %w(active_record sequel), 'Select the ORM') do |orm|
+            @orm = orm.to_sym
+          end
+          opts.on(
+            '--install', '-I',
+            Ballot::Generators::InstallGenerator.desc
+          ) do
+            if generator && !generator.kind_of?(Ballot::Generators::InstallGenerator)
+              warn 'Can only select one generator to run.'
+              $stderr.puts opts
+              return 1
+            else
+              self.generator = Ballot::Generators::InstallGenerator.new
+            end
+          end
+          opts.on(
+            '--summary NAME', '-S',
+            Ballot::Generators::SummaryGenerator.desc
+          ) do |name|
+            if generator && !generator.kind_of?(Ballot::Generators::SummaryGenerator)
+              warn 'Can only select one generator to run.'
+              $stderr.puts opts
+              return 1
+            else
+              self.generator = Ballot::Generators::SummaryGenerator.new(name)
+            end
+          end
+
+          opts.on('-h', '--help', 'Prints this help') do
+            $stdout.puts opts
+            return 1
+          end
+        }
+        op.parse!(argv)
+
+        if generator
+          generator.class.orm = @orm if @orm
+          generator.create_migration_file
+        else
+          $stdout.puts op
+        end
+
+        0
+      rescue => ex
+        $stderr.puts ex.message
+        return 1
+      end
+
+      private
+
+      attr_accessor :generator
+    end
+  end
+end
+
+require_relative 'standalone/support'
+require_relative 'install/install_generator'
+require_relative 'summary/summary_generator'
+
+#:nocov:

data/lib/generators/ballot/standalone/support.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+#:nocov:
+#:stopdoc:
+
+# Everything in this file is wrong, except that it does the right thing to
+# simplify the overall implementation of standalone generators.
+module Rails
+  module Generators
+    # Implement just enough of Generators to be useful.
+    class Base #:nodoc:
+      def self.desc(value = nil)
+        @desc = value.gsub(/^Description:\n\s+/, '').chomp if value
+        @desc
+      end
+
+      def self.generator_name
+        name.split(/::/).last.sub(/Generator/, '').downcase
+      end
+
+      attr_reader :argv
+      attr_accessor :destination
+
+      def migration_template(source, target)
+        data = File.read(File.join(self.class.source_root, source))
+        data = ERB.new(data, 0, '%<>>-').result(binding)
+
+        path, file = File.split(target)
+
+        file = "#{self.class.next_migration_number(nil)}_#{file}"
+
+        File.write(File.join(destination || path, file), data)
+      end
+    end
+
+    class NamedBase < Base #:nodoc:
+      def initialize(name)
+        @name = prepare_name(name)
+      end
+
+      def plural_table_name
+        "#{@name}s"
+      end
+
+      def class_name
+        @name.gsub(/^(.)|_(.)/) { (Regexp.last_match(1) || Regexp.last_match(2)).upcase }
+      end
+
+      def file_name
+        @name
+      end
+
+      private
+
+      def prepare_name(name)
+        name.split(/::/).
+          last.
+          gsub(/([A-Z])/, '_\1').
+          downcase.
+          sub(/^_/, '').
+          sub(/s$/, '')
+      end
+    end
+  end
+end
+
+#:startdoc:
+#:nocov:

data/lib/generators/ballot/summary/summary_generator.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'generators/ballot'
+
+##
+module Ballot
+  module Generators
+    # The Rails generator to install the cache_ballot_summary column on the
+    # indicated table.
+    class SummaryGenerator < ::Rails::Generators::NamedBase
+      include ::Rails::Generators::Migration if defined?(::Rails::Generators::Migration)
+      extend Ballot::Generators
+
+      desc <<-DESC
+Description:
+    Create a migration to add cached ballot summaries to the named table.
+      DESC
+
+      def create_migration_file #:nodoc:
+        if self.class.orm_has_migration?
+          migration_template 'migration.rb',
+            "db/migrate/ballot_cache_for_#{file_name}.rb"
+        end
+      end
+    end
+  end
+end

data/lib/generators/ballot/summary/templates/active_record/migration.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class BallotCacheFor<%= class_name %> < ActiveRecord::Migration
+  def change
+    change_table :'<%= plural_table_name %>' do |t|
+      if t.respond_to?(:jsonb)
+        t.jsonb :cached_ballot_summary, null: false, default: {}
+      elsif t.respond_to?(:json)
+        t.json :cached_ballot_summary, null: false, default: {}
+      else
+        t.text :cached_ballot_summary, null: false, default: '{}'
+      end
+    end
+  end
+end

data/lib/generators/ballot/summary/templates/sequel/migration.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+Sequel.migration do
+  change do
+    types = %i(jsonb json String)
+    column_options = {
+      null: false,
+      default: '{}'
+    }
+
+    alter_table :'<%= plural_table_name %>' do
+      begin
+        type = types.shift
+        add_column :cached_ballot_summary, type, column_options
+      rescue
+        types.empty? && raise || retry
+      end
+    end
+  end
+end

data/lib/sequel/plugins/ballot_votable.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Sequel # :nodoc:
+  module Plugins # :nodoc:
+    # The votable plugin marks the model as containing objects that can be
+    # voted on. It creates a polymorphic one-to-many relationship from the
+    # Votable model to Ballot::Sequel::Vote.
+    #
+    # This may be used with single_table_inheritance, but should be loaded
+    # *after* single_table_inheritance has been called. It has not been tested
+    # with class_table_inheritance.
+    #
+    # This plug-in causes Ballot::Votable to be included into the affected
+    # model, and Ballot::Votable::ClassMethods to be extended onto the affected
+    # model.
+    module BallotVotable
+      def self.apply(model) # :nodoc:
+        require 'ballot/sequel/vote'
+        require 'ballot/words'
+        require 'ballot/votable'
+
+        model.instance_eval do
+          if columns.include?(:cached_ballot_summary)
+            plugin :serialization, :json, :cached_ballot_summary
+          end
+
+          # Create a polymorphic one-to-many relationship for votables. Based
+          # heavily on the one_to_many implementation from sequel_polymorphic,
+          # but customized to sequel-voting's needs.
+          one_to_many :ballots_for,
+            key: :votable_id,
+            reciprocal: :votable,
+            reciprocal_type: :one_to_many,
+            conditions: { votable_type: Ballot::Sequel.type_name(model) },
+            adder: ->(many_of_instance) {
+              many_of_instance.update(
+                votable_id: pk,
+                votable_type: Ballot::Sequel.type_name(model)
+              )
+            },
+            remover: ->(many_of_instance) { many_of_instance.delete },
+            clearer: -> { ballots_for_dataset.delete },
+            class: '::Ballot::Sequel::Vote'
+
+          include Ballot::Votable
+          extend Ballot::Votable::ClassMethods
+        end
+      end
+
+      module InstanceMethods #:nodoc:
+        def ballot_by(voter = nil, kwargs = {}) #:nodoc:
+          kwargs = { vote: true, scope: nil }.
+            merge(__ballot_votable_kwargs(voter, kwargs))
+          self.ballot_registered = false
+
+          voter_id, voter_type = Ballot::Sequel.voter_id_and_type_name_for(kwargs)
+          return false unless voter_id
+
+          votes_ = find_ballots_for(
+            scope: kwargs[:scope],
+            voter_id: voter_id,
+            voter_type: voter_type
+          )
+
+          vote = if votes_.none? || kwargs[:duplicate]
+                   Ballot::Sequel::Vote.new(
+                     votable_id: id,
+                     votable_type: Ballot::Sequel.type_name(model),
+                     voter_id: voter_id,
+                     voter_type: voter_type,
+                     scope: kwargs[:scope]
+                   )
+                 else
+                   votes_.last
+                 end
+
+          flag = Ballot::Words.truthy?(kwargs[:vote])
+          weight = kwargs[:weight] && kwargs[:weight].to_i || 1
+
+          return false if vote.vote == flag && vote.weight == weight
+
+          vote.vote = flag
+          vote.weight = weight
+
+          model.db.transaction do
+            if vote.save
+              self.ballot_registered = true
+              update_cached_votes kwargs[:scope]
+              true
+            end
+          end
+        end
+
+        def remove_ballot_by(voter = nil, kwargs = {}) # :nodoc:
+          kwargs = __ballot_votable_kwargs(voter, kwargs)
+          voter_id, voter_type = Ballot::Sequel.voter_id_and_type_name_for(kwargs)
+          return false unless voter_id
+
+          votes_ = find_ballots_for(
+            scope: kwargs[:scope],
+            voter_id: voter_id,
+            voter_type: voter_type
+          )
+
+          return true if votes_.none?
+
+          model.db.transaction do
+            votes_.each(&:destroy)
+            update_cached_votes kwargs[:scope]
+            self.ballot_registered = ballots_for_dataset.any?
+            true
+          end
+        end
+
+        def ballot_by?(voter = nil, kwargs = {}) #:nodoc:
+          kwargs = __ballot_votable_kwargs(voter, kwargs)
+          voter_id, voter_type = Ballot::Sequel.voter_id_and_type_name_for(kwargs)
+          return false unless voter_id
+
+          cond = {
+            voter_id: voter_id,
+            voter_type: voter_type,
+            scope: kwargs[:scope]
+          }
+          cond[:vote] = Ballot::Words.truthy?(kwargs[:vote]) if kwargs.key?(:vote)
+
+          find_ballots_for(cond).any?
+        end
+
+        def ballots_by_class(klass, kwargs = {}) #:nodoc:
+          cond = {
+            voter_type: Ballot::Sequel.type_name(klass),
+            scope: kwargs[:scope]
+          }
+          cond[:vote] = Ballot::Words.truthy?(kwargs[:vote]) if kwargs.key?(:vote)
+
+          find_ballots_for(cond)
+        end
+
+        private
+
+        def caching_ballot_summary?
+          model.columns.include?(:cached_ballot_summary)
+        end
+
+        def find_ballots_for(*cond, &block)
+          ballots_for_dataset.where(*cond, &block)
+        end
+
+        def update_cached_votes(scope = nil)
+          return false unless caching_ballot_summary?
+
+          lock!
+          summary = cached_ballot_summary.merge(calculate_summary(scope))
+          self.cached_ballot_summary = summary
+          save_changes
+        end
+
+        def __eager_ballot_voters(ds)
+          ballots = ds.naked.select(:voter_type, :voter_id).all
+          partitioned = ballots.group_by { |e| e[:voter_type] }
+          partitioned.each_value do |value|
+            value.map! { |e| e[:voter_id] }
+          end
+          partitioned.each_key do |key|
+            voters = self.class.send(:constantize, key).
+              where(id: partitioned[key]).
+              map { |v| [ v.id, v ] }
+
+            partitioned[key] = Hash[voters]
+          end
+
+          ballots.map { |ballot|
+            partitioned[ballot[:voter_type]][ballot[:voter_id]]
+          }
+        end
+      end
+    end
+  end
+end