card 1.99.1 → 1.99.6

data/db/seed/test/fixtures/schema_migrations_core_cards.yml

@@ -307,3 +307,11 @@ schema_migrations_core_cards_153:
   version: '20190927112151'
 schema_migrations_core_cards_154:
   version: '20191008201046'
+schema_migrations_core_cards_155:
+  version: '20191014204655'
+schema_migrations_core_cards_156:
+  version: '20191028135243'
+schema_migrations_core_cards_157:
+  version: '20191115160748'
+schema_migrations_core_cards_158:
+  version: '20191118145629'

data/db/test_seed.rb

@@ -4,7 +4,6 @@ require "timecop"
 
 # noinspection RubyResolve
 class SharedData
-  require_relative "../lib/card/model/save_helper"
   extend Card::Model::SaveHelper
 
   USERS = [
@@ -96,11 +95,11 @@ class SharedData
       Card.create! type_id: Card::CardtypeID, name: "UserForm"
       create "UserForm+*type+*structure", "{{+name}} {{+age}} {{+description}}"
 
-      Card::Auth.current_id = Card["joe_user"].id
+      Card::Auth.signin "joe_user"
       create "JoeLater", "test"
       create "JoeNow", "test"
 
-      Card::Auth.current_id = Card::WagnBotID
+      Card::Auth.signin Card::WagnBotID
 
       create_cardtype "Book"
       create "Book+*type+*structure", "by {{+author}}, design by {{+illustrator}}"
@@ -169,10 +168,10 @@ class SharedData
       end
 
       # noinspection RubyResolve
-      Card["Joe Admin"].fetch(trait: :roles, new: { type_code: "pointer" })
+      Card["Joe Admin"].fetch(:roles, new: { type_code: "pointer" })
         .items = [Card::AdministratorID, Card::SharkID, Card::HelpDeskID]
 
-      Card["Joe User"].fetch(trait: :roles, new: { type_code: "pointer" })
+      Card["Joe User"].fetch(:roles, new: { type_code: "pointer" })
               .items = [Card::SharkID]
 
       create_user "u1", email: "u1@user.com", password: "u1_pass"
@@ -184,9 +183,9 @@ class SharedData
       r3 = create_role "r3"
       r4 = create_role "r4"
 
-      Card["u1"].fetch(trait: :roles, new: { type_code: "pointer" }).items = [r1, r2, r3]
-      Card["u2"].fetch(trait: :roles, new: {}).items = [r1, r2, r4]
-      Card["u3"].fetch(trait: :roles, new: {}).items = [r1, r4, Card::AdministratorID]
+      Card["u1"].fetch(:roles, new: { type_code: "pointer" }).items = [r1, r2, r3]
+      Card["u2"].fetch(:roles, new: {}).items = [r1, r2, r4]
+      Card["u3"].fetch(:roles, new: {}).items = [r1, r4, Card::AdministratorID]
     end
 
 
@@ -244,14 +243,14 @@ class SharedData
         create "John Following+her"
         magnifier = create "Magnifier+lens"
 
-        Card::Auth.current_id = Card["Narcissist"].id
+        Card::Auth.signin "Narcissist"
         magnifier.update! content: "zoom in"
         create_optic "Sunglasses", "{{+tint}}{{+lens}}"
 
-        Card::Auth.current_id = Card["Optic fan"].id
+        Card::Auth.signin "Optic fan"
         create_optic "Google glass", "{{+price}}"
 
-        Card::Auth.current_id = Card::WagnBotID
+        Card::Auth.signin Card::WagnBotID
         create "Google glass+*self+*follow_fields", ""
         create "Sunglasses+*self+*follow_fields", "[[#{Card[:nests].name}]]\n[[_self+price]]\n[[_self+producer]]"
         create "Sunglasses+tint"

data/lib/card.rb

@@ -1,8 +1,6 @@
 # -*- encoding : utf-8 -*-
 
-Object.const_remove_if_defined :Card
 ActiveSupport.run_load_hooks(:before_card, self)
-# ActiveSupport::Dependencies.loaded.clear
 
 # Cards are wiki-inspired building blocks.
 #
@@ -93,28 +91,12 @@ ActiveSupport.run_load_hooks(:before_card, self)
 # You can see the current user with `Card::Auth.current`. The permissions of a proxy user can be temporarily assumed using `Card::Auth#as`.
 #
 # {Card::Auth More on accounts}
-#
 class Card < ApplicationRecord
-  require_dependency "card/mark"
-  extend Mark
+  extend ::Card::Mark
+  extend ::Card::Dirty::MethodFactory
+  include ::Card::Dirty
 
-  require_dependency "card/name"
-  require_dependency "card/codename"
-  require_dependency "card/query"
-  require_dependency "card/format"
-  require_dependency "card/error"
-  require_dependency "card/auth"
-  require_dependency "card/mod"
-  require_dependency "card/content"
-  require_dependency "card/action"
-  require_dependency "card/act"
-  require_dependency "card/change"
-  require_dependency "card/reference"
-  require_dependency "card/subcards"
-  require_dependency "card/view"
-  require_dependency "card/act_manager"
-  require_dependency "card/dirty"
-  require_dependency "card/layout"
+  Card::Cache # trigger autoload
 
   has_many :references_in,  class_name: :Reference, foreign_key: :referee_id
   has_many :references_out, class_name: :Reference, foreign_key: :referer_id
@@ -122,70 +104,57 @@ class Card < ApplicationRecord
   has_many :actions, -> { where(draft: [nil, false]).order :id }
   has_many :drafts, -> { where(draft: true).order :id }, class_name: :Action
 
-  cattr_accessor :set_patterns, :serializable_attributes, :set_specific_attributes
-  self.set_patterns = []
-
-  # attributes that ActiveJob can handle
-  def self.serializable_attr_accessor *args
-    self.serializable_attributes = args
-    attr_accessor(*args)
-  end
+  cattr_accessor :set_patterns, :action_specific_attributes, :set_specific_attributes
 
-  serializable_attr_accessor(
+  self.set_patterns = []
+  self.action_specific_attributes = [
     :action, :supercard, :superleft,
     :current_action,
-    :comment,                     # obviated soon
-    :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,
+
     :last_action_id_before_edit,
     :only_storage_phase,          # used to save subcards
     :changed_attributes,
+
     :skip,                        # skip event(s) for all cards in act
     :skip_in_action,              # skip event for just this card
     :trigger,                     # trigger event(s) for all cards in act
-    :trigger_in_action            # trigger event for just this card
-  )
+    :trigger_in_action,           # trigger event for just this card
 
-  alias_method :skip_event, :skip
-  alias_method :skip_event_in_action, :skip_in_action
-  alias_method :trigger_event, :trigger
-  alias_method :trigger_event_in_action, :trigger_in_action
+    :comment,                     # obviated soon
 
-  def serializable_attributes
-    self.class.serializable_attributes + set_specific.keys
-  end
+    # TODO: refactor following to use skip/trigger
+    :update_referers,             # wrong mechanism for this
+    :update_all_users,            # if the above is wrong then this one too
+    :silent_change                # and this probably too
+  ]
 
+  attr_accessor(*action_specific_attributes)
   attr_accessor :follower_stash
 
-  define_callbacks(
+  STAGE_CALLBACKS = [
     :select_action, :show_page, :act,
-
     # VALIDATION PHASE
     :initialize_stage, :prepare_to_validate_stage, :validate_stage,
     :initialize_final_stage, :prepare_to_validate_final_stage,
     :validate_final_stage,
-
     # STORAGE PHASE
     :prepare_to_store_stage, :store_stage, :finalize_stage,
     :prepare_to_store_final_stage, :store_final_stage, :finalize_final_stage,
-
     # INTEGRATION PHASE
     :integrate_stage, :integrate_with_delay_stage,
     :integrate_final_stage,
     :after_integrate_stage,
     :after_integrate_final_stage, :integrate_with_delay_final_stage
-  )
+  ].freeze
+  define_callbacks(*STAGE_CALLBACKS)
 
   # Validation and integration phase are only called for the act card
   # The act card starts those phases for all its subcards
   before_validation :validation_phase, unless: -> { only_storage_phase? }
   around_save :storage_phase
   after_commit :integration_phase, unless: -> { only_storage_phase? }
-#  after_rollback :clean_up, unless: -> { only_storage_phase? }
+  #  after_rollback :clean_up, unless: -> { only_storage_phase? }
 
   ActiveSupport.run_load_hooks(:card, self)
 end
-
-ActiveSupport.run_load_hooks(:after_card, self)
+ActiveSupport.run_load_hooks :after_card, self

data/lib/card/act_manager.rb

@@ -1,5 +1,3 @@
-require_dependency "card/act_manager/stage_director"
-
 class Card
   # Manages the whole process of creating an {act Card::Act} ie. changing
   # a card and attached subcards.
@@ -109,6 +107,7 @@ class Card
         directors.each_pair do |card, _dir|
           card.expire
           card.director = nil
+          card.clear_action_specific_attributes
         end
         expire
         @directors = nil

data/lib/card/act_manager/event_delay.rb

@@ -26,16 +26,21 @@ class Card
       # event processed by ActiveJob.
       # This is the improvised resetup to get subcards working.
       def contextualize_for_delay act_id, card, env, auth, &block
-        self.act = Act.find act_id if act_id
         with_env_and_auth env, auth do
-          return yield unless act
-
-          run_act(act.card || card) do
-            act_card.director.run_delayed_event act, &block
+          if act_id && (self.act = Act.find act_id)
+            run_job_with_act act, card, &block
+          else
+            yield
           end
         end
       end
 
+      def run_job_with_act act, card, &block
+        run_act(act.card || card) do
+          act_card.director.run_delayed_event act, &block
+        end
+      end
+
       def with_env_and_auth env, auth
         Card::Auth.with auth do
           Card::Env.with env do

data/lib/card/act_manager/subdirector_array.rb

@@ -19,6 +19,8 @@ class Card
         card = card.card if card.is_a? StageDirector
         each { |dir| return dir if dir.card == card }
         dir = ActManager.fetch card, parent: @parent
+        return dir if dir.main
+
         dir.replace_card card if dir.card != card
         dir.main = false
         dir.parent = @parent

data/lib/card/auth.rb

@@ -1,10 +1,5 @@
 # -*- encoding : utf-8 -*-
 
-require_dependency "card/auth/permissions"
-require_dependency "card/auth/proxy"
-require_dependency "card/auth/setup"
-require_dependency "card/auth/token"
-
 class Card
   # Singleton methods for account authentication and contextualization.
   #

data/lib/card/auth/current.rb

@@ -3,7 +3,8 @@ class Card
     # methods for setting current account
     module Current
       # set current user in process and session
-      def signin signin_id
+      def signin cardish
+        signin_id = Card.id(cardish) || Card::AnonymousID
         self.current_id = signin_id
         set_session_user signin_id
       end
@@ -30,37 +31,9 @@ class Card
         end
       end
 
-      # set the id of the current user.
-      def current_id= card_id
-        @current = @as_id = @as_card = @current_roles = nil
-        card_id = card_id.to_i if card_id.present?
-        @current_id = card_id
-      end
-
-      # set current user from email or id
-      # @return [Integer]
-      def current= mark
-        self.current_id =
-          if mark.to_s =~ /@/
-            account = Auth.find_account_by_email mark
-            account && account.active? ? account.left_id : Card::AnonymousID
-          else
-            mark
-          end
-      end
-
       def current_roles
         @current_roles ||= [Card.fetch_name(:anyone_signed_in),
-                            current.fetch(trait: :roles)&.item_names].flatten.compact
-      end
-
-      def no_special_roles?
-        Auth.current_roles.size == 1 # &&
-          # Auth.current_roles.first == Card.fetch_name(:anyone_signed_in)
-      end
-
-      def clear_current_roles
-        @current_roles = nil
+                            current.fetch(:roles)&.item_names].flatten.compact
       end
 
       def serialize
