card 1.17.1 → 1.17.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a4f48d47748a3722b990ce46cf124c029ab739c0
-  data.tar.gz: e75894912cdeedb1503358bcf5debe5c85bb3019
+  metadata.gz: d772d98ac5c860f29c6c27e3e6d0a259f6c8e7a7
+  data.tar.gz: a7e78fc4a0d9c36fafd07efd6d90183df1b707aa
 SHA512:
-  metadata.gz: d70cba85ffa764ea15973673238a89d8d19afcd50b2ec46d3eacf13e71ae617def616d83a044bf6150f1d636fd496c0061127cb708bbe87125957d676a12fcba
-  data.tar.gz: 5b0d8f08cc4dfee2cf0e28ad804e9f61b6c3365041421be40b582506300177a6abf29845b61f834a76345b7a7cc943abdb0b84f9b0d26f47f5150b3e1c95e77e
+  metadata.gz: 136c7897642c4e96cd070a08d474f2b7b199175495dce04dbcdc65b5768b49fb8a897844117167c49e68a766117fc122afefb73b95c5c15adf01534241c03ce8
+  data.tar.gz: 1c1c8077a10fc53451bbfa5890367f6ee27a6e7a25a9461abdc1cffb002aef0c7e7ef85c59ae82a764f0fef28989a2fb7a2edf231a3b69ce4c723f01c16f3fd8

data/VERSION

@@ -1 +1 @@
-1.17.1
+1.17.2

data/config/initializers/recaptcha.rb

@@ -1,24 +1,32 @@
 # -*- encoding : utf-8 -*-
-def load_config_from_card codename
-  # the seed task runs initializers so we have to check
-  # if the cards table is ready before we use it here
-  return unless ActiveRecord::Base.connection.table_exists?('cards') &&
-                Card.ancestors.include?(ActiveRecord::Base)
-  ((ca = Card.find_by_codename codename) &&
-    ca.raw_content.present? && ca.raw_content) ||
-    Card::Auth::DEFAULT_RECAPTCHA_SETTINGS[codename] ||
-    nil
+
+# card config overrides application.rb config overrides default
+def load_recaptcha_config setting
+  setting = "recaptcha_#{setting}".to_sym
+  Cardio.config.send("#{setting}=",
+                     load_recaptcha_card_config(setting) || # card content
+                     Cardio.config.send(setting) || # application.rb
+                     Card::Auth::DEFAULT_RECAPTCHA_SETTINGS[setting])
+end
+
+def card_table_ready?
+  # FIXME: this test should be more generally usable
+  ActiveRecord::Base.connection.table_exists?('cards') &&
+    Card.ancestors.include?(ActiveRecord::Base)
+end
+
+# use if card with value is present
+def load_recaptcha_card_config setting
+  card = Card.find_by_codename setting
+  card && card.db_content.present? && card.db_content
 end
 
 Recaptcha.configure do |config|
-  Cardio.config.recaptcha_public_key ||=
-    load_config_from_card(:recaptcha_public_key)
-  Cardio.config.recaptcha_private_key ||=
-    load_config_from_card(:recaptcha_private_key)
-  Cardio.config.recaptcha_proxy ||=
-    load_config_from_card(:recaptcha_proxy)
-  config.public_key  = Cardio.config.recaptcha_public_key
-  config.private_key = Cardio.config.recaptcha_private_key
-  # config.api_version = 'v1' if config.respond_to?(:api_version=)
-  config.proxy       = Cardio.config.recaptcha_proxy
+  # the seed task runs initializers so we have to check
+  # if the cards table is ready before we use it here
+  if card_table_ready?
+    [:public_key, :private_key, :proxy].each do |setting|
+      config.send "#{setting}=", load_recaptcha_config(setting)
+    end
+  end
 end

data/db/migrate/20160122153608_new_indeces.rb

@@ -0,0 +1,10 @@
+# add new indeces for datetime and ref_type fields
+class NewIndeces < ActiveRecord::Migration
+  def change
+    add_index 'card_references', ['ref_type'],
+              name: 'card_references_ref_type_index' # using: :btree
+    add_index 'cards', ['created_at'], name: 'cards_created_at_index'
+    add_index 'cards', ['updated_at'], name: 'cards_updated_at_index'
+    add_index 'card_acts', ['acted_at'], name: 'acts_acted_at_index'
+  end
+end

