card 1.93.6 → 1.93.7

data/lib/card/view/options.rb

@@ -1,8 +1,7 @@
 class Card
   class View
+    # Manages options for card views, including those used in nest syntax
     module Options
-      # 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.
@@ -13,7 +12,6 @@ class Card
       # don't inherit  | carditect     | none
       #
       # (note: each option will likely some day merit its own object)
-
       @keymap = {
         carditect: [
           :view,           # view to render
@@ -48,198 +46,18 @@ class Card
       }
       # 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 Deckers in card nests
-        # @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
-          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
-          define_method option_key do
-            norm_method = "normalize_#{option_key}"
-            value = live_options[option_key]
-            try(norm_method, value) || value
-          end
-        end
-
-        def define_setter option_key
-          define_method "#{option_key}=" do |value|
-            live_options[option_key] = value
-          end
-        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.
-      # @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
-
-
-      # 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
-
-
-      # "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)
-      # FIXME: what we really want is options as they were when render was called.
-      # normalized is wrong because it can get changed before render. live is wrong
-      # because they can get changed after.  current solution is a compromise.
-      # @return [Hash]
-      def slot_options
-        normalized_options.merge(view: requested_view).select do |k, _v|
-          Options.all_keys.include? k
-        end
-      end
-
-      def closest_live_option key
-        if live_options.key? key
-          live_options[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
-      # symbols as keys, managing standard view inheritance, and special
-      # handling for main_views.
-      def normalize_options
-        @normalized_options = opts = options_to_hash @raw_options.clone
-        opts[:view] = @raw_view
-        inherit_from_parent if parent
-        opts[:main] = true if format.main?
-        @optional = opts.delete(:optional) || false
-        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 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}"
+        def add_option name, type
+          raise "invalid option type" unless @keymap.key?(type)
+          @keymap[type] << name
+          reset_key_lists
         end
       end
 
-      # standard inheritance from parent view object
-      def inherit_from_parent
-        Options.heir_keys.each do |key|
-          parent_value = parent.live_options[key]
-          normalized_options[key] ||= parent_value if parent_value
-        end
-      end
-
-      def process_live_options
-        opts = @live_options = normalized_options.clone
-        opts.merge! format.main_nest_options if opts[:main_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
-
-      # This method triggers the default_X_args methods which can alter the
-      # @live_options hash both directly and indirectly (via the voo API)
-      def process_default_options
-        format.view_options_with_defaults requested_view, live_options
-      end
-
-      # "foreign" options are non-standard options.  They're allowed, but they
-      # prevent independent caching (and thus stubbing)
-
-      # non-standard options that are found in normalized_options
-      # @return [Hash] options Hash
-      def foreign_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_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
-
-
+      extend KeyLists
+      include VooApi
     end
   end
 end

data/lib/card/view/options/key_lists.rb

@@ -0,0 +1,41 @@
+class Card
+  class View
+    module Options
+      module KeyLists
+        # 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 Deckers in card nests
+        # @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
+          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)
+          ]
+        end
+
+        def reset_key_lists
+          @all_keys = nil
+          @carditect_keys = nil
+          @heir_keys = nil
+        end
+      end
+    end
+  end
+end

data/lib/card/view/options/voo_api.rb

