card-mod-counts 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 07bf8f2a2e551a3ba76bb0a9be5acc9f60d06eafe89acdf74756e3fb69a49280
+  data.tar.gz: 8a033c80c7e6b778bd34f9c4be1402b73d7fb69daf5a9f16287fac5c88ca1b34
+SHA512:
+  metadata.gz: 39ed100f2208371f60233693c7b04d6d0e42f8519bbf58259ac83f54e3944e331c487a0313178a3fe3422714f5174bf87bb08f2348351292ba63a6b6d2fb11c0
+  data.tar.gz: '08f255b8eb96a16f2a4ee5e023fab2d54bb3562dc7f39f8095f4c08ad55a62b271ee274594f420249ecdcfab2c7d5bcda4831df53e5847d93ae9207cb560cdf1'

data/README.md

@@ -0,0 +1,51 @@
+<!--
+# @title README - mod: counts
+-->
+
+# Counts mod
+
+Counting things can be slow. This mod helps you store and cache counts so you can retrieve
+them quickly.
+
+This is a mod for monkeys; it's specifically aimed at optimizing code. The only support
+for sharks to date is an override of the `:count` view and a `CQL` extension (see below.)
+
+
+## Database
+
+Installing the mod will add a `counts` table. It mimics the cards table structure by
+storing `value` for a unique `left_id` and `right_id`. No card with those two ids is
+required; counts are often stored for virtual cards.
+
+
+## Abstract Sets
+
+Each of the following sets works on the same underlying principle: you include it
+with `include_set` to make the set ready to handle counts. Note that many sets will
+require that you configure recounting.
+
+### Abstract::CachedCount
+
+The base class. The following use it, and it can also be used directly for nonstandard
+cases.
+
+### Abstract::ListCachedCount
+
+Count the number of items in an explicit list.
+
+### Abstract::SearchCachedCount
+
+Count the number of items returned by a standard CQL search. `recount_trigger` calls are
+required.
+
+### Abstract::ListRefCachedCount
+
+Count a common search pattern: items referred to by a explicit field list. When including
+this set, you will need to specify two arguments: `type_to_count` and `list_field`.
+
+## CQL
+
+You can sort by the counts generated with the following CQL
+```
+sort: { right: RIGHT_NAME, item: "cached_count", return: "count" }
+```

data/db/migrate/20170330102819_counts_table.rb

@@ -0,0 +1,18 @@
+# -*- encoding : utf-8 -*-
+
+class CountsTable < ActiveRecord::Migration[4.2]
+  def up
+    drop_table :counts if table_exists? :counts
+    create_table :counts do |t|
+      t.integer :left_id
+      t.integer :right_id
+      t.integer :value
+    end
+
+    add_index :counts, %i[left_id right_id], name: "left_id_right_id_index"
+  end
+
+  def down
+    drop_table :counts
+  end
+end

data/lib/card/query/cached_count_join.rb

@@ -0,0 +1,21 @@
+class Card
+  module Query
+    # joins card query with cached count table
+    class CachedCountJoin < Join
+      def initialize cardquery, right
+        validate_right right
+        super(side: :left, from: cardquery, from_field: "id",
+              to: %w[counts counts_table left_id])
+        @conditions << "counts_table.right_id = #{@right_id}"
+      end
+
+      def validate_right right
+        raise Card::Error::BadQuery, "sort by cached_count: no right given" unless right
+        unless (@right_id = right.card_id)
+          raise Card::Error::BadQuery,
+                "cached count for +#{right}: #{right} does not exist"
+        end
+      end
+    end
+  end
+end

data/lib/card/query/cached_count_sorting.rb

@@ -0,0 +1,14 @@
+class Card
+  module Query
+    attributes[:item] = :ignore # item is in Card::Query; this shouldn't have to be here.
+
+    module CachedCountSorting
+      def sort_by_count_cached_count val
+        count_join = CachedCountJoin.new self, val[:right]
+        joins << count_join
+        @mods[:sort_as] = "integer"
+        @mods[:sort] = "#{count_join.to_alias}.value"
+      end
+    end
+  end
+end

data/lib/count.rb

@@ -0,0 +1,84 @@
+class Count < ActiveRecord::Base
+  def step
+    update value + 1
+  end
+
+  def update new_value
+    update! value: new_value
+    new_value
+  end
+
+  class << self
+    def create card
+      validate_count_card card
+      count = Count.new left_id: left_id(card),
+                        right_id: right_id(card),
+                        value: card.recount
+      count.save!
+      count
+    end
+
+    def fetch_value card
+      find_value_by_card(card) || create(card).value
+    end
+
+    def fetch card
+      find_by_card(card) || create(card)
+    end
+
+    def step card
+      count = find_by_card(card)
+      return create(card).value unless count
+      count.step
+    end
+
+    def refresh card
+      count = find_by_card(card)
+      return create(card).value unless count
+      count.update card.recount
+    end
+
+    def find_value_by_card card
+      where_card(card).pluck(:value).first
+    end
+
+    def find_by_card card
+      where_card(card).take
+    end
+
+    private
+
+    def where_card card
+      Count.where(left_id: left_id(card), right_id: right_id(card))
+    end
+
+    def left_id card
+      if card.compound?
+        card.left_id || ((l = card.left) && l.id)
+      else
+        card.id
+      end
+    end
+
+    def right_id card
+      if card.compound?
+        card.right_id || ((r = card.right) && r.id)
+      else
+        -1
+      end
+    end
+
+    def validate_count_card card
+      reason = "has to respond to 'recount'" unless card.respond_to? :recount
+      reason ||=
+        if card.compound?
+          "needs left_id" unless left_id(card)
+          "needs right_id" unless right_id(card)
+        elsif !card.id
+          "needs id"
+        end
+      return unless reason
+      raise Card::Error, card.name, "count not cacheable: card #{card.name} #{reason}"
+    end
+  end
+end

