card 1.96.8 → 1.97.0

data/lib/card/set_pattern.rb

@@ -8,10 +8,9 @@ class Card
 
         def card_keys
           @card_keys ||=
-            Card.set_patterns.inject({}) do |hash, set_pattern|
+            Card.set_patterns.each_with_object({}) do |set_pattern, hash|
               card_key = Card.quick_fetch(set_pattern.pattern_code).key
               hash[card_key] = true
-              hash
             end
         end
 
@@ -24,7 +23,8 @@ class Card
       class Abstract
         class << self
           attr_accessor :pattern_code, :pattern_id, :junction_only,
-                        :assigns_type, :anchorless, :anchor_parts_count
+                        :assigns_type, :anchorless
+          attr_writer :anchor_parts_count
 
           def new card
             super if pattern_applies? card
@@ -64,6 +64,7 @@ class Card
           def module_key anchor_codes
             return pattern_code.to_s.camelize if anchorless?
             return unless anchor_codes # is this not an error?
+
             ([pattern_code] + anchor_codes).map { |code| code.to_s.camelize }.join "::"
           end
         end
@@ -116,6 +117,7 @@ class Card
 
         def anchor_parts
           return [@anchor_name] unless anchor_parts_count > 1
+
           parts = @anchor_name.parts
           if parts.size <= anchor_parts_count
             parts
@@ -184,16 +186,18 @@ class Card
 
       def lookup_inherited_key
         return unless @inherit_card
+
         card = @inherit_card
         @inherit_card = nil
         return unless (type_code = default_type_code card)
+
         mod_key = "Type::#{type_code.to_s.camelize}"
         mod_key if mods_exist_for_key? mod_key
       end
 
       def default_type_code card
         default_rule = card.rule_card :default
-        default_rule && default_rule.type_code
+        default_rule&.type_code
       end
 
       def mods_exist_for_key? mod_key

data/lib/card/subcards.rb

@@ -36,6 +36,7 @@ class Card
 
     def card name
       return unless @keys.include? name.to_name.key
+
       fetch_subcard name
     end
 
@@ -51,12 +52,18 @@ class Card
 
     def rename old_name, new_name
       return unless @keys.include? old_name.to_name.key
+
       @keys.delete old_name.to_name.key
       @keys << new_name.to_name.key
     end
 
+    def respond_to_missing? method_name, _include_private=false
+      @keys.respond_to? method_name
+    end
+
     def method_missing method, *args
-      return unless @keys.respond_to? method
+      return unless respond_to_missing?(method)
+
       @keys.send method, *args
     end
 
@@ -101,6 +108,7 @@ class Card
     def absolutize_subcard_name name
       name = Card::Name[name]
       return name if @context_card.name.parts.first.blank?
+
       name.absolute_name @context_card.name
     end
   end

data/lib/card/subcards/add.rb

@@ -97,9 +97,7 @@ class Card
 
       # ensure a leading '+'
       def normalize_subfield_key key
-        if key.is_a?(Symbol) && Card::Codename.exist?(key)
-          key = Card::Codename.name(key)
-        end
+        key = Card::Codename.name(key) if key.is_a?(Symbol) && Card::Codename.exist?(key)
         key.to_name.prepend_joint
       end
 

data/lib/card/subcards/remove.rb

@@ -11,6 +11,7 @@ class Card
       def remove name_or_card
         key = subcard_key name_or_card
         return unless @keys.include? key
+
         @keys.delete key
         clear_key key
       end
@@ -32,6 +33,7 @@ class Card
       def deep_clear cleared=::Set.new
         each_card do |card|
           next if cleared.include? card.id
+
           cleared << card.id
           card.subcards.deep_clear cleared
         end

data/lib/card/tasks/card.rake

@@ -47,6 +47,7 @@ namespace :card do
     _task, name, url = ARGV
     raise "no name given" unless name.present?
     raise "no url given" unless url.present?
+
     importer.add_remote name, url
     exit
   end
@@ -54,6 +55,7 @@ namespace :card do
   def pull_card opts={}
     _task, card = ARGV
     raise "no card given" unless card.present?
+
     importer.pull card, opts.merge(remote: ENV["from"])
     exit # without exit the card argument is treated as second rake task
   end

data/lib/card/tasks/card/create.rake

@@ -58,6 +58,7 @@ namespace :card do
     def with_params *keys
       optional_params = keys.last.is_a?(Hash) ? keys.pop : {}
       return unless params_present?(*keys)
+
       values = keys.map { |k| ENV[k.to_s] }
       optional_params.each_pair do |k, v|
         values << (ENV[k.to_s] || v)