@@ -71,11 +44,8 @@ class Card
       # @option auth_data [Integer] current_id
       # @option auth_data [Integer] as_id
       def with auth_data
-        case auth_data
-        when Integer
-          auth_data = { current_id: auth_data }
-        when String
-          auth_data = { current_id: Card.fetch_id(auth_data) }
+        if auth_data.is_a?(Integer) || auth_data.is_a?(String)
+          auth_data = { current_id: Card.id(auth_data) }
         end
 
         tmp_current_id = current_id
@@ -102,68 +72,62 @@ class Card
         Card::Env.session
       end
 
-      # set current from token or session
-      def set_current opts={}
+      # set current from token, api_key, or session
+      def signin_with opts={}
         if opts[:token]
-          set_current_from_token opts[:token]
+          signin_with_token opts[:token]
         elsif opts[:api_key]
-          set_current_from_api_key opts[:api_key]
+          signin_with_api_key opts[:api_key]
         else
-          set_current_from_session
+          signin_with_session
         end
       end
 
       # set the current user based on token
-      def set_current_from_token token
+      def signin_with_token token
         payload = Token.validate! token
-        self.current_id = payload[:anonymous] ? Card::AnonymousID : payload[:user_id]
+        signin payload[:anonymous] ? Card::AnonymousID : payload[:user_id]
       end
 
       # set the current user based on api_key
