card 1.99.1 → 1.99.2

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
 
   has_many :references_in,  class_name: :Reference, foreign_key: :referee_id
   has_many :references_out, class_name: :Reference, foreign_key: :referer_id
@@ -159,33 +141,30 @@ class Card < ApplicationRecord
 
   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.

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,15 @@ class Card
       def database
         Rails.configuration.database_configuration.dig Rails.env, "database"
       end
+
+      private
+
+      # 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/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

data/lib/card/codename.rb

@@ -1,8 +1,5 @@
 # -*- encoding : utf-8 -*-
 
-require_dependency "card/cache"
-require_dependency "card/name"
-
 class Card
   # {Card}'s names can be changed, and therefore _names_ should not be directly mentioned
   # in code, lest a name change break the application.
@@ -46,7 +43,9 @@ class Card
         end
       end
 
-      def name codename
+      def name codename=nil
+        return super() if codename.nil?
+
         name! codename
       rescue Error::CodenameNotFound => _e
         yield if block_given?
@@ -75,7 +74,7 @@ class Card
       # clear cache both locally and in cache
       def reset_cache
         @codehash = nil
-        Card.cache.delete "CODEHASH"
+        ::Card.cache.delete "CODEHASH"
       end
 
       # @param codename [Symbol, String]
@@ -112,7 +111,7 @@ class Card
 
       # generate Hash for @codehash and put it in the cache
       def load_codehash
-        Card.cache.fetch("CODEHASH") do
+        ::Card.cache.fetch("CODEHASH") do
           generate_codehash
         end
       end

data/lib/card/content.rb

@@ -1,10 +1,5 @@
 # -*- encoding : utf-8 -*-
 
-require_dependency "card/content/chunk"
-require_dependency "card/content/parser"
-require_dependency "card/content/clean"
-require_dependency "card/content/truncate"
-
 class Card
   # Content objects support the parsing of content strings into arrays that
   # contain semantically meaningful "chunks" like nests, links, urls, etc.
@@ -12,8 +7,10 @@ class Card
   # Each chunk has an object whose class inherits from {Card::Content::Chunk::Abstract}
   #
   class Content < SimpleDelegator
-    extend Card::Content::Clean
-    extend Card::Content::Truncate
+    extend Clean
+    extend Truncate
+
+    Chunk
 
     attr_reader :revision, :format, :chunks, :opts
 
@@ -46,7 +43,7 @@ class Card
     end
 
     def has_chunk? chunk_type
-      each_chunk.any { |chunk| chunk.is_a?(chunk_type)}
+      each_chunk.any { |chunk| chunk.is_a?(chunk_type) }
     end
 
     # sends &block to #process_chunk on each Chunk object

data/lib/card/content/chunk.rb

@@ -89,84 +89,6 @@ class Card
       register_list :nest_only, [:Nest]
       register_list :query, [:QueryReference]
       register_list :stub, [:ViewStub]
-
-      class Abstract
-        class_attribute :config
-        attr_reader :text, :process_chunk
-
-        class << self
-          # if the prefix regex matched check that chunk against the full regex
-          def full_match content, prefix=nil
-            content.match full_re(prefix)
-          end
-
-          def full_re _prefix
-            config[:full_re]
-          end
-
-          def context_ok? _content, _chunk_start
-            true
-          end
-        end
-
-        def reference_code
-          "I"
-        end
-
-        def initialize match, content
-          match = self.class.full_match(match) if match.is_a? String
-          @text = match[0]
-          @processed = nil
-          @content = content
-          interpret match, content
-          self
-        end
-
-        def interpret _match_string, _content
-          Rails.logger.info "no #interpret method found for chunk class: " \
-                            "#{self.class}"
-        end
-
-        def format
-          @content.format
-        end
-
-        def card
-          @content.card
-        end
-
-        def to_s
-          result
-        end
-
-        def result
-          burn_read || @process_chunk || @processed || @text
-        end
-
-        def burn_read
-          return unless @burn_read
-
-          tmp = @burn_read
-          @burn_read = nil
-          tmp
-        end
-
-        # Temporarily overrides the processed nest content for single-use
-        # After using the nest's result
-        # (for example via `to_s`) the original result is restored
-        def burn_after_reading text
-          @burn_read = text
-        end
-
-        def inspect
-          "<##{self.class}##{self}>"
-        end
-
-        def as_json _options={}
-          burn_read || @process_chunk || @processed ||
-            "not rendered #{self.class}, #{card&.name}"
-        end
-      end
     end
   end
   Card::Mod::Loader.load_chunks