card 1.101.0 → 1.101.5

data/lib/card/env/success.rb

@@ -2,10 +2,11 @@ class Card
   module Env
     # Success objects
     class Success
-      include Card::Env::Location
+      include Location
+      include Target
 
-      attr_accessor :redirect, :name, :name_context, :reload
-      attr_writer :params, :card
+      attr_accessor :name, :name_context, :reload
+      attr_writer :params, :redirect, :card
       attr_reader :id
 
       def initialize name_context=nil, success_args=nil
@@ -15,102 +16,30 @@ class Card
         self << normalize_success_args(success_args)
       end
 
+      def to_url name_context=@name_context
+        target = target name_context
+        target.is_a?(Card) ? target.format.path(params) : target
+      end
+
       def in_context name_context
         self.name_context = name_context
         self
       end
 
-      def normalize_success_args success_args
-        case success_args
-        when nil
-          self.mark = "_self"
-          {}
-        when ActionController::Parameters
-          success_args.to_unsafe_h
-        else
-          success_args
-        end
-      end
-
       def << value
         if value.is_a? Hash
           apply value
         else
-          self.target = value
+          self.mark = value
         end
       end
 
-      def reload?
-        @reload.to_s == "true"
+      def redirect
+        @redirect.present? ? @redirect : false
       end
 
-      # TODO: refactor to use cardish
-      def mark= value
-        case value
-        when Integer then @id = value
-        when String then @name = value
-        when Card then @card = value
-        else
-          self.target = value
-        end
-      end
-
-      # @deprecated
-      def id= id
-        # for backwards compatibility use mark here.
-        # id was often used for the card name
-        self.mark = id
-      end
-
-      def type= type
-        @new_args[:type] = type
-      end
-
-      def type_id= type_id
-        @new_args[:type_id] = type_id.to_i
-      end
-
-      def content= content
-        @new_args[:content] = content
-      end
-
-      def target= value
-        @id = @name = @card = nil
-        @target = process_target value
-      end
-
-      def process_target value
-        case value
-        when ""                     then ""
-        when "*previous", :previous then :previous
-        when %r{^(http|/)}          then value
-        when /^REDIRECT:\s*(.+)/
-          @redirect = true
-          process_target Regexp.last_match(1)
-        else self.mark = value
-        end
-      end
-
-      def apply hash
-        hash.each_pair do |key, value|
-          self[key] = value
-        end
-      end
-
-      def card name_context=@name_context
-        if @card
-          @card
-        elsif @id
-          Card.fetch @id
-        elsif @name
-          Card.fetch @name.to_name.absolute(name_context), new: @new_args
-        end
-      end
-
-      def target name_context=@name_context
-        card(name_context) ||
-          (@target == :previous ? Card::Env.previous_location : @target) ||
-          Card.fetch(name_context)
+      def reload?
+        @reload.to_s == "true"
       end
 
       def []= key, value
@@ -139,32 +68,46 @@ class Card
         @params.marshal_dump
       end
 
-      def raw_params
-        @params
+      def session
+        Card::Env.session
       end
 
-      def to_url name_context=@name_context
-        case (target = target(name_context))
-        when Card
-          target.format.path params
-        else
-          target
-        end
+      private
+
+      def respond_to_missing? method, _include_private=false
+        method.match?(/^(\w+)=?$/) || super
       end
 
       def method_missing method, *args
-        case method
-        when /^(\w+)=$/
-          self[Regexp.last_match(1).to_sym] = args[0]
-        when /^(\w+)$/
-          self[Regexp.last_match(1).to_sym]
-        else
-          super
+        return super unless (m = method.match(/^(\w+(=)?)/))
+
+        infer_bracket m[1].to_sym, m[2], args[0]
+      end
+
+      def infer_bracket method, assign, val
+        args = [method]
+        args << val if assign
+        @params.send(*args)
+      end
+
+      def apply hash
+        hash.each_pair do |key, value|
+          next unless value.present?
+
+          self[key] = value
         end
       end
 
-      def session
-        Card::Env.session
+      def normalize_success_args success_args
+        case success_args
+        when nil
+          self.mark = "_self"
+          {}
+        when ActionController::Parameters
+          success_args.to_unsafe_h
+        else
+          success_args
+        end
       end
     end
   end

data/lib/card/env/success/target.rb

@@ -0,0 +1,73 @@
+class Card
+  module Env
+    class Success
+      # The success "target" is the destination upon success.
+      #
+      # @card, @name, @id, etc all refer to the target card
+      module Target
+        def target= value
+          @id = @name = @card = nil
+          @target = process_target value
+        end
+
+        def target name_context=@name_context
+          card(name_context) || @target || Card.fetch(name_context)
+        end
+
+        # TODO: refactor to use cardish
+        def mark= value
+          case value
+          when Integer then @id = value
+          when Card then @card = value
+          else
+            self.target = value
+          end
+        end
+
+        # @deprecated
+        def id= id
+          # for backwards compatibility use mark here.
+          # id was often used for the card name
+          self.mark = id
+        end
+
+        def type= type
+          @new_args[:type] = type
+        end
+
+        def type_id= type_id
+          @new_args[:type_id] = type_id.to_i
+        end
+
+        def content= content
+          @new_args[:content] = content
+        end
+
+        def card name_context=@name_context
+          if @card
+            @card
+          elsif @id
+            Card.fetch @id
+          elsif @name
+            Card.fetch @name.to_name.absolute(name_context), new: @new_args
+          end
+        end
+
+        private
+
+        def process_target value
+          case value
+          when ""
+            ""
+          when "*previous", ":previous", :previous
+            Card::Env.previous_location
+          when %r{^(http|/)}
+            value
+          else
+            @name = Name[value]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/card/error.rb

@@ -22,8 +22,7 @@ class Card
     end
 
     def message_from_card
-      I18n.t :exception_for_card,
-             scope: %i[lib card error], cardname: card.name, message: card_message_text
+      Cardio.t :lib_exception_for_card, cardname: card.name, message: card_message_text
     end
 
     def backtrace

data/lib/card/fetch.rb

@@ -10,7 +10,6 @@ class Card
     # see arg options in all/fetch
     def initialize *args
       normalize_args args
-      absolutize_mark
       validate_opts!
     end
 
@@ -31,15 +30,19 @@ class Card
     def normalize_args args
       @opts = args.last.is_a?(Hash) ? args.pop : {}
       @mark = Card.id_or_name args
+      normalize_mark
     end
 
-    def absolutize_mark
-      return unless mark.name? && (supercard = opts.dig(:new, :supercard))
-      @mark = mark.absolute_name supercard.name
+    def normalize_mark
+      return unless mark.name?
+
+      supercard = opts.dig :new, :supercard
+      @mark = mark.absolute_name supercard.name if supercard
     end
 
     def validate_opts!
       return unless opts[:new] && opts[:skip_virtual]
+
       raise Card::Error, "fetch called with new args and skip_virtual"
     end
 

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