card 1.91 → 1.92

data/lib/card/view/options.rb

@@ -1,64 +1,86 @@
 class Card
   class View
-    # normalizes and manages standard view options
     module Options
-      # option values are strings unless otherwise noted
+      # Manages options for card views, including those used in nest syntax
+
+      # the keymap represents a 2x2 matrix, where the factors are
+      # (a) whether an option's value can be set by a Carditect via nests, and
+      # (b) whether nested views can inherit the option from a parent view.
+      #
+      #                  use in nests  | don't use
+      #                 ________________________________
+      #       inherit  | both          | heir
+      # don't inherit  | carditect     | none
+      #
+      # (note: each option will likely some day merit its own object)
+
       @keymap = {
-        nest: [
+        carditect: [
           :view,          # view to render
-          :show,          # render these views when optional
-          :hide,          # do not render these views when optional
           :nest_name,     # name as used in nest
-          :nest_syntax    # full nest syntax
-        ],
-        # note: show/hide can be single view (Symbol), list of views (Array),
-        # or comma separated views (String)
+          :nest_syntax,   # full nest syntax
+          :show,          # render these views when optional
+          :hide           # do not render these views when optional
+        ],                # note: show/hide can be single view (Symbol), list of views (Array),
+                          # or comma separated views (String)
         heir: [
           :main,           # format object is page's "main" object (Boolean)
           :home_view,      # view for slot to return to when no view specified
           :edit_structure  # use a different structure for editing (Array)
         ],
         both: [
-          :help, # cue text when editing
-          :structure, # overrides the content of the card
-          :title, # overrides the name of the card
-          :variant, # override the canonical version of the name with
-          #                a different variant
-          :editor, # inline_nests makes a form within standard content
-          #                (Symbol)
-          :type, # set the default type of new cards
-          :size, # set an image size
-          :params, # parameters for add button.  deprecate?
-          :items, # options for items (Hash)
-          :cache # change view cache behaviour
-        #                (Symbol<:always, :standard, :never>)
-        ],
+          :help,           # cue text when editing
+          :structure,      # overrides the content of the card
+          :title,          # overrides the name of the card
+          :variant,        # override the canonical version of the name with a different variant
+          :editor,         # inline_nests makes a form within standard content (Symbol)
+          :type,           # set the default type of new cards
+          :size,           # set an image size
+          :params,         # parameters for add button.  deprecate?
+          :items,          # options for items (Hash)
+          :cache           # change view cache behaviour
+        ],                 # (Symbol<:always, :standard, :never>)
         none: [
-          :skip_perms,  # do not check permissions for this view (Boolean)
-          :main_view
-        ]   # this is main view of page (Boolean)
+          :skip_perms,     # do not check permissions for this view (Boolean)
+          :main_view       # this is main view of page (Boolean)
+        ]
       }
+      # Note: option values are strings unless otherwise noted
+
+      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      # CLASS METHODS
 
       class << self
         attr_reader :keymap
 
+        # KEY LISTS
+
         # all standard option keys
+        # @return [Array]
         def all_keys
           @all_keys ||= keymap.each_with_object([]) { |(_k, v), a| a.push(*v) }
         end
 
         # keys whose values can be set by Wagneers in card nests
-        def nest_keys
-          @nest_keys ||= ::Set.new(keymap[:both]) + keymap[:nest]
+        # @return [Array]
+        def carditect_keys
+          @carditect_keys ||= ::Set.new(keymap[:both]) + keymap[:carditect]
         end
 
         # keys that follow simple standard inheritance pattern from parent views
+        # @return [Array]
         def heir_keys
           @heir_keys ||= ::Set.new(keymap[:both]) + keymap[:heir]
         end
 
+        # Keys that can be read or written via accessors
+        # @return [Array]
         def accessible_keys
-          heir_keys + [:nest_name, :nest_syntax] - [:items]
+          all_keys - [     # (all but the following)
+              :view,       # view is accessed as requested_view or ok_view and cannot be directly manipulated
+              :show, :hide # these have a more extensive API (see Card::View::Visibility)
+              #:items,
+          ]
         end
 
         def define_getter option_key
@@ -76,40 +98,45 @@ class Card
         end
       end
 
+      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      # VOO API
+
+      # The following methods allow developers to read and write options dynamically.
+
+
       # There are two primary options hashes:
-      # - @normalized_options are determined upon initialization and do not
-      #   change after that.
-      # - @live_options are created during the "process" phase, and they can be
-      #   altered via the "voo" API at any time
 
+      # - @normalized_options are determined upon initialization and do not change after that.
+      # @return [Hash] options
       attr_reader :normalized_options
 
+      # - @live_options are dynamic and can be altered by the "voo" API at any time. Such alterations are
+      #   NOT used in stubs
+      # @return [Hash]
       def live_options
         @live_options ||= process_live_options
       end
 
-      # The following methods comprise the primary voo API.  They allow
-      # developers to read and write options dynamically
 