data/db/migrate_core_cards/20130411191151_renaming_for_menu.rb

@@ -16,11 +16,11 @@ class RenamingForMenu < Card::CoreMigration
     renames.each do |oldname, newname|
       puts "updating: #{oldname}"
       c = Card[oldname]
-      c.update_referencers = true
+      c.update_referers = true
       c.name = newname
       c.save!
     end
-    
+
     codenames = %w{
       by_name
       by_update

data/db/migrate_core_cards/20140317035504_account_requests_to_signups.rb

@@ -17,7 +17,7 @@ class AccountRequestsToSignups < Card::CoreMigration
     # rename Account Request to "Sign up"
     new_signup = Card[:account_request]
     new_signup.name = newname
-    new_signup.update_referencers = true
+    new_signup.update_referers = true
     new_signup.codename = :signup
     new_signup.save!
 
@@ -27,7 +27,7 @@ class AccountRequestsToSignups < Card::CoreMigration
     thanks = Card[:thanks]
     if (signup_thanks = Card["#{old_signup.name}+#{thanks.name}"])
       signup_thanks.name = "#{new_signup.name}+#{Card[:type].name}+#{thanks.name}"
-      signup_thanks.update_referencers = true
+      signup_thanks.update_referers = true
       signup_thanks.save!
     end
 

data/db/migrate_core_cards/20150202143810_import_bootstrap_layout.rb

@@ -5,7 +5,7 @@ class ImportBootstrapLayout < Card::CoreMigration
     layout = Card.fetch "Default Layout"
     if layout
       layout.name = "Classic Layout"
-      layout.update_referencers = true
+      layout.update_referers = true
       layout.save!
     end
 
@@ -32,7 +32,7 @@ class ImportBootstrapLayout < Card::CoreMigration
     old_func = Card[:style_functional]
     old_func.name = 'style: cards'
     old_func.codename = 'style_cards'
-    old_func.update_referencers = true
+    old_func.update_referers = true
     old_func.save!
 
     old_stand = Card[:style_standard]

data/db/migrate_core_cards/20150807205221_create_references_for_search_cards.rb

@@ -2,8 +2,10 @@
 
 class CreateReferencesForSearchCards < Card::CoreMigration
   def up
-    Card.where(type_id: Card::SearchTypeID).find_each.with_index do |card, index|
-      card.update_references
+    Card.where(
+      type_id: Card::SearchTypeID
+    ).find_each.with_index do |card, index|
+      card.update_references_out
       puts "completed #{index} search cards" if index % 100 == 0
     end
   end

data/db/schema.rb

@@ -11,7 +11,7 @@
 #
 # It's strongly recommended that you check this file into your version control system.
 
-ActiveRecord::Schema.define(version: 20151105225559) do
+ActiveRecord::Schema.define(version: 20160122153608) do
 
   create_table "card_actions", force: :cascade do |t|
     t.integer "card_id",         limit: 4
@@ -32,6 +32,7 @@ ActiveRecord::Schema.define(version: 20151105225559) do
     t.string   "ip_address", limit: 255
   end
 
+  add_index "card_acts", ["acted_at"], name: "acts_acted_at_index", using: :btree
   add_index "card_acts", ["actor_id"], name: "card_acts_actor_id_index", using: :btree
   add_index "card_acts", ["card_id"], name: "card_acts_card_id_index", using: :btree
 
@@ -51,6 +52,7 @@ ActiveRecord::Schema.define(version: 20151105225559) do
     t.integer "present",     limit: 4
   end
 
+  add_index "card_references", ["ref_type"], name: "card_references_ref_type_index", using: :btree
   add_index "card_references", ["referee_id"], name: "card_references_referee_id_index", using: :btree
   add_index "card_references", ["referee_key"], name: "card_references_referee_key_index", using: :btree
   add_index "card_references", ["referer_id"], name: "card_references_referer_id_index", using: :btree
@@ -84,12 +86,14 @@ ActiveRecord::Schema.define(version: 20151105225559) do
     t.text     "db_content",          limit: 16777215
   end
 
+  add_index "cards", ["created_at"], name: "cards_created_at_index", using: :btree
   add_index "cards", ["key"], name: "cards_key_index", unique: true, using: :btree
   add_index "cards", ["left_id"], name: "cards_left_id_index", using: :btree
   add_index "cards", ["name"], name: "cards_name_index", using: :btree
   add_index "cards", ["read_rule_id"], name: "cards_read_rule_id_index", using: :btree
   add_index "cards", ["right_id"], name: "cards_right_id_index", using: :btree
   add_index "cards", ["type_id"], name: "cards_type_id_index", using: :btree
+  add_index "cards", ["updated_at"], name: "cards_updated_at_index", using: :btree
 
   create_table "schema_migrations_core_cards", id: false, force: :cascade do |t|
     t.string "version", limit: 255, null: false

data/db/version.txt

@@ -1 +1 @@
-20151105225559
+20160122153608

data/lib/card.rb

@@ -33,8 +33,8 @@ class Card < ActiveRecord::Base
   require_dependency 'card/subcards'
   require_dependency 'card/view_cache'
 
-  has_many :references_from, class_name: :Reference, foreign_key: :referee_id
-  has_many :references_to,   class_name: :Reference, foreign_key: :referer_id
+  has_many :references_in,  class_name: :Reference, foreign_key: :referee_id
+  has_many :references_out, class_name: :Reference, foreign_key: :referer_id
   has_many :acts, -> { order :id }
   has_many :actions, -> { where(draft: [nil, false]).order :id }
   has_many :drafts, -> { where(draft: true).order :id }, class_name: :Action
@@ -48,7 +48,7 @@ class Card < ActiveRecord::Base
     :action, :supercard, :superleft,
     :current_act, :current_action,
     :comment, :comment_author,    # obviated soon
-    :update_referencers,          # wrong mechanism for this
+    :update_referers,          # wrong mechanism for this
     :update_all_users,            # if the above is wrong then this one too
     :silent_change,               # and this probably too
     :remove_rule_stash,

data/lib/card/reference.rb

@@ -1,68 +1,84 @@
 # -*- encoding : utf-8 -*-
 
-class Card::Reference < ActiveRecord::Base
-  def referencer
-    Card[referer_id]
-  end
-
-  def referencee
-    Card[referee_id]
-  end
+class Card
+  # a Reference is a directional relationship from one card (the referer)
+  # to another (the referee).
+  class Reference < ActiveRecord::Base
+    class << self
+      # bulk insert improves performance considerably
+      # array takes form [ [referer_id, referee_id, referee_key, ref_type], ...]
+      def mass_insert array
+        return if array.empty?
+        value_statements = array.map { |values| "\n(#{values.join ', '})" }
+        sql = 'INSERT into card_references '\
+              '(referer_id, referee_id, referee_key, ref_type) '\
+              "VALUES #{value_statements.join ', '}"
+        Card.connection.execute sql
+      end
 
-  class << self
-    def delete_all_from card
-      delete_all referer_id: card.id
-    end
+      # map existing reference to name to card via id
+      def map_referees referee_key, referee_id
+        where(referee_key: referee_key).update_all referee_id: referee_id
+      end
 
-    def delete_all_to card
-      where(referee_id: card.id).update_all present: 0, referee_id: nil
-    end
+      # references no longer refer to card, so remove id
+      def unmap_referees referee_id
+        where(referee_id: referee_id).update_all referee_id: nil
+      end
 
-    def update_existing_key card, name=nil
-      key = (name || card.name).to_name.key
-      where(referee_key: key).update_all present: 1, referee_id: card.id
-    end
+      # find all references to missing (eg deleted) cards and reset them
+      def unmap_if_referee_missing
+        joins(
+          'LEFT JOIN cards ON card_references.referee_id = cards.id'
+        ).where(
+          '(cards.id IS NULL OR cards.trash IS TRUE) AND referee_id IS NOT NULL'
+        ).update_all referee_id: nil
+      end
 
-    def update_on_rename card, newname, update_referers=false
-      if update_referers
-        # not currently needed because references are deleted and re-created
-        # in the process of adding new revision
-        # where referee_id: card.id).update_all referee_key: newname.to_name.key
-      else
-        delete_all_to card
+      # remove all references from missing (eg deleted) cards
+      def delete_if_referer_missing
+        joins(
+          'LEFT JOIN cards ON card_references.referer_id = cards.id'
+        ).where(
+          'cards.id IS NULL'
+        ).find_in_batches do |group|
+          # used to be .delete_all here, but that was failing on large dbs
+          puts 'deleting batch of references'
+          where("id in (#{group.map(&:id).join ','})").delete_all
+        end
       end
-      update_existing_key card, newname
-    end
 
-    def update_on_delete card
-      delete_all_from card
-      delete_all_to card
-    end
+      # repair references one by one (delete, create, delete, create...)
+      # slower, but better than #repair_all for use on running sites
+      def repair_all
+        delete_if_referer_missing
+        Card.where(trash: false).find_each do |card|
+          Rails.logger.info "updating references from #{card}"
+          card.include_set_modules
+          card.update_references_out
+        end
+      end
 
-    def repair_missing_referees
-      joins(
-        'LEFT JOIN cards ON card_references.referee_id = cards.id'
-      ).where(
-        '(cards.id IS NULL OR cards.trash IS TRUE) AND referee_id IS NOT NULL'
-      ).update_all referee_id: nil
+      # delete all references, then recreate them one by one
+      # faster than #repair_all, but not recommended for use on running sites
+      def recreate_all
+        delete_all
+        Card.where(trash: false).find_each do |card|
+          Rails.logger.info "updating references from #{card}"
+          card.include_set_modules
+          card.create_references_out
+        end
+      end
     end
 
-    def delete_missing_referers
-      joins(
-        'LEFT JOIN cards ON card_references.referer_id = cards.id'
-      ).where(
-        'cards.id IS NULL'
-      ).delete_all
+    # card that refers
+    def referer
+      Card[referer_id]
     end
 
-    def repair_all
-      delete_missing_referers
-
-      Card.where(trash: false).find_each do |card|
-        Rails.logger.info "Repairing references for '#{card.name}'" \
-                          "(id: #{card.id}) ... "
-        card.update_references
-      end
+    # card that is referred to
+    def referee
+      Card[referee_id]
     end
   end
 end

data/mod/01_core/chunk/query_reference.rb

@@ -77,7 +77,7 @@ module Card::Chunk
     end
 
     def reference_code
-      'Q' # Q for "Query"
+      'Q' # for "Query"
     end
   end
 end

data/mod/01_core/set/all/collection.rb

@@ -26,7 +26,7 @@ module ClassMethods
     if block_given?
       super(options) do |records|
         yield(records)
-        Card::Cache.reset_all
+        Card::Cache.reset_soft
       end
     else
       super(options)

data/mod/01_core/set/all/name.rb

@@ -10,7 +10,7 @@ module ClassMethods
     if rename == :old
       # name conflict resolved; original name can be used
       Card[name].update_attributes! name: uniq_name,
-                                    update_referencers: true
+                                    update_referers: true
       name
     else
       uniq_name
@@ -71,39 +71,35 @@ def contextual_name
 end
 
 def relative_name context_name=nil
-  if !context_name && @supercard
-    context_name = @supercard.cardname
-  end
-  cardname.relative_name(context_name)
+  context_name ||= @supercard.cardname if @supercard
+  cardname.relative_name context_name
 end
 
 def absolute_name context_name=nil
-  if !context_name && @supercard
-    context_name = @supercard.cardname
-  end
-  cardname.absolute_name(context_name)
+  context_name ||= @supercard.cardname if @supercard
+  cardname.absolute_name context_name
 end
 
 def left *args
-  return if simple?
-  @superleft || begin
-    unless name_changed? &&
-           name.to_name.trunk_name.key == name_was.to_name.key
-      # prevent recursion when, eg, renaming A+B to A+B+C
-      Card.fetch cardname.left, *args
-    end
+  case
+  when simple?    then nil
+  when @superleft then @superleft
+  when name_changed? && name.to_name.trunk_name.key == name_was.to_name.key
+    nil # prevent recursion when, eg, renaming A+B to A+B+C
+  else
+    Card.fetch cardname.left, *args
   end
 end
 
 def right *args
-  Card.fetch(cardname.right, *args) if !simple?
+  Card.fetch(cardname.right, *args) unless simple?
 end
 
 def [] *args
   case args[0]
   when Fixnum, Range
     fetch_name = Array.wrap(cardname.parts[args[0]]).compact.join '+'
-    Card.fetch(fetch_name, args[1] || {}) if !simple?
+    Card.fetch(fetch_name, args[1] || {}) unless simple?
   else
     super
   end
@@ -141,22 +137,22 @@ def child_names parent_name=nil, side=nil
               "(#{side}) children of #{parent_name}")
 end
 
