card 1.19.6 → 1.20.0

data/lib/card/format/nest/main.rb

@@ -3,32 +3,52 @@ class Card
     module Nest
       # Handle the main nest
       module Main
-        def wrap_main content
-          content # no wrapping in base format
+        def wrap_main
+          yield # no wrapping in base format
         end
 
-        protected
-
         def main_nest opts
-          opts.merge! root.main_opts if root.main_opts
-          legacy_main_opts_tweaks! opts
-
-          with_nest_mode :normal do
-            @mainline = true
-            result = wrap_main nest_card(root.card, opts)
-            @mainline = false
-            result
+          wrap_main do
+            with_nest_mode :normal do
+              nest root.card, opts.merge(main_view: true, main: true)
+            end
           end
         end
 
-        def legacy_main_opts_tweaks! opts
-          if (val = params[:size]) && val.present?
-            opts[:size] = val.to_sym
-          end
+        def main_nest? nest_name
+          nest_name == "_main" && !root.already_mained?
+        end
 
-          if (val = params[:item]) && val.present?
-            opts[:items] = (opts[:items] || {}).reverse_merge view: val.to_sym
-          end
+        def already_mained?
+          return true if @main || @already_main
+          @already_main = true
+          false
+        end
+
+        def main!
+          @main = true
+        end
+
+        def main_nest_options
+          opts = root.main_opts || {}
+          main_nest_size_opt opts
+          main_nest_items_opt opts
+          opts
+        end
+
+        protected
+
+        def main_nest_size_opt opts
+          val = params[:size]
+          return unless val.present?
+          opts[:size] = val.to_sym
+        end
+
+        def main_nest_items_opt opts
+          val = params[:item]
+          return unless val.present?
+          opts[:items] ||= {}
+          opts[:items][:view] = val.to_sym
         end
       end
     end

data/lib/card/format/nest/subformat.rb

@@ -4,28 +4,15 @@ class Card
       module Subformat
         def subformat subcard
           subcard = Card.fetch(subcard, new: {}) if subcard.is_a?(String)
-          self.class.new subcard,
-                         parent: self, depth: @depth + 1, root: @root,
-                         # FIXME: - the following four should not be hard-coded
-                         # here.  need a generalized mechanism
-                         # for attribute inheritance
-                         context_names: @context_names, mode: @mode,
-                         mainline: @mainline, form: @form
+          self.class.new subcard, root: @root, parent: self, depth: @depth + 1,
+                                  form: @form, mode: @mode,
+                                  context_names: @context_names
         end
 
         def field_subformat field
           field = card.cardname.field(field) unless field.is_a?(Card)
           subformat field
         end
-
-        private
-
-        def nest_subformat nested_card, opts
-          return self if opts[:inc_name] =~ /^_(self)?$/
-          sub = subformat nested_card
-          sub.nest_opts = opts[:items] ? opts[:items].clone : {}
-          sub
-        end
       end
     end
   end

data/lib/card/format/nest/view.rb

@@ -1,38 +1,28 @@
 class Card
   class Format
     module Nest
+      NEST_MODES = { new: :edit,
+                     closed_content: :closed,
+                     setup: :edit,
+                     edit: :edit, closed: :closed, layout: :layout,
+                     normal: :normal, template: :template }.freeze
+
       # Renders views for a nests
       module View
-        NEST_MODES = { new: :edit,
-                       closed_content: :closed,
-                       setup: :edit,
-                       edit: :edit, closed: :closed, layout: :layout,
-                       normal: :normal, template: :template }.freeze
-
-        def nest_render view, opts
-          optional_render nest_view(view), opts
-        end
-
         def with_nest_mode mode
-          if (switch_mode = NEST_MODES[mode]) && @mode != switch_mode
-            old_mode = @mode
+          old_mode = @mode
+          if (switch_mode = NEST_MODES[mode])
             @mode = switch_mode
-            @nest_defaults = nil
           end
           result = yield
-          if old_mode
-            @nest_defaults = nil
-            @mode = old_mode
-          end
+          @mode = old_mode
           result
         end
 
-        private
+        # private
 
-        def nest_view view
-          # This was refactored based on the assumption that the subformat
-          # has always the same @mode as its parent format
-          # The nest view used to be based on the mode of the parent format
+        def modal_nest_view view
+          # Note: the subformat always has the same @mode as its parent format
           case @mode
           when :edit then view_in_edit_mode(view)
           when :template then :template_rule
@@ -44,22 +34,23 @@ class Card
         # Returns the view that the card should use
         # if nested in edit mode
         def view_in_edit_mode homeview
-          not_in_form =
-            Card::Format.perms[homeview] == :none || # view configured not to keep in form
-            card.structure || # not yet nesting structures
-            card.key.blank? # eg {{_self|type}} on new cards
+          hide_view_in_edit_mode?(homeview) ? :blank : :edit_in_form
+        end
 