-      def items
-        live_options[:items] ||= {}
-      end
+      # Developers can also set most options directly via accessors, eg voo.title = "King"
+      # :view, :show, and :hide have non-standard access (see #accessible_keys)
 
       accessible_keys.each do |option_key|
         define_getter option_key
         define_setter option_key
       end
 
-      def normalize_editor value
-        value && value.to_sym
-      end
 
-      def normalize_cache value
-        value && value.to_sym
+      # "items", the option used to configure views of each of a list of cards, is
+      # currently the only Hash option (thus this accessor override)
+      # @return [Hash]
+      def items
+        live_options[:items] ||= {}
       end
 
       # options to be used in data attributes of card slots (normalized options
       # with standard keys)
+      # @return [Hash]
       def slot_options
         normalized_options.select { |k, _v| Options.all_keys.include? k }
       end
@@ -117,13 +144,23 @@ class Card
       def closest_live_option key
         if live_options.key? key
           live_options[key]
-        else
-          (parent && parent.closest_live_option(key)) ||
-            (format.parent && format.parent.voo &&
-              format.parent.voo.closest_live_option(key))
+        elsif (ancestor = next_ancestor)
+          ancestor.closest_live_option key
         end
       end
 
+      # ACCESSOR_HELPERS
+      # methods that follow the normalize_#{key} pattern are called by accessors
+      # (arguably that should be done during normalization!)
+
+      def normalize_editor value
+        value && value.to_sym
+      end
+
+      def normalize_cache value
+        value && value.to_sym
+      end
+
       private
 
       # option normalization includes standardizing options into a hash with
@@ -138,15 +175,18 @@ class Card
         opts
       end
 
+
       # typically options are already a hash.  this also handles an array of
       # hashes and nil.
       def options_to_hash opts
         case opts
-        when Hash  then opts
-        when Array then opts[0].merge opts[1]
+        when ActionController::Parameters
+          opts.to_unsafe_h.deep_symbolize_keys
+        when Hash  then opts.deep_symbolize_keys!
+        when Array then opts[0].merge(opts[1]).deep_symbolize_keys!
         when nil   then {}
         else raise Card::Error, "bad view options: #{opts}"
-        end.deep_symbolize_keys!
+        end
       end
 
       # standard inheritance from parent view object
@@ -160,9 +200,9 @@ class Card
       def process_live_options
         opts = @live_options = normalized_options.clone
         opts.merge! format.main_nest_options if opts[:main_view]
-        # main_view is a live_option because it is important that it NOT be
-        # locked in the stub.  Otherwise the main card can only show one view.
+        # main_nest_options are not processed in normalize_options so that they're NOT locked in the stub.
         process_default_options
+        process_visibility_options
         opts
       end
 
@@ -174,17 +214,27 @@ class Card
 
       # "foreign" options are non-standard options.  They're allowed, but they
       # prevent independent caching (and thus stubbing)
-      def foreign_options opts
-        opts.reject { |k, _v| Options.all_keys.include? k }
-      end
 
+      # non-standard options that are found in normalized_options
+      # @return [Hash] options Hash
       def foreign_normalized_options
-        @foreign_normalize_options ||= foreign_options normalized_options
+        @foreign_normalize_options ||= foreign_options_in normalized_options
       end
 
+      # non-standard options that are found in live_options
+      # @return [Hash] options Hash
       def foreign_live_options
-        foreign_options live_options
+        foreign_options_in live_options
       end
+
+      # find non-standard option in Hash
+      # @param opts [Hash] options hash
+      # @return [Hash] options Hash
+      def foreign_options_in opts
+        opts.reject { |k, _v| Options.all_keys.include? k }
+      end
+
+
     end
   end
 end

data/lib/card/view/stub.rb

@@ -1,29 +1,63 @@
 class Card
   class View
-    # A "stub" is a placeholder for a card view. It can only be used in
-    # situations where the card identifier, known options, and nest mode
-    # comprise all the info needed to reproduce the view as intended
+    # A "stub" is a placeholder for a card view.
+    #
+    # Cached views use stubs so that _nesting_ content can remained cached
+    # even while _nested_ content changes. The nested content's place is held
+    # by a stub.
+    #
+    # A stub must contain all the information necessary to produce the view as intended.
+    #
     module Stub
+      # @return [String]
       def stub
-        "<card-view>#{stub_json}</card-view>"
+        "<card-view>#{stub_json}</card-view>".html_safe
       end
 
+      # @return [String] the stub_hash as JSON
       def stub_json
         JSON.generate stub_hash
       end
 
+      # @return [Hash]
       def stub_hash
-        {
-          cast: card.cast,
-          options: normalized_options,
-          mode: format.mode
-        }
+        with_override mode: format.nest_mode,
+                      cast: card.cast,
+                      options: normalized_options,
+                      override: root?
       end
 