data/set/abstract/01_cached_count.rb

@@ -0,0 +1,67 @@
+# -*- encoding : utf-8 -*-
+
+# Cards in this set cache a count in the counts table
+
+def self.included host_class
+  host_class.extend ClassMethods
+end
+
+def cached_count
+  @cached_count || hard_cached_count(::Count.fetch_value(self))
+end
+
+def update_cached_count _changed_card=nil
+  hard_cached_count ::Count.refresh(self)
+end
+
+def hard_cached_count value
+  Card.cache.hard&.write_attribute key, :cached_count, value
+  @cached_count = value
+end
+
+# called to refresh the cached count
+# the default way is that the card is a search card and we just
+# count the search result
+# for special calculations override this method in your set
+def recount
+  count
+end
+
+module ClassMethods
+  # @param parts [Array] set parts of changed card
+  def recount_trigger *set_parts, &block
+    event_args = set_parts.last.is_a?(Hash) ? set_parts.pop : {}
+    set = ensure_set { set_parts }
+    event_name = recount_event_name set, event_args[:on]
+    define_recount_event set, event_name, event_args, &block
+  end
+
+  def field_recount field_card
+    yield unless field_card.left&.action&.in? %i[create delete]
+  end
+
+  private
+
+  def define_recount_event set, event_name, event_args
+    set.class_eval do
+      event event_name, :after_integrate, event_args do
+        Array.wrap(yield(self)).compact.each do |count_card|
+          count_card.update_cached_count self if count_card.respond_to? :recount
+        end
+      end
+    end
+  end
+
+  def recount_event_name set, on
+    changed_set = set.to_s.tr(":", "_").underscore
+    count_set = to_s.tr(":", "_").underscore
+    on_actions = on.present? ? "_on_#{Array.wrap(on).join '_'}" : nil
+    :"update_cached_count_for_#{count_set}_triggered_by_#{changed_set}#{on_actions}"
+  end
+end
+
+format do
+  def count
+    card.cached_count
+  end
+end

data/set/abstract/02_search_cached_count.rb

@@ -0,0 +1,14 @@
+include_set Abstract::CqlSearch
+include_set Abstract::SearchViews
+
+def self.included host_class
+  host_class.include_set Abstract::CachedCount
+end
+
+def virtual?
+  new?
+end
+
+def type_id
+  SearchTypeID
+end

data/set/abstract/list_cached_count.rb

@@ -0,0 +1,7 @@
+def self.included host_class
+  host_class.class_eval do
+    include_set Abstract::CachedCount
+    recount_trigger(host_class) { |changed_card| changed_card }
+    self
+  end
+end

data/set/abstract/list_ref_cached_count.rb

@@ -0,0 +1,52 @@
+# Include with options :type_to_count and :tag
+# counts all cards of a type "type_to_count" that are tagged with self via a
+# +<list_field> pointer.
+# If <type_to_count>+<list_field> card is updated, all
+# <changed item name>+<type_to_count> cached counts are updated
+#
+# @example count for topic cards the metrics that are tagged with the topic
+# via a +topic card
+#   include_set Abstract::ListRefCachedCount, type_to_count: :metric,
+#                                             list_field: :wikirate_topic
+
+include_set Abstract::SearchCachedCount
+
+def self.included host_class
+  host_class.class_eval do
+    include_set Abstract::CachedCount
+    recount_trigger :type_plus_right,
+                    host_class.type_to_count,
+                    host_class.list_field do |changed_card|
+      trait_name = host_class.try(:count_trait) || host_class.type_to_count
+      changed_card.changed_item_names.map do |item_name|
+        Card.fetch item_name.to_name.trait(trait_name)
+      end
+    end
+
+    define_method :type_id_to_count do
+      Card::Codename.id host_class.type_to_count
+    end
+
+    define_method :list_field_id do
+      Card::Codename.id host_class.list_field
+    end
+  end
+end
+
+def cql_content
+  { type_id: type_id_to_count, right_plus: right_plus_val }
+end
+
+def right_plus_val
+  [list_field_id, { refer_to: left.id }]
+end
+
+format do
+  # TODO: make less hacky.
+  # Without this filter cql can overwrite right_plus
+  def filter_cql
+    cql = super
+    cql[:right_plus] = [cql[:right_plus], card.right_plus_val].compact
+    cql
+  end
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: card-mod-counts
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Philipp Kühl
+- Ethan McCutchen
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-10-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: card
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: card-mod-search
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- info@decko.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- db/migrate/20170330102819_counts_table.rb
+- lib/card/query/cached_count_join.rb
+- lib/card/query/cached_count_sorting.rb
+- lib/count.rb
+- set/abstract/01_cached_count.rb
+- set/abstract/02_search_cached_count.rb
+- set/abstract/list_cached_count.rb
+- set/abstract/list_ref_cached_count.rb
+homepage: http://decko.org
+licenses:
+- GPL-3.0
+metadata:
+  card-mod: counts
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.5'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.28
+signing_key:
+specification_version: 4
+summary: caching of counts
+test_files: []