-          not_in_form ? :blank : :edit_in_form
+        def hide_view_in_edit_mode? view
+          Card::Format.perms[view] == :none || # view never edited
+            card.structure                  || # not yet nesting structures
+            card.key.blank?                    # eg {{_self|type}} on new cards
         end
 
         # Return the view that the card should use
         # if nested in closed mode
-        def view_in_closed_mode homeview
-          approved_view = Card::Format.closed[homeview]
+        def view_in_closed_mode view
+          approved_view = Card::Format.closed[view]
           if approved_view == true
-            homeview
-          elsif Card::Format.error_code[homeview]
-            homeview
+            view
+          elsif Card::Format.error_code[view]
+            view
           elsif approved_view
             approved_view
           elsif !card.known?

data/lib/card/format/permission.rb

@@ -1,53 +1,68 @@
 class Card
   class Format
     module Permission
-      def ok_view view, args={}
-        return view if args.delete :skip_permissions
-        approved_view = approved_view view, args
-        args[:denied_view] = view if approved_view != view
-        if focal? && (error_code = Card::Format.error_code[approved_view])
-          root.error_status = error_code
-        end
+      def ok_view view, skip_perms=false
+        return :too_deep if subformats_nested_too_deeply?
+        approved_view = check_view view, skip_perms
+        handle_view_denial view, approved_view
+        assign_view_error_status approved_view
+
         approved_view
       end
 
-      def approved_view view, args={}
+      def handle_view_denial view, approved_view
+        return if approved_view == view
+        @denied_view = view
+      end
+
+      def assign_view_error_status view
+        return unless focal?
+        return unless (error_code = Card::Format.error_code[view])
+        root.error_status = error_code
+      end
+
+      def check_view view, skip_perms
         case
-        when @depth >= Card.config.max_depth
-          # prevent recursion. @depth tracks subformats
-          :too_deep
-        when Card::Format.perms[view] == :none
-          # permission skipping specified in view definition
-          view
-        when args.delete(:skip_permissions)
-          # permission skipping specified in args
-          view
-        when !card.known? && !tagged(view, :unknown_ok)
-          # handle unknown cards (where view not exempt)
-          view_for_unknown view, args
-        else
-          # run explicit permission checks
-          permitted_view view, args
+        when skip_perms                       then view
+        when view_always_permitted?(view)     then view
+        when unknown_disqualifies_view?(view) then view_for_unknown view
+        else permitted_view view  # run explicit permission checks
         end
       end
 
-      def permitted_view view, args
-        perms_required = Card::Format.perms[view] || :read
-        args[:denied_task] =
-          if perms_required.is_a? Proc
-            :read unless perms_required.call(self)  # read isn't quite right
-          else
-            [perms_required].flatten.find { |task| !ok? task }
-          end
-
-        if args[:denied_task]
+      def unknown_disqualifies_view? view
+        # view can't handle unknown cards (and card is unknown)
+        return if tagged view, :unknown_ok
+        card.unknown?
+      end
+
+      def subformats_nested_too_deeply?
+        # prevent recursion
+        @depth >= Card.config.max_depth
+      end
+
+      def view_always_permitted? view
+        Card::Format.perms[view] == :none
+      end
+
+      def permitted_view view
+        if (@denied_task = task_denied_for_view view)
           Card::Format.denial[view] || :denial
         else
           view
         end
       end
 
-      def view_for_unknown _view, _args
+      def task_denied_for_view view
+        perms_required = Card::Format.perms[view] || :read
+        if perms_required.is_a? Proc
+          :read unless perms_required.call(self)  # read isn't quite right
+        else
+          [perms_required].flatten.find { |task| !ok? task }
+        end
+      end
+
+      def view_for_unknown _view
         # note: overridden in HTML
         focal? ? :not_found : :missing
       end

data/lib/card/format/registration.rb

@@ -18,17 +18,19 @@ class Card
         match ? match[:format] : :base
       end
 
+      def interpret_view_opts view, opts
+        extract_class_vars view, opts
+        extract_view_tags view, opts.delete(:tags)
+      end
+
       def extract_class_vars view, opts
-        return unless opts.present?
         [:perms, :error_code, :denial, :closed].each do |varname|
-          class_var = send varname
-          class_var[view] = opts.delete(varname) if opts[varname]
+          next unless (value = opts.delete varname)
+          send(varname)[view] = value
         end
-        extract_view_tags view, opts
       end
 
-      def extract_view_tags view, opts
-        tags = opts.delete :tags
+      def extract_view_tags view, tags
         return unless tags
         Array.wrap(tags).each do |tag|
           view_tags[view] ||= {}
@@ -36,6 +38,10 @@ class Card
         end
       end
 
+      def view_cache_setting_method view
+        "view_#{view}_cache_setting"
+      end
+
       def new card, opts={}
         if self != Format
           super

data/lib/card/format/render.rb

@@ -3,110 +3,99 @@ class Card
     # View rendering methods.
     #
     module Render
-      DEPRECATED_VIEWS = {
-        view: :open, card: :open, line: :closed, bare: :core, naked: :core
-      }.freeze
-
       def render view, args={}
