card 1.101.2 → 1.102.0

data/lib/card/set/pattern/class_methods.rb

@@ -0,0 +1,75 @@
+class Card
+  module Set
+    class Pattern
+      # methods for Set::Pattern classes
+      module ClassMethods
+        attr_accessor :pattern_code, :pattern_id, :junction_only,
+                      :assigns_type, :anchorless
+        attr_writer :anchor_parts_count
+
+        def new card
+          super if pattern_applies? card
+        end
+
+        def register pattern_code, opts={}
+          if (self.pattern_id = Card::Codename.id(pattern_code))
+            self.pattern_code = pattern_code
+            Card.set_patterns.insert opts.delete(:index).to_i, self
+            self.anchorless = !respond_to?(:anchor_name)
+            opts.each { |key, val| send "#{key}=", val }
+          else
+            warn "no codename for pattern_code #{pattern_code}"
+          end
+        end
+
+        def junction_only?
+          junction_only == true
+        end
+
+        def anchorless?
+          anchorless
+        end
+
+        def pattern
+          Card.fetch(pattern_id, skip_modules: true).name
+        end
+
+        def pattern_applies? card
+          junction_only? ? card.name.compound? : true
+        end
+
+        def anchor_parts_count
+          @anchor_parts_count ||= (anchorless? ? 0 : 1)
+        end
+
+        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
+
+        # label for set pattern if no anchor is given
+        def generic_label
+          label nil
+        end
+
+        private
+
+        def left_type card
+          card.superleft&.type_name || quick_type(card.name.left_name)
+        end
+
+        def quick_type name
+          if name.present?
+            card = Card.fetch name, skip_modules: true, new: {}
+            card.include_set_modules if card.new? && name.to_name.compound?
+            card&.type_name
+          else
+            "RichText"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/card/set/registrar.rb

@@ -0,0 +1,83 @@
+# -*- encoding : utf-8 -*-
+
+class Card
+  module Set
+    # the set loading process has two main phases:
+
+    #  1. Definition: interpret each set file, creating/defining set and
+    #     set_format modules
+    #  2. Organization: have base classes include modules associated with the
+    #     'all' set, and clean up the other modules
+    module Registrar
+      # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      # Definition Phase
+
+      # each set file calls `extend Card::Set` when loaded
+      def extended mod
+        register_set mod
+      end
+
+      # make the set available for use
+      def register_set set_module
+        if set_module.all_set?
+          # automatically included in Card class
+          modules[:base] << set_module
+        else
+          set_type = set_module.abstract_set? ? :abstract : :nonbase
+          register_set_of_type set_module, set_type
+        end
+      end
+
+      #
+      #  When a Card application loads, it uses set modules to autogenerate
+      #  tmp files that add module names (Card::Set::PATTERN::ANCHOR) and
+      #  extend the module with Card::Set.
+
+      # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+      # Organization Phase
+
+      # 'base modules' are modules that are always included on the Card or
+      # Format class
+      # 'nonbase modules' are included dynamically on singleton_classes
+      def process_base_modules
+        base_modules = modules[:base]
+        return unless base_modules.present?
+
+        Card.add_set_modules base_modules
+        process_base_format_modules modules[:base_format]
+        base_modules.clear
+      end
+
+      def clean_empty_modules
+        clean_empty_module_from_hash modules[:nonbase]
+        modules[:nonbase_format].each_value do |hash|
+          clean_empty_module_from_hash hash
+        end
+      end
+
+      def clean_empty_module_from_hash hash
+        hash.each do |mod_name, modlist|
+          modlist.delete_if { |x| x.instance_methods.empty? }
+          hash.delete mod_name if modlist.empty?
+        end
+      end
+
+      private
+
+      # makes sets ready for dynamic loading via #include_set_modules
+      def register_set_of_type set_module, set_type
+        mods = modules[set_type]
+        key = set_module.shortname
+        mods[key] ||= []
+        mods[key] << set_module
+      end
+
+      def process_base_format_modules base_format_modules
+        base_format_modules.each do |format_class, modules_list|
+          format_class.add_set_modules modules_list
+        end
+        base_format_modules.clear
+      end
+    end
+  end
+end