-      def set_current_from_api_key api_key
+      def signin_with_api_key api_key
         account = find_account_by_api_key api_key
         unless account&.validate_api_key! api_key
           raise Card::Error::PermissionDenied, "API key authentication failed"
         end
 
-        self.current = account.left_id
+        signin account.left_id
       end
 
       # get :user id from session and set Auth.current_id
-      def set_current_from_session
-        self.current_id =
-          if (card_id = session_user) && Card.exists?(card_id)
-            card_id
-          else
-            set_session_user Card::AnonymousID
-          end
+      def signin_with_session
+        card_id = session_user
+        signin(card_id && Card.exists?(card_id) ? card_id : nil)
       end
 
       # find +\*account card by +\*api card
       # @param token [String]
       # @return [+*account card, nil]
       def find_account_by_api_key api_key
-        find_account_by "api_key", Card::ApiKeyID, api_key.strip
+        find_account_by :api_key, api_key.strip
       end
 
       # find +\*account card by +\*email card
       # @param email [String]
       # @return [+*account card, nil]
       def find_account_by_email email
-        find_account_by "email", Card::EmailID, email.strip.downcase
+        find_account_by :email, email.strip.downcase
       end
 
       # general pattern for finding +\*account card based on field cards
-      # @param fieldname [String] right name of field card (for WQL comment)
-      # @param field_id [Integer] card id of field's simple card
+      # @param fieldcode [Symbol] code of account field
       # @param value [String] content of field
       # @return [+*account card, nil]