-      def validate_stub
+      # handle nest_mode in stub
+      # @return [Hash]
+      def with_override hash
+
+        # typically modes only override views on nests, but stubs create non-standard nests
+        # mode-based view overrides should NOT apply to standard render calls that have
+        # been replaced with stubs - only to standard nest calls. therefore modes are not
+        # stored in non-standard nest stubs
+        hash
+      end
+
+      def validate_stub!
+        reject_foreign_options_in_stub!
+        #reject_illegal_stub_values!
+      end
+
+      #def reject_illegal_stub_values!
+      #  normalized_options.each do |key, value|
+      #    next unless value =~ /\</
+      #    raise invalid_stub + " has illegal value for #{key}: #{value}"
+      #  end
+      #end
+
+      def invalid_stub
+        "INVALID STUB: #{card.name}/#{ok_view}"
+      end
+
+
+      def reject_foreign_options_in_stub!
         return if foreign_normalized_options.empty?
-        raise "INVALID STUB: #{card.name}/#{ok_view}" \
-              " has foreign options: #{foreign_normalized_options}"
+        raise invalid_stub + " has foreign options: #{foreign_normalized_options}"
       end
     end
   end

data/lib/card/view/visibility.rb

@@ -57,11 +57,11 @@ class Card
         show? view
       end
 
-      # test whether main_view is optional
+      # test whether view is optional
       # (@optional is set in normalize_options
+      # @return [true/false]
       def optional?
-        return @optional unless @optional.nil?
-        @optional = detect_if_optional
+        @optional
       end
 
       # translate raw hide, show options (which can be strings, symbols,

data/lib/cardio.rb

@@ -7,7 +7,7 @@ require "cardio/schema.rb"
 
 ActiveSupport.on_load :card do
   if Card.take
-    Card::Mod::Loader.load_mods
+    Card::Mod.load
   else
     Rails.logger.warn "empty database"
   end
@@ -47,10 +47,10 @@ module Cardio
         acts_per_page:          10,
         space_last_in_multispace: true,
         closed_search_limit:    10,
-        paging_limit: 20,
+        paging_limit:           20,
 
         non_createable_types:   [%w(signup setting set)],
-        view_cache: false,
+        view_cache:             true,
 
         encoding:               "utf-8",
         request_logger:         false,
@@ -59,7 +59,9 @@ module Cardio
 
         file_storage:           :local,
         file_buckets:           {},
-        file_default_bucket: nil
+        file_default_bucket:    nil,
+
+        allow_irreversible_admin_tasks: false
       }
     end
 
@@ -70,6 +72,8 @@ module Cardio
       config.autoload_paths += Dir["#{gem_root}/mod/*/lib/**/"]
       config.autoload_paths += Dir["#{root}/mod/*/lib/**/"]
 
+      #config.autoload_paths += Dir["#{root}/mod/*/set/**/"]
+
       default_configs.each_pair do |setting, value|
         set_default_value(config, setting, *value)
       end
@@ -157,7 +161,7 @@ module Cardio
     def migration_paths type
       list = paths["db/migrate#{schema_suffix type}"].to_a
       if type == :deck_cards
-        Card::Mod::Loader.mod_dirs.each("db/migrate_cards") do |path|
+        Card::Mod.dirs.each("db/migrate_cards") do |path|
           list += Dir.glob path
         end
       end

data/mod/account/set/right/account.rb

@@ -84,7 +84,7 @@ end
 
 event :validate_accountability, :prepare_to_validate, on: :create do
   unless left && left.accountable?
-    errors.add :content, "not allowed on this card"
+    errors.add :content, tr(:error_not_allowed)
   end
 end
 
@@ -131,8 +131,7 @@ def reset_password_try_again
   send_reset_password_token
   { id: "_self",
     view: "message",
-    message: "Sorry, #{errors.first.last}. " \
-             "Please check your email for a new password reset link." }
+    message: tr(:sorry_email_reset, error_msg: errors.first.last) }
 end
 
 def edit_password_success_args; end

data/mod/account/set/right/email.rb

@@ -14,7 +14,7 @@ view :core, :raw
 
 event :validate_email, :validate, on: :save do
   if content.present? && content !~ /^([^@\s]+)@((?:[-a-z0-9]+\.)+[a-z]{2,})$/i
-    errors.add :content, "must be valid address"
+    errors.add :content, tr(:error_invalid_address)
   end
 end
 
@@ -23,9 +23,9 @@ event :validate_unique_email, after: :validate_email, on: :save do
     Auth.as_bot do
       wql = { right_id: Card::EmailID, eq: content, return: :id }
       wql[:not] = { id: id } if id
-      wql_comment = "email duplicate? (#{content})"
+      wql_comment = tr(:search_email_duplicate, content: content)
       if Card.search(wql, wql_comment).first
-        errors.add :content, "must be unique"
+        errors.add :content, tr(:error_not_unique)
       end
     end
   end
@@ -44,8 +44,7 @@ def ok_to_read
   if own_email? || Auth.always_ok?
     true
   else
-    deny_because "viewing email is restricted to administrators and " \
-                 "account holders"
+    deny_because tr(:deny_email_restricted)
   end
 end