@@ -0,0 +1,165 @@
+class Card
+  class View
+    module Options
+      # The methods of the VooApi module allow developers
+      # to read and write options dynamically.
+      module VooApi
+        # There are two primary options hashes:
+
+        # - @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
+
+        class << self
+          def included base
+            # Developers can also set most options directly via accessors,
+            # eg voo.title = "King"
+            # :view, :show, and :hide have non-standard access (see #accessible_keys)
+
+            base.accessible_keys.each do |option_key|
+              define_getter option_key unless option_key == :items
+              define_setter option_key
+            end
+          end
+
+          def define_getter option_key
+            define_method option_key do
+              norm_method = "normalize_#{option_key}"
+              value = live_options[option_key]
+              try(norm_method, value) || value
+            end
+          end
+
+          def define_setter option_key
+            define_method "#{option_key}=" do |value|
+              live_options[option_key] = value
+            end
+          end
+        end
+
+        # "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)
+        # FIXME: what we really want is options as they were when render was called.
+        # normalized is wrong because it can get changed before render. live is wrong
+        # because they can get changed after.  current solution is a compromise.
+        # @return [Hash]
+        def slot_options
+          normalized_options.merge(view: requested_view).select do |k, _v|
+            Options.all_keys.include? k
+          end
+        end
+
+        def closest_live_option key
+          if live_options.key? key
+            live_options[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&.to_sym
+        end
+
+        def normalize_cache value
+          value&.to_sym
+        end
+
+        private
+
+        # option normalization includes standardizing options into a hash with
+        # symbols as keys, managing standard view inheritance, and special
+        # handling for main_views.
+        def normalize_options
+          @normalized_options = opts = options_to_hash @raw_options.clone
+          opts[:view] = @raw_view
+          inherit_from_parent if parent
+          opts[:main] = true if format.main?
+          @optional = opts.delete(:optional) || false
+          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 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
+        end
+
+        # standard inheritance from parent view object
+        def inherit_from_parent
+          Options.heir_keys.each do |key|
+            parent_value = parent.live_options[key]
+            normalized_options[key] ||= parent_value if parent_value
+          end
+        end
+
+        def process_live_options
+          @live_options = normalized_options.clone
+          if @live_options[:main_view]
+            @live_options.merge! format.main_nest_options
+          end
+          # main_nest_options are not processed in normalize_options so that
+          # they're NOT locked in the stub.
+          process_default_options
+          process_visibility_options
+          @live_options
+        end
+
+        # This method triggers the default_X_args methods which can alter the
+        # @live_options hash both directly and indirectly (via the voo API)
+        def process_default_options
+          format.view_options_with_defaults requested_view, live_options
+        end
+
+        # "foreign" options are non-standard options.  They're allowed, but they
+        # prevent independent caching (and thus stubbing)
+
+        # non-standard options that are found in normalized_options
+        # @return [Hash] options Hash
+        def foreign_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_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
+end

data/lib/cardio.rb

@@ -5,7 +5,7 @@ djar = "delayed_job_active_record"
 require djar if Gem::Specification.find_all_by_name(djar).any?
 require "cardio/schema.rb"
 
-ActiveSupport.on_load :card do
+ActiveSupport.on_load :after_card do
   if Card.take
     Card::Mod.load
   else
@@ -128,6 +128,7 @@ module Cardio
       add_path "db"
       add_path "db/migrate"
       add_path "db/migrate_core_cards"
+      add_path "db/migrate_deck", root: root, with: "db/migrate"
       add_path "db/migrate_deck_cards", root: root, with: "db/migrate_cards"
       add_path "db/seeds.rb", with: "db/seeds.rb"
     end
@@ -135,6 +136,9 @@ module Cardio
     def add_initializer_paths
       add_path "config/initializers", glob: "**/*.rb"
       add_initializers root
+      each_mod_path do |mod_path|
+        add_initializers mod_path, false, "core_initializers"
+      end
     end
 
     def add_mod_initializer_paths
@@ -144,8 +148,8 @@ module Cardio
       end
     end
 
-    def add_initializers dir, mod=false
-      Dir.glob("#{dir}/config/initializers").each do |initializers_dir|
+    def add_initializers base_dir, mod=false, init_dir="initializers"
+      Dir.glob("#{base_dir}/config/#{init_dir}").each do |initializers_dir|
         path_mark = mod ? "mod/config/initializers" : "config/initializers"
         paths[path_mark] << initializers_dir
       end
@@ -184,14 +188,19 @@ module Cardio
     def migration_paths type
       list = paths["db/migrate#{schema_suffix type}"].to_a
       if type == :deck_cards
-        Card::Mod.dirs.each("db/migrate_cards") do |path|
-          list += Dir.glob path
-        end
+        add_mod_migration_paths list
+      elsif type == :deck
+        add_mod_migration_paths list, "migrate"
       end
-
       list.flatten
     end
 
+    def add_mod_migration_paths list, dir="migrate_cards"
+      Card::Mod.dirs.each("db/#{dir}") do |path|
+        list += Dir.glob path
+      end
+    end
+
     private
 
     def mod_name_from_gem_spec gem_spec