@@ -66,7 +67,7 @@ namespace :card do
     end
 
     def params_present? *env_keys
-      missing = env_keys.select { |k| !ENV[k.to_s] }
+      missing = env_keys.reject { |k| ENV[k.to_s] }
       missing.each do |key|
         color_puts "missing parameter:", :red, key
       end

data/lib/card/tasks/card/file_card_creator.rb

@@ -15,8 +15,8 @@ class Card
 
       @creator = card_class.new mod, name, type, codename: codename, force: force
     end
-    def self.card_class type
 
+    def self.card_class type
       CARD_CLASSES.find { |cc| cc.valid_type? type }
     end
 

data/lib/card/tasks/card/file_card_creator/abstract_file_card/migration_file.rb

@@ -9,6 +9,7 @@ class Card
           puts "creating migration file...".yellow
           migration_out = `#{migrate_command}`
           return if migration_out.include?("conflict")
+
           migration_file_name = migration_out[/db.*/]
           write_at migration_file_name, 5, indented_migration_content # 5 is line no.
         end

data/lib/card/tasks/card/migrate.rake

@@ -1,4 +1,3 @@
-
 def run_card_migration core_or_deck
   prepare_migration
   verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
@@ -36,7 +35,7 @@ end
 namespace :card do
   namespace :migrate do
     desc "migrate cards"
-    task cards: [:core_cards, :deck_cards]
+    task cards: %i[core_cards deck_cards]
 
     desc "migrate structure"
     task structure: :environment do
@@ -85,6 +84,7 @@ namespace :card do
       version = ENV["VERSION"] ? ENV["VERSION"].to_i : nil
       verbose = ENV["VERBOSE"] ? ENV["VERBOSE"] == "true" : true
       raise "VERSION is required" unless version
+
       ActiveRecord::Migration.verbose = verbose
       ActiveRecord::SchemaMigration.where(version: version.to_s).delete_all
       Cardio.migrate :deck_cards, version
@@ -100,7 +100,7 @@ namespace :card do
 
       Cardio.schema_mode args[:type] do
         version = ActiveRecord::Migrator.current_version
-        if version.to_i > 0 && (file = open(stamp_file, "w"))
+        if version.to_i > 0 && (file = ::File.open(stamp_file, "w"))
           puts ">>  writing version: #{version} to #{stamp_file}"
           file.puts version
         end

data/lib/card/version.rb

@@ -1,9 +1,11 @@
 # -*- encoding : utf-8 -*-
 
-module Card::Version
-  class << self
-    def release
-      @@version ||= File.read(File.expand_path "../../../VERSION", __FILE__).strip
+class Card
+  module Version
+    class << self
+      def release
+      @@version ||= File.read(File.expand_path("../../VERSION", __dir__)).strip
+    end
     end
   end
 end

data/lib/card/view.rb

@@ -2,6 +2,7 @@ require_dependency "card/view/visibility"
 require_dependency "card/view/cache"
 require_dependency "card/view/stub"
 require_dependency "card/view/options"
+require_dependency "card/view/classy"
 
 class Card
   class View
@@ -11,6 +12,9 @@ class Card
     include Cache
     include Stub
     include Options
+    include Layout
+    include Wrapper
+    include Classy
     extend Cache::ClassMethods
 
     attr_reader :format, :parent, :card
@@ -39,6 +43,7 @@ class Card
     def process
       process_live_options
       return if optional? && hide?(requested_view)
+
       fetch { yield ok_view }
     end
 
@@ -67,6 +72,10 @@ class Card
       !parent
     end
 
+    def deep_root
+      format.root.voo
+    end
+
     # neither view nor format has a parent
     # @return [true/false]
     def deep_root?
@@ -75,8 +84,12 @@ class Card
 
     # next voo object found tracing ancestry through parent voos and/or parent formats
     # @return [Card::View]
-    def next_ancestor
-      parent || (format.parent && format.parent.voo)
+    def next_ancestor accross_format=true
+      parent || (accross_format && next_format_ancestor) || nil
+    end
+
+    def next_format_ancestor
+      format.parent&.voo
     end
   end
 end

data/lib/card/view/cache.rb

@@ -20,9 +20,11 @@ class Card
 
       # Fetch view via cache and, when appropriate, render its stubs
       #
