card 1.101.2 → 1.102.0

data/lib/card/fetch/all.rb

@@ -0,0 +1,33 @@
+class Card
+  class Fetch
+    # fetch-related Card instance methods
+    module All
+      # fetching from the context of a card
+      def fetch traits, opts={}
+        opts[:new][:supercard] = self if opts[:new]
+        Array.wrap(traits).inject(self) do |card, trait|
+          Card.fetch card.name.trait(trait), opts
+        end
+      end
+
+      def newish opts
+        reset_patterns
+        Card.with_normalized_new_args opts do |norm_opts|
+          handle_type norm_opts do
+            assign_attributes norm_opts
+            self.name = name # trigger superize_name
+          end
+        end
+      end
+
+      def refresh force=false
+        return self unless force || frozen? || readonly?
+        return unless id
+
+        fresh_card = self.class.find id
+        fresh_card.include_set_modules
+        fresh_card
+      end
+    end
+  end
+end

data/lib/card/fetch/card_class.rb

@@ -0,0 +1,155 @@
+class Card
+  class Fetch
+    # = Card#fetch
+    #
+    # A multipurpose retrieval operator that integrates caching, database lookups,
+    # and "virtual" card construction
+    module CardClass
+      # Look for cards in
+      # * cache
+      # * database
+      # * virtual cards
+      #
+      # @param args [Integer, String, Card::Name, Symbol, Array]
+      #    Initials args must be one or more "marks," which uniquely idenfify cards:
+      #      1. a name/key. (String or Card::Name)
+      #      2. a numeric id. Can be (a) an Integer or (b) a String with an integer
+      #         prefixed with a tilde, eg "~1234"
+      #      3. a codename. Can be (a) a Symbol or (b) a String with a colon prefix,
+      #         eg :mycodename
+      #    If you pass more then one mark or an array of marks they get joined with a '+'.
+      #    The final argument can be a Hash to set the following options
+      #      :skip_virtual               Real cards only
+      #      :skip_modules               Don't load Set modules
+      #      :look_in_trash              Return trashed card objects
+      #      :local_only                 Use only local cache for lookup and storing
+      #      new: { opts for Card#new }  Return a new card when not found
+      # @return [Card]
+      def fetch *args
+        f = Card::Fetch.new(*args)
+        f.retrieve_or_new
+      rescue ActiveModel::RangeError => _e
+        Card.new name: "card id out of range: #{f.mark}"
+      end
+
+      # fetch only real (no virtual) cards
+      #
+      # @param mark - see #fetch
+      # @return [Card]
+      def [] *mark
+        fetch(*mark, skip_virtual: true)
+      end
+
+      # fetch real cards without set modules loaded. Should only be used for
+      # simple attributes
+      #
+      # @example
+      #   quick_fetch "A", :self, :structure
+      #
+      # @param mark - see #fetch
+      # @return [Card]
+      def quick_fetch *mark
+        fetch(*mark, skip_virtual: true, skip_modules: true)
+      end
+
+      # @return [Card]
+      def fetch_from_cast cast
+        fetch_args = cast[:id] ? [cast[:id].to_i] : [cast[:name], { new: cast }]
+        fetch(*fetch_args)
+      end
+
+      #----------------------------------------------------------------------
+      # ATTRIBUTE FETCHING
+      # The following methods optimize fetching of specific attributes
+
+      def id cardish
+        case cardish
+        when Integer then cardish
+        when Card then cardish.id
+        when Symbol then Card::Codename.id cardish
+        else fetch_id cardish
+        end
+      end
+
+      # @param mark_parts - see #fetch
+      # @return [Integer]
+      def fetch_id *mark_parts
+        mark = Card::Fetch.new(*mark_parts)&.mark
+        mark.is_a?(Integer) ? mark : quick_fetch(mark.to_s)&.id
+      end
+
+      # @param mark - see #fetch
+      # @return [Card::Name]
+      def fetch_name *mark, &block
+        if (card = quick_fetch(*mark))
+          card.name
+        elsif block_given?
+          yield.to_name
+        end
+      rescue StandardError => e
+        rescue_fetch_name e, &block
+      end
+
+      # @param mark - see #fetch
+      # @return [Integer]
+      def fetch_type_id *mark
+        fetch(*mark, skip_modules: true)&.type_id
+      end
+
+      # Specialized fetching appropriate for cards requested by URI
+      # @param params [Hash] hash in the style of parameters expected by Decko
+      # @option params [Hash] :card arguments for Card.new
+      # @option params [String] :mark.
+      # @option params [String] :type shortcut for card[:type]
+      # @option params [True/False] :look_in_trash - passed to Card.fetch
+      # @option params [True/False] :assign - override attributes of fetched card with
+      #   card hash
+      def uri_fetch params
+        card_opts = uri_fetch_opts params
+        if params[:action] == "create"
+          # FIXME: we currently need a "new" card to catch duplicates
+          # (otherwise save will just act like a normal update)
+          # We may need a "#create" instance method to handle this checking?
+          Card.new card_opts
+        else
+          standard_uri_fetch params, card_opts
+        end
+      end
+
+      private
+
+      def standard_uri_fetch params, card_opts
+        mark = params[:mark] || card_opts[:name]
+        card = fetch mark, new: card_opts,
+                           skip_modules: true,
+                           look_in_trash: params[:look_in_trash]
+        card.assign_attributes card_opts if params[:assign] && card&.real?
+        card&.include_set_modules
+        card
+      end
+
+      def uri_fetch_opts params
+        Env.hash(params[:card]).tap do |opts|
+          opts[:type] ||= params[:type] if params[:type] # for /new/:type shortcut.
+          opts[:name] ||= Name[params[:mark]]&.tr "_", " "
+        end
+      end
+
+      def rescue_fetch_name error, &block
+        if rescued_fetch_name_to_name? error, &block
+          yield.to_name
+        elsif error.is_a? ActiveModel::RangeError
+          nil
+        else
+          raise error
+        end
+      end
+
+      def rescued_fetch_name_to_name? error
+        return unless block_given?
+
+        error.is_a?(ActiveModel::RangeError) || error.is_a?(Error::CodenameNotFound)
+      end
+    end
+  end
+end