-def descendant_names parent_name=nil
+# ids of children and children's children
+def descendant_ids parent_id=nil
   return [] if new_card?
-  parent_name ||= name
+  parent_id ||= id
   Auth.as_bot do
-    deps = child_names parent_name
-    deps.inject(deps) do |array, childname|
-      array + descendant_names(childname)
-    end
+    child_ids = Card.search part: parent_id, return: :id
+    child_descendant_ids = child_ids.map { |cid| descendant_ids cid }
+    (child_ids + child_descendant_ids).flatten.uniq
   end
 end
 
+# children and children's children
+# NOTE - set modules are not loaded
+# -- should only be used for name manipulations
 def descendants
-  # children and children's children
-  # NOTE - set modules are not loaded
-  # -- should only be used for name manipulations
-  @descendants ||= descendant_names.map { |name| Card.quick_fetch name }
+  @descendants ||= descendant_ids.map { |id| Card.quick_fetch id }
 end
 
 def repair_key
@@ -208,7 +204,7 @@ event :validate_name, before: :approve, on: :save do
 
     unless cdname.valid?
       errors.add :name, 'may not contain any of the following characters: ' \
-                        "#{ Card::Name.banned_array * ' ' }"
+                        "#{Card::Name.banned_array * ' '}"
     end
     # this is to protect against using a plus card as a tag
     if cdname.junction? && simple? && id &&