-      # If this is a free cache action (see CacheAction), we go through the stubs and render them now.
-      # If the cache is active (ie, we are inside another view), we do not worry about stubs but keep going,
-      # because the free cache we're inside will take care of those stubs.
+      # If this is a free cache action (see CacheAction), we go through the stubs and
+      # render them now.
+      # If the cache is active (ie, we are inside another view), we do not worry about
+      # stubs but keep going, because the free cache we're inside will take care of
+      # those stubs.
       #
       # @return [String (usually)] rendered view
       def cache_render
@@ -32,7 +34,8 @@ class Card
 
       # Is there already a view cache in progress on which this one depends?
       #
-      # Note that if you create a brand new independent format object (ie, not a subformat)
+      # Note that if you create a brand new independent format object
+      # (ie, not a subformat)
       # its activity will be treated as unrelated to this caching/rendering.
       #
       # @return [true/false]
@@ -56,11 +59,9 @@ class Card
         self.class.caching(self) { yield }
       end
 
-
-      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       # VIEW CACHE KEY
 
-
       def cache_key
         @cache_key ||= [
           card.key, format.class, format.nest_mode, options_for_cache_key
@@ -96,15 +97,14 @@ class Card
 
       def option_value_to_string value
         case value
-          when Hash then "{#{hash_for_cache_key value}}"
-          when Array then array_for_cache_key(value)
-          else value.to_s
+        when Hash then "{#{hash_for_cache_key value}}"
+        when Array then array_for_cache_key(value)
+        else value.to_s
         end
       end
 
-      #~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       # cache-related Card::View class methods
-
       module ClassMethods
         def cache
           Card::Cache[Card::View]

data/lib/card/view/cache_action.rb

@@ -13,9 +13,8 @@ class Card
 
       def log_cache_action
         action = yield
-        if false # TODO: make configurable
-          puts "VIEW CACHE [#{action}] (#{card.name}##{requested_view})"
-        end
+        # TODO: make configurable
+        puts "VIEW CACHE [#{action}] (#{card.name}##{requested_view})" if false
         action
       end
 
@@ -28,8 +27,7 @@ class Card
         end
       end
 
-
-      # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       # CACHE STATUS: OFF
       # view caching is turned off, format- or system-wide
 
@@ -43,8 +41,7 @@ class Card
         :yield
       end
 
-
-      # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       # CACHE STATUS: FREE
       # caching is on; no other cache in progress
 
@@ -58,7 +55,7 @@ class Card
         cache_setting != :never && clean_enough_to_cache?
       end
 
-      # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       # CACHE STATUS: ACTIVE
       # another view cache is in progress; this view is inside it
 
@@ -71,6 +68,7 @@ class Card
       def active_cache_ok?
         return false unless parent && clean_enough_to_cache?
         return true if normalized_options[:skip_perms]
+
         active_cache_permissible?
       end
 
@@ -91,7 +89,8 @@ class Card
         @permission_task ||= Card::Format.perms[requested_view] || :read
       end
 
-      # determine the cache action from the cache setting (assuming cache status is "active")
+      # determine the cache action from the cache setting
+      # (assuming cache status is "active")
       # @return [Symbol] cache action
       def active_cache_action_from_setting
         level = ACTIVE_CACHE_LEVEL[cache_setting]
@@ -99,12 +98,12 @@ class Card
       end
 
       ACTIVE_CACHE_LEVEL = {
-        always:   :cache_yield, # read/write cache specifically for this view
+        always: :cache_yield, # read/write cache specifically for this view
         standard: :yield,       # render view; it will only be cached within active view
-        never:    :stub         # render a stub
+        never: :stub         # render a stub
       }.freeze
 
-      # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       # SHARED METHODS
 
       # Mod developers can configure cache directives on view definitions.  eg:
@@ -127,7 +126,6 @@ class Card
         format.view_cache_setting requested_view
       end
 
-
       # altered view requests and altered cards are not cacheable
       # @return [True/False]
       def clean_enough_to_cache?
@@ -137,7 +135,6 @@ class Card
         # FIXME: might consider other changes as disqualifying, though
         # we should make sure not to disallow caching of virtual cards
       end
-
     end
   end
 end

data/lib/card/view/classy.rb

@@ -0,0 +1,168 @@
+class Card
+  class View
+    # API to change css classes in other places
+    module Classy
+      # Add additional css classes to a css class
+      #
+      # Example
+      #   class_up "card-slot", "card-dark text-muted"
+      #
+      #   If a view later adds the css "card-slot" to a html tag with
+      #
+      #     classy("card-slot")
+      #
+      #   then all additional css classes will be added.
+      #
+      # The scope when these additional classes apply can be restricted
+      # @param klass [String, Symbol] the css class to be enriched with additional classes
+      # @param classier [String, Array<String>] additional css classes
+      # @param scope [Symbol]
+      #    :view        only in the same view
+      #    :subviews    the same and all subviews; not in nests or where its nested
+      #    :format      all views, sub and parent views; not in nests or where its nested
+      #    :nests       the same as :format but also in nests
+      #    :single_use  the same as :nests but is removed after the first use
+      #    :global      always everywhere
+      def class_up klass, classier, scope=:subviews
+        klass = klass.to_s
+
+        storage_voo(scope).add_extra_classes klass, classier, scope
+      end
+
+      def class_down klass, classier
+        remove_extra_classes klass, classier, :private
+      end
+
+      def with_class_up klass, classier, scope=:subviews
+        class_up klass, classier, scope
+        yield
+      ensure
+        class_down klass, classier
+      end
+
+      # don't use in the given block the additional class that
+      # was added to `klass`
+      def without_upped_class klass
+        tmp_class = class_list.delete klass
+        result = yield tmp_class
+        class_list[klass] = tmp_class
+        result
+      end
+
+      def classy *classes
+        classes = Array.wrap(classes).flatten
+        [classes, extra_classes(classes)].flatten.compact.join " "
+      end
+
+      def add_extra_classes key, classier, scope
+        type = class_list_type scope
+
+        class_list(type)[key] =
+          [class_list(type)[key], classier].flatten.compact.join(" ")
+      end
+
+      # remove classes everywhere where they are visible for the given scope
+      def remove_extra_classes klass, classier, type
+        # TODO: scope handling
+        # Method is not used and maybe no longer necessary with the scope feature
+        # for class_up.
+
+        # It's no longer sufficient to remove only public classes for ancestors.
+        # Needs an approach similar to extra_classes with the "space" argument
+        next_ancestor&.remove_extra_classes klass, classier, :public
+
+        cl = class_list type
+        return unless cl[klass]
+
+        if cl[klass] == classier
+          cl.delete klass
+        else
+          cl[klass].gsub!(/#{classier}\s?/, "")
+        end
+      end
+
+      def extra_classes klass
+        klass = klass.first if klass.is_a?(Array)
+        klass = klass.to_s
+
+        deep_extra_classes klass, :self
+      end
+
+      # recurse through voos and formats to find all extra classes
+      # @param space [:self, :self_format, :ancestor_format]
+      def deep_extra_classes klass, space
+        [self_extra_classes(klass, space),
+         ancestor_extra_classes(klass, space)].flatten.compact
+      end
+
+      private
+
+      def storage_voo scope
+        # When we climb up the voo tree and cross a nest boundary then we can jump only
+        # to the root voo of the parent format. Hence we have to add classes to the root
+        # if we want them to be found by nests.
+        case scope
+        when :view, :subviews             then self
+        when :format, :nests, :single_use then root
+        when :global                      then deep_root
+        else
+          raise ArgumentError, "invalid class_up scope: #{scope}"
+        end
+      end
+
+      def self_extra_classes klass, space
+        classes = ok_types(space).map { |ot| class_list(ot)[klass] }
+        return classes unless class_list(:single_use)&.key? klass
+
+        [classes, class_list(:single_use).delete(klass)]
+      end
+
+      def ancestor_extra_classes klass, space
+        if parent
+          parent_space = space == :self ? :self_format : :ancestor_format
+          parent.deep_extra_classes(klass, parent_space)
+        else
+          next_format_ancestor&.deep_extra_classes(klass, :ancestor_format)
+        end
+      end
+
+      def ok_types space
+        case space
+        when :ancestor_format then [:public]
+        when :self_format     then %i[public format_private]
+        when :self            then %i[public format_private private]
+        end
+      end
+
+      def class_list type=:private
+        case type
+        when :private, :format_private, :public, :single_use
+          @class_list ||= {}
+          @class_list[type] ||= {}
+        else
+          raise ArgumentError, "#{type} not a valid class list"
+        end
+      end
+
+      # Translates scopes to the privacy types used to manage the class lists.
+      # A #classy calls looks in the following class_lists:
+      #    private - only in the same voo
+      #    format_private - the same voo and all parent voos in the same format
+      #    public - in all voos in all parent formats
+      def class_list_type scope
+        case scope
+        when :view
+          :private
+        when :format, :subviews
+          :format_private
+        when :nests, :global
+          :public
+        when :single_use
+          :single_use
+        else
+          raise ArgumentError, "invalid class_up scope: #{scope}"
+        end
+      end
+    end
+  end
+end