-      def find_account_by fieldname, field_id, value
+      def find_account_by fieldcode, value
         Auth.as_bot do
           Card.search({ right_id: Card::AccountID,
-                        right_plus: [{ id: field_id },
-                                     { content: value }] },
-                      "find +:account for #{fieldname} (#{value})").first
+                        right_plus: [Card::Codename.id(fieldcode), { content: value }] },
+                      "find +:account with +#{fieldcode} (#{value})").first
         end
       end
 
@@ -182,6 +146,13 @@ class Card
       def database
         Rails.configuration.database_configuration.dig Rails.env, "database"
       end
+
+      # set the id of the current user.
+      def current_id= card_id
+        @current = @as_id = @as_card = @current_roles = nil
+        card_id = card_id.to_i if card_id.present?
+        @current_id = card_id
+      end
     end
   end
 end

data/lib/card/auth/permissions.rb

@@ -2,11 +2,6 @@ class Card
   module Auth
     # singleton permission methods
     module Permissions
-      RECAPTCHA_DEFAULTS = {
-        recaptcha_site_key: "6LdoqpgUAAAAAEdhJ4heI1h3XLlpXcDf0YubriCG",
-        recaptcha_secret_key: "6LdoqpgUAAAAAP4Sz1L5PY6VKum_RFxq4-awj4BH"
-      }.freeze
-
       # user has "root" permissions
       # @return [true/false]
       def always_ok?

data/lib/card/auth/setup.rb

@@ -42,7 +42,7 @@ class Card
       end
 
       def user_account_wql
-        { right_id: AccountID, creator_id: ["ne", WagnBotID] }
+        { right_id: Card::AccountID, creator_id: ["ne", Card::WagnBotID] }
       end
 
       def user_account_count