-        view = canonicalize_view view
-        return if hidden_view? view, args
-        view = ok_view view, args
-        current_view(view) do
-          args = default_render_args view, args
-          with_nest_mode view do
-            Card::Cache::ViewCache.fetch(self, view, args) do
-              method = view_method view, args
-              method.arity.zero? ? method.call : method.call(args)
-            end
+        voo = View.new self, view, args, @voo
+        with_voo voo do
+          voo.process do |final_view, options|
+            final_render final_view, options
           end
         end
       rescue => e
         rescue_view e, view
       end
 
-      def render_api match, opts
-        view = match[3] ? match[4] : opts.shift
-        args = opts[0] ? opts.shift.clone : {}
-        optional_render_args(args, opts) if match[2]
-        args[:skip_permissions] = true if match[1]
-        render view, args
+      def with_voo voo
+        old_voo = @voo
+        @voo = voo
+        result = yield
+        @voo = old_voo
+        result
       end
 
-      def optional_render_args args, opts
-        args[:optional] = true
-        args[:default_visibility] = opts.shift
+      def view_options_with_defaults view, options
+        default_method = "default_#{view}_args"
+        send default_method, options if respond_to? default_method
+        options
       end
 
-      def view_method view, args
-        method "_view_#{view}"
-      rescue
-        args[:unsupported_view] = view
-        method "_view_unsupported_view"
+      def voo
+        @voo
       end
 
-      def canonicalize_view view
-        return if view.blank?
-        view_key = view.to_viewname.key.to_sym
-        DEPRECATED_VIEWS[view_key] || view_key
+      def show_view? view, default_viz=:show
+        voo.process_visibility_options # trigger viz processing
+        visibility = voo.viz_hash[view] || default_viz
+        visibility == :show
       end
 
-      def default_item_view
-        :name
+      def final_render view, args
+        current_view(view) do
+          with_nest_mode view do
+            method = view_method view
+            method.arity.zero? ? method.call : method.call(args)
+          end
+        end
       end
 
-      def hidden_view? view, args
-        args.delete(:optional) && !show_view?(view, args)
+      # setting (:alway, :never, :nested) designated in view definition
+      def view_cache_setting view
+        setting_method = self.class.view_cache_setting_method view
+        respond_to?(setting_method) ? send(setting_method) : :standard
       end
 
-      def show_view? view, args
-        code_config = args["optional_#{view}".to_sym]
-        case code_config
-          # permanent visibility specified in code
-        when :always then true
-        when :never  then false
-        else configured_visibility view, args, code_config
+      def stub_render cached_content
+        return cached_content unless cached_content.is_a? String
+        expand_stubs cached_content do |stub_hash|
+          prepare_stub_nest(stub_hash) do |stub_card, mode, options|
+            with_nest_mode(mode) { nest stub_card, options }
+          end
         end
       end
 
-      def configured_visibility view, args, code_config
-        card_config = nest_arg_visibility view, args
-        case (card_config || code_config)
-        when :show then true
-        when :hide then false
-        else
-          default_viz = args.delete :default_visibility
-          default_viz ? default_viz == :show : true
+      def prepare_stub_nest stub_hash
+        stub_card = Card.fetch_from_cast stub_hash[:cast]
+        stub_options = stub_hash[:options]
+        if stub_card.key.present? && stub_card.key == card.key
+          stub_options[:nest_name] ||= "_self"
         end
+        yield stub_card, stub_hash[:mode], stub_options
       end
 
-      def nest_arg_visibility view, args
-        [:show, :hide].each do |setting|
-          return setting if parse_view_visibility(args[setting]).member?(view)
+      def expand_stubs cached_content
+        conto = Card::Content.new cached_content, self, chunk_list: :stub
+        conto.process_each_chunk do |stub_hash|
+          yield(stub_hash).to_s
         end
-        false
+        conto.to_s
       end
 
-      def parse_view_visibility val
-        case val
-        when NilClass then []
-        when Array    then val
-        when String   then val.split(/[\s,]+/)
-        else raise Card::Error, "bad show/hide argument: #{val}"
-        end.map { |view| canonicalize_view view }
+      def api_render match, opts
+        view = match[3] ? match[4] : opts.shift
+        args = opts[0] ? opts.shift.clone : {}
+        optional_render_args(args, opts) if match[2]
+        args[:skip_perms] = true if match[1]
+        render view, args
       end
 
-      def default_render_args view, a=nil
-        args =
-          case a
-          when nil   then {}
-          when Hash  then a.clone
-          when Array then a[0].merge a[1]
-          else raise Card::Error, "bad render args: #{a}"
-          end
+      def optional_render_args args, opts
+        args[:optional] = opts.shift || :show
+      end
 
-        default_method = "default_#{view}_args"
-        send default_method, args if respond_to?(default_method)
-        args
+      def view_method view
+        method "_view_#{view}"
+      rescue
+        voo.unsupported_view = view
+        method "_view_unsupported_view"
       end
 
       def current_view view