data/lib/card/set/required_field.rb

@@ -29,6 +29,7 @@ class Card
 
       def define_field_test
         return unless (test = event_test)
+
         method_name = field_test_name
         field_set.class_exec do
           define_method method_name do
@@ -39,13 +40,15 @@ class Card
 
       def field_test_name
         return unless event_test
+
         "_when_left_#{event_test}".to_sym
       end
 
       def event_test
         return @event_test unless @event_test.nil?
+
         test = options[:when]
-        @event_test = test&.is_a?(Symbol) ? test : false
+        @event_test = test.is_a?(Symbol) ? test : false
       end
 
       def field_set

data/lib/card/setting.rb

@@ -9,6 +9,7 @@ class Card
     #     O = Card['*create']         (object)
     # accessible in E
     attr_accessor :codename
+
     # accessible in E and M
     mattr_accessor :groups, :preferences
 
@@ -78,6 +79,7 @@ class Card
 
     def applies_to_prototype? prototype
       return true unless applies
+
       applies.call(prototype)
     end
 
@@ -114,6 +116,7 @@ class Card
 
     def permitted_type_ids types
       return unless types
+
       type_ids = Array.wrap(types).flatten.map do |cardtype|
         Card::Codename.id cardtype
       end

data/lib/card/subcards.rb

@@ -16,6 +16,7 @@ class Card
     include Relate
 
     attr_accessor :context_card, :keys
+
     def initialize context_card
       @context_card = context_card
       @keys = ::Set.new
@@ -73,10 +74,8 @@ class Card
       end.compact
     end
 
-    def each_card
-      cards.each do |card|
-        yield card
-      end
+    def each_card &block
+      cards.each(&block)
     end
 
     alias_method :each, :each_card

data/lib/card/subcards/all.rb

@@ -0,0 +1,103 @@
+class Card
+  class Subcards
+    # subcard-related Card instance methods
+    module All
+      def subcard card_name
+        subcards.card card_name
+      end
+
+      def subfield field_name
+        subcards.field field_name
+      end
+
+      def field? tag
+        field(tag) || subfield(tag)
+      end
+
+      def subcards
+        @subcards ||= Card::Subcards.new self
+      end
+
+      def subcards?
+        subcards.present?
+      end
+
+      def expire_subcards
+        subcards.clear
+      end
+
+      # phase_method :attach_subcard, before: :store do |name_or_card, args=nil|
+      # TODO: handle differently in different stages
+      def add_subcard name_or_card, args={}
+        subcards.add name_or_card, args
+      end
+      alias_method :attach_subcard, :add_subcard
+
+      def add_subcard! name_or_card, args={}
+        subcard = subcards.add name_or_card, args
+        subcard.director.reset_stage
+        subcard
+      end
+      alias_method :attach_subcard!, :add_subcard!
+
+      # phase_method :attach_subfield, before: :approve do |name_or_card, args=nil|
+      def attach_subfield name_or_card, args={}
+        subcards.add_field name_or_card, args
+      end
+      alias_method :add_subfield, :attach_subfield
+
+      def attach_subfield! name_or_card, args={}
+        subcard = subcards.add_field name_or_card, args
+        subcard.director.reset_stage
+        subcard
+      end
+
+      def detach_subcard name_or_card
+        subcards.remove name_or_card
+      end
+      alias_method :remove_subcard, :detach_subcard
+
+      def detach_subfield name_or_card
+        subcards.remove_field name_or_card
+      end
+      alias_method :remove_subfield, :detach_subfield
+
+      def clear_subcards
+        subcards.clear
+      end
+
+      # ensures subfield is present
+      # does NOT override subfield content if already present
+      def ensure_subfield field_name, args={}
+        if subfield_present? field_name
+          subfield field_name
+        else
+          add_subfield field_name, args
+        end
+      end
+
+      def subfield_present? field_name
+        subfield(field_name)&.content&.present?
+      end
+
+      def deep_clear_subcards
+        subcards.deep_clear
+      end
+
+      def handle_subcard_errors
+        subcards.each do |subcard|
+          subcard.errors.each do |error|
+            subcard_error subcard, error
+          end
+          subcard.errors.clear
+        end
+      end
+
+      def subcard_error subcard, error
+        msg = error.message
+        msg = "#{error.attribute} #{msg}" unless %i[content abort].member? error.attribute
+        errors.add subcard.name.from(name), msg
+      end
+    end
+  end
+end

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