@@ -290,12 +286,6 @@ def suspend_name name
 end
 
 event :cascade_name_changes, after: :store, on: :update, changed: :name do
-  # Rails.logger.info "------------------- #{name_was} CASCADE #{self.name} " \
-  #                   " -------------------------------------"
-  # handle strings from cgi
-  self.update_referencers = false if update_referencers == 'false'
-  Card::Reference.update_on_rename self, name, self.update_referencers
-
   des = descendants
   @descendants = nil # reset
 
@@ -306,36 +296,8 @@ event :cascade_name_changes, after: :store, on: :update, changed: :name do
     Card.expire de.name # old name
     newname = de.cardname.replace_part name_was, name
     Card.where(id: de.id).update_all name: newname.to_s, key: newname.key
-    Card::Reference.update_on_rename de, newname, update_referencers
+    de.update_referers = update_referers
+    de.refresh_references_in
     Card.expire newname
   end
-  execute_referencers_update(des) if update_referencers
-end
-
-def execute_referencers_update descendants
-  Auth.as_bot do
-    [name_referencers(name_was) + descendants.map(&:referencers)]
-      .flatten.uniq.each do |card|
-      # FIXME:  using 'name_referencers' instead of plain 'referencers' for self
-      # because there are cases where trunk and tag
-      # have already been saved via association by this point and therefore
-      # referencers misses things
-      # eg.  X includes Y, and Y is renamed to X+Z.  When X+Z is saved, X is
-      # first updated as a trunk before X+Z gets to this point.
-      # so at this time X is still including Y, which does not exist.
-      # therefore #referencers doesn't find it, but name_referencers(old_name)
-      # does.
-      # some even more complicated scenario probably breaks on the descendants,
-      # so this probably needs a more thoughtful refactor
-      # aligning the dependent saving with the name cascading
-
-      Rails.logger.debug "------------------ UPDATE REFERER #{card.name} " \
-                         '------------------------'
-      unless card == self || card.structure
-        card = card.refresh
-        card.db_content = card.replace_references name_was, name
-        card.save!
-      end
-    end
-  end
 end