data/lib/card/fetch/results.rb

@@ -4,6 +4,7 @@ class Card
     module Results
       def results
         return if card.nil?
+
         card.new_card? ? new_result_card : finalize_result_card
       end
 
@@ -34,6 +35,7 @@ class Card
 
       def renew
         return if new_opts.blank?
+
         # Rails.logger.info "renewing: #{mark}, #{new_opts}"
         @card = card.dup
         @card.newish newish_opts
@@ -59,6 +61,7 @@ class Card
 
       def update_supercard
         return unless (sc = new_opts[:supercard])
+
         @card.supercard = sc
         @card.update_superleft @card.name
       end
@@ -67,6 +70,7 @@ class Card
         return true if new_opts.blank?
         return false if type_change? || name_change?
         return false if fancy_renew?
+
         quick_content
         true
       end
@@ -84,19 +88,23 @@ class Card
 
       def quick_content
         return unless (content = assignable_content(new_opts[:default_content]))
+
         @card.content = content
       end
 
       def name_change?
         return false unless (new_name = new_opts[:name]&.to_name)
         return false if new_name.relative? && mark.name? && mark.absolute?
+
         new_name.to_s != @card.name.to_s
       end
 
       def type_change?
         return true if @card.type_id.nil?
+
         type_id = type_id_from_new_opts
         return true if !type_id && supercard_might_change_type?
+
         type_id && (type_id != @card.type_id)
       end
 
@@ -118,6 +126,7 @@ class Card
       def assign_name_from_mark
         return if opts[:local_only]
         return unless mark&.to_s != card.name
+
         card.name = mark.to_s
       end
     end

data/lib/card/fetch/retrieve.rb

@@ -5,6 +5,7 @@ class Card
       # look for card in cache.  if that doesn't work, look in database
       def retrieve_existing
         return unless mark.present?
+
         retrieve_from_cache || retrieve_from_db
       end
 
@@ -26,6 +27,7 @@ class Card
 
       def retrieval_from_db_query
         return unless (query = retrieval_from_db_query_base)
+
         query[:trash] = false unless look_in_trash?
         query
       end

data/lib/card/fetch/store.rb

@@ -20,6 +20,7 @@ class Card
       # instantiate a card as a cache placeholder
       def new_for_cache
         return unless new_for_cache?
+
         args = { name: mark, skip_modules: true }
         args[:type_lookup] = :skip if skip_type_lookup?
         args.merge! new_opts.slice(:type, :type_id, :type_code) if eager_caching?

data/lib/card/format.rb

@@ -47,7 +47,7 @@ class Card
     def require_card_to_initialize!
       return if @card
 
-      raise Card::Error, Cardio.t(:exception_init_without_card)
+      raise Card::Error, Cardio.t(:lib_exception_init_without_card)
     end
 
     def include_set_format_modules

data/lib/card/format/content.rb

@@ -2,7 +2,7 @@ class Card
   class Format
     module Content
       def process_content override_content=nil, content_opts=nil, &block
-        content_obj = content_object override_content , content_opts
+        content_obj = content_object override_content, content_opts
         content_obj.process_chunks(&block)
         content_obj.to_s
       end
@@ -82,8 +82,6 @@ class Card
         content ||= render_raw || ""
         Card::Content.new content, self, content_opts
       end
-
-
     end
   end
 end

data/lib/card/format/error.rb