@@ -18,7 +18,7 @@ class Card
         end
 
         def ruby_file_name
-          @codename + ".rb"
+          "#{@codename}.rb"
         end
 
         def ruby_file_content

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

@@ -2,15 +2,13 @@ class Card
   class FileCardCreator
     # Helper methods to write to files and the console.
     module OutputHelper
-      def write_to_mod rel_dir, filename
+      def write_to_mod rel_dir, filename, &block
         dir = File.join "mod", @mod, rel_dir
         FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
 
         path = File.join dir, filename
         log_file_action path do
-          File.open(path, "w") do |opened_file|
-            yield(opened_file)
-          end
+          File.open(path, "w", &block)
         end
       end
 

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

@@ -20,11 +20,11 @@ end
 def reset_column_information mod=false
   Rails.application.eager_load!
   load_mod_lib if mod
-  ApplicationRecord.descendants.each(&:reset_column_information)
+  Cardio::Record.descendants.each(&:reset_column_information)
 end
 
 def load_mod_lib
-  Dir.glob(Cardio.root.join("mod/*/lib/*.rb")).each { |x| require x }
+  Dir.glob(Cardio.root.join("mod/*/lib/*.rb")).sort.each { |x| require x }
 end
 
 def without_dumping
@@ -100,7 +100,7 @@ namespace :card do
 
       Cardio.schema_mode args[:type] do
         version = ActiveRecord::Migrator.current_version
-        if version.to_i > 0 && (file = ::File.open(stamp_file, "w"))
+        if version.to_i.positive? && (file = ::File.open(stamp_file, "w"))
           puts ">>  writing version: #{version} to #{stamp_file}"
           file.puts version
         end

data/lib/card/view/cache.rb

@@ -194,8 +194,8 @@ class Card
       # those stubs.
       #
       # @return [String (usually)] rendered view
-      def cache_render
-        cached_view = cache_fetch { yield }
+      def cache_render &block
+        cached_view = cache_fetch(&block)
         cache_active? ? cached_view : format.stub_render(cached_view)
       end
 
@@ -212,18 +212,16 @@ class Card
 
       # If view is cached, retrieve it.  Otherwise render and store it.
       # Uses the primary cache API.
-      def cache_fetch
+      def cache_fetch &block
         caching do
           ensure_cache_key
-          self.class.cache.fetch cache_key do
-            yield
-          end
+          self.class.cache.fetch cache_key, &block
         end
       end
 
       # keep track of nested cache fetching
-      def caching
-        self.class.caching(self) { yield }
+      def caching &block
+        self.class.caching(self, &block)
       end
 
       # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

data/lib/card/view/cache/cache_action.rb

@@ -14,12 +14,11 @@ class Card
         end
 
         def log_cache_action
-          action = yield
+          yield
           # TODO: make configurable
           # ...or better yet, integrate into performance logger...
           # Rails.logger.warn "VIEW CACHE #{cache_active? ? '-->' : ''}[#{action}] "\
           #                   "(#{card.name}##{requested_view})"
-          action
         end
 
         # @return [Symbol] :off, :active, or :free

data/lib/card/view/cache/stub.rb

@@ -17,7 +17,7 @@ class Card
         end
 
         def bin_to_hex string
-          string.unpack("H*").first
+          string.unpack1("H*")
         end
 
         # @return [Hash]