@@ -8,6 +8,7 @@ class Card
 
       def anyone_can? task
         return false unless task.is_a? Symbol
+
         @anyone_can ||= {}
         @anyone_can[task] = card.anyone_can? task if @anyone_can[task].nil?
         @anyone_can[task]
@@ -29,7 +30,11 @@ class Card
       end
 
       def monitor_depth
-        raise Card::Error::UserError, tr(:too_deep) if depth >= Card.config.max_depth
+        if depth >= Card.config.max_depth
+          raise Card::Error::UserError,
+                t(:format_too_deep)
+        end
+
         yield
       end
 
@@ -42,7 +47,7 @@ class Card
         if card&.name.present?
           safe_name
         else
-          Cardio.tr :no_cardname
+          Cardio.t :lib_no_cardname
         end
       end
 
@@ -71,7 +76,7 @@ class Card
         if exception.is_a? Card::Error::UserError
           exception.message
         else
-          tr :error_rendering, cardname: error_cardname(exception), view: view
+          t :lib_error_rendering, cardname: error_cardname(exception), view: view
         end
       end
     end

data/lib/card/format/method_delegation.rb

@@ -46,12 +46,20 @@ class Card
 
       def render_args underscore, bang, opts
         # opts is a list; args is a hash. we're using various inputs to build the hash
-        (opts[0] ? opts.shift.clone : {}).tap do |args|
-          args[:optional] = (opts.shift || args[:optional] || :show) unless bang
+        interpret_render_opts opts do |args|
+          args[:optional] = optional_render_opt opts, args unless bang
           args[:skip_perms] = true if underscore
         end
       end
 
+      def interpret_render_opts opts, &block
+        (opts[0] ? opts.shift.clone : {}).tap(&block)
+      end
+
+      def optional_render_opt opts, args
+        opts.shift || args[:optional] || :show
+      end
+
       def new_action_view
         CardActionView.new(controller).tap do |t|
           t.extend CardController._helpers

data/lib/card/format/nest.rb

@@ -2,16 +2,17 @@ class Card
   class Format
     # processing nests
     class Nest
-      include Fetch
+      include Nest::Fetch
 
       attr_accessor :format, :card, :view, :view_opts, :format_opts
+
       def initialize format, cardish, view_opts={}, format_opts={}
         @format = format
         @view_opts = view_opts
         @format_opts = format_opts.clone
         @override = @format_opts.delete(:override) != false
         @card ||= fetch_card cardish
-        # note: fetch_card can alter view and view_opts[:nest_name]
+        # NOTE: fetch_card can alter view and view_opts[:nest_name]
       end
 
       def prepare

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

@@ -24,7 +24,7 @@ class Card
         end
 
         def not_found_codename_error codename
-          Cardio.tr :exception_unknown_codename, codename: codename
+          Cardio.t :lib_exception_unknown_codename, codename: codename
         end
 
         def new_card cardish
@@ -43,12 +43,14 @@ class Card
         def new_supercard_args
           # special case.  gets absolutized incorrectly. fix in name?
           return {} if view_opts[:nest_name].strip.blank?
+
           { supercard: format.context_card }
         end
 
         def new_main_args
           nest_name = view_opts[:nest_name]
           return {} unless nest_name =~ /main/
+
           { name: nest_name.gsub(/^_main\+/, "+"),
             supercard: format.root.card }
         end

data/lib/card/format/nesting/mode.rb

@@ -41,7 +41,7 @@ class Card
         # @param view [Symbol]
         # @return [Symbol ] viewname
         def modal_nest_view view
-          # Note: the subformat always has the same nest_mode as its parent format
+          # NOTE: the subformat always has the same nest_mode as its parent format
           case nest_mode
           when :edit     then view_in_edit_mode(view)
           when :template then :template_nest

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

@@ -3,7 +3,7 @@ class Card
     module Nesting
       # Formats can have subformats. Lineage can be retraced through "parent" format.
       module Subformat
-        # note: while it is possible to have a subformat of a different class,
+        # NOTE: while it is possible to have a subformat of a different class,
         # the :format_class value takes precedence over :format.
         def subformat subcard, opts={}
           subcard = subformat_card subcard
@@ -56,6 +56,7 @@ class Card
 
         def subformat_card subcard
           return subcard if subcard.is_a? Card
+
           Card.fetch subcard, new: {}
         end
       end

data/lib/card/format/render.rb

@@ -65,8 +65,8 @@ class Card
       end
 
       def pretty_path source_location
-        source_location.first.gsub(%r{^.+mod\d+-([^/]+)}, '\1: ') + ":" +
-          source_location.second.to_s
+        "#{source_location.first.gsub(%r{^.+mod\d+-([^/]+)},
+                                      '\1: ')}:#{source_location.second}"
       end
 
       # :standard, :always, :never