card 1.101.5 → 1.103.0

data/lib/cardio/mod/load_strategy.rb

@@ -1,79 +1,40 @@
 module Cardio
-  module Mod
+  class Mod
     # Shared code for the three different load strategies: Eval, TmpFiles and BindingMagic
     class LoadStrategy
       class << self
         attr_accessor :tmp_files, :current
 
-        def klass symbol
-          case symbol
-          when :tmp_files     then TmpFiles
-          when :binding_magic then BindingMagic
+        def class_for_set strategy
+          case strategy
+          when :tmp_files     then SetTmpFiles
+          when :binding_magic then SetBindingMagic
           else                     Eval
           end
         end
 
+        def class_for_set_pattern strategy
+          return PatternTmpFiles if strategy == :tmp_files
+
+          Eval
+        end
+
         def tmp_files?
           Cardio.config.load_strategy == :tmp_files
         end
       end
 
-      def initialize mod_dirs, loader
+      attr_reader :loader
+      delegate :template_class, :each_file, :mod_dirs, :parts_from_path, to: :loader
+
+      def initialize loader
         LoadStrategy.current = self.class
-        @mod_dirs = mod_dirs
         @loader = loader
       end
 
       def clean_comments?
         false
       end
-
-      private
-
-      def module_type
-        @loader.class.module_type
-      end
-
-      def module_template
-        @loader.class.module_class_template
-      end
-
-      def each_file &block
-        if module_type == :set
-          each_set_file(&block)
-        else
-          each_mod_dir module_type do |base_dir|
-            each_file_in_dir base_dir, &block
-          end
-        end
-      end
-
-      def each_set_file &block
-        each_mod_dir :set do |base_dir|
-          @loader.patterns.each do |pattern|
-            each_file_in_dir base_dir, pattern.to_s, &block
-          end
-        end
-      end
-
-      def each_mod_dir module_type, &block
-        @mod_dirs.each module_type, &block
-      end
-
-      def each_file_in_dir base_dir, subdir=nil
-        pattern = File.join(*[base_dir, subdir, "**/*.rb"].compact)
-        Dir.glob(pattern).sort.each do |abs_path|
-          rel_path = abs_path.sub("#{base_dir}/", "")
-          const_parts = parts_from_path rel_path
-          yield abs_path, const_parts
-        end
-      end
-
-      def parts_from_path path
-        # remove file extension and number prefixes
-        parts = path.gsub(/\.rb/, "").gsub(%r{(?<=\A|/)\d+_}, "").split(File::SEPARATOR)
-        parts.map(&:camelize)
-      end
     end
   end
 end

data/lib/cardio/mod/load_strategy/eval.rb

@@ -1,13 +1,12 @@
 module Cardio
-  module Mod
+  class Mod
     class LoadStrategy
       # Put everything for the module definition in one string and the evaluate
       # it immediately with ruby's eval method.
       class Eval < LoadStrategy
         def load_modules
           each_file do |abs_path, module_names|
-            template = module_template.new module_names, abs_path, self
-            template.build
+            template_class.new(module_names, abs_path, self).build
           end
         end
       end

data/lib/cardio/mod/load_strategy/pattern_tmp_files.rb

@@ -1,5 +1,5 @@
 module Cardio
-  module Mod
+  class Mod
     class LoadStrategy
       # The {TmpFiles} load strategy version for set pattern modules/
       class PatternTmpFiles < TmpFiles

data/lib/cardio/mod/load_strategy/set_binding_magic.rb

@@ -1,5 +1,5 @@
 module Cardio
-  module Mod
+  class Mod
     # Tries to build the module with as little string evaluation as possible.
     # The problem here is that in methods like `module_eval` the Module.nesting
     # list gets lost so all references in mod files to constants in the

data/lib/cardio/mod/load_strategy/set_tmp_files.rb

@@ -1,5 +1,5 @@
 module Cardio
-  module Mod
+  class Mod
     class LoadStrategy
       # The {TmpFiles} load strategy version for set modules
       class SetTmpFiles < LoadStrategy::TmpFiles
@@ -8,7 +8,7 @@ module Cardio
         def generate_tmp_files
           return unless prepare_tmp_dir "tmp/set"
 
-          @mod_dirs.each_with_tmp(:set) do |mod_dir, mod_tmp_dir|
+          mod_dirs.each_with_tmp(:set) do |mod_dir, mod_tmp_dir|
             Dir.mkdir mod_tmp_dir
             Dir.glob("#{mod_dir}/**/*.rb").each do |abs_path|
               rel_path = abs_path.sub "#{mod_dir}/", ""
@@ -21,8 +21,8 @@ module Cardio
         end
 
         def load_tmp_files
-          @mod_dirs.each_tmp(:set) do |set_tmp_dir|
-            Card::Set::Pattern.loadable_codes.each do |pattern|
+          mod_dirs.each_tmp(:set) do |set_tmp_dir|
+            Card::Set::Pattern.codes.each do |pattern|
               pattern_dir = "#{set_tmp_dir}/#{pattern}"
               Loader.load_dir "#{pattern_dir}/**" if Dir.exist? pattern_dir
             end

data/lib/cardio/mod/load_strategy/tmp_files.rb

@@ -1,5 +1,5 @@
 module Cardio
-  module Mod
+  class Mod
     class LoadStrategy
       # LoadStrategy for mod modules. It writes the code to tmp files
       # and then loads the tmp files. (deprecated)
@@ -24,17 +24,14 @@ module Cardio
         end
 
         def rewrite_tmp_files?
-          if defined?(@rewrite)
-            @rewrite
-          else
-            @rewrite = !(Rails.env.production? &&
-              Card.paths["tmp/set"].existent.first)
-          end
+          return @rewrite if defined? @rewrite
+
+          @rewrite = !(Rails.env.production? && Card.paths["tmp/set"].existent.first)
         end
 
         def write_tmp_file from_file, to_file, const_parts
           FileUtils.mkdir_p File.dirname(to_file)
-          mt = module_template.new const_parts, from_file, self
+          mt = template_class.new const_parts, from_file, self
           File.write to_file, mt.to_s
         end
       end

data/lib/cardio/mod/loader.rb

@@ -1,7 +1,7 @@
 # -*- encoding : utf-8 -*-
 
 module Cardio
-  module Mod
+  class Mod
     # Cardio::Mod::Loader is used to load all part of a mod,
     # i.e. initializers, patterns, formats, chunks, layouts and sets
     # cards are not accessible at this point
@@ -12,28 +12,7 @@ module Cardio
     # The mods are given by a Mod::Dirs object.
     # SetLoader can use three different strategies to load the set modules.
     class Loader
-      def initialize load_strategy: nil, mod_dirs: nil
-        load_strategy ||= Cardio.config.load_strategy
-        mod_dirs ||= Mod.dirs
-        klass = load_strategy_class load_strategy
-        @load_strategy = klass.new mod_dirs, self
-      end
-
-      def load_strategy_class load_strategy
-        case load_strategy
-        when :tmp_files     then LoadStrategy::TmpFiles
-        when :binding_magic then LoadStrategy::BindingMagic
-        else                     LoadStrategy::Eval
-        end
-      end
-
-      def load
-        @load_strategy.load_modules
-      end
-
       class << self
-        attr_reader :module_type
-
         def load_mods
           SetPatternLoader.new.load
           SetLoader.new.load
@@ -45,19 +24,12 @@ module Cardio
           Card::Set::Pattern.reset
           Card::Set.reset_modules
           SetPatternLoader.new.load
-          SetLoader.new(patterns: Card::Set::Pattern.nonbase_loadable_codes).load
+          SetLoader.new(no_all: true).load
         end
 
-        def module_class_template
-          const_get :Template
-        end
-
-        # private
-
         def load_initializers
-          Cardio.config
-                .paths["mod/config/initializers"].existent.sort.each do |initializer|
-            load initializer
+          Cardio.config.paths["late/initializers"].existent.sort.each do |init|
+            load init
           end
         end
 
@@ -73,6 +45,39 @@ module Cardio
           end
         end
       end
+
+      attr_reader :mod_dirs
+
+      def initialize load_strategy: nil, mod_dirs: nil
+        load_strategy ||= Cardio.config.load_strategy
+        @mod_dirs = mod_dirs || Mod.dirs
+        @load_strategy = load_strategy_class(load_strategy).new self
+      end
+
+      def load
+        @load_strategy.load_modules
+      end
+
+      def parts_from_path path
+        # remove file extension and number prefixes
+        parts = path.gsub(/\.rb/, "").gsub(%r{(?<=\A|/)\d+_}, "").split(File::SEPARATOR)
+        parts.map(&:camelize)
+      end
+
+      private
+
+      def each_mod_dir module_type, &block
+        @mod_dirs.each module_type, &block
+      end
+
+      def each_file_in_dir base_dir, subdir=nil
+        pattern = File.join(*[base_dir, subdir, "**/*.rb"].compact)
+        Dir.glob(pattern).sort.each do |abs_path|
+          rel_path = abs_path.sub("#{base_dir}/", "")
+          const_parts = parts_from_path rel_path
+          yield abs_path, const_parts
+        end
+      end
     end
   end
 end

data/lib/cardio/mod/loader/set_loader.rb

@@ -1,27 +1,21 @@
 module Cardio
-  module Mod
+  class Mod
     class Loader
       # A SetLoader object loads all set modules for a list of mods.
       # The mods are given by a Mod::Dirs object.
       # SetLoader can use three different strategies to load the set modules.
       class SetLoader < Loader
-        @module_type = :set
-        attr_accessor :patterns
+        def template_class
+          SetTemplate
+        end
 
         def initialize args={}
-          @patterns = args.delete(:patterns) || Card::Set::Pattern.loadable_codes
-          super
+          @no_all = args.delete :no_all
+          super load_strategy: args[:load_strategy], mod_dirs: args[:mod_dirs]
         end
 
-        def load_strategy_class load_strategy
-          case load_strategy
-          when :tmp_files
-            LoadStrategy::SetTmpFiles
-          when :binding_magic
-            LoadStrategy::SetBindingMagic
-          else
-            LoadStrategy::Eval
-          end
+        def load_strategy_class strategy
+          LoadStrategy.class_for_set strategy
         end
 
         def load
@@ -30,129 +24,23 @@ module Cardio
           Card::Set.clean_empty_modules
         end
 
-        class Template < ModuleTemplate
-          def initialize modules, content_path, strategy
-            super
-            @modules.pop if helper_module?
-          end
-
-          def to_const
-            return Object if simple_load?
-
-            @modules.inject(pattern_class) do |const, name_part|
-              const.const_get_or_set name_part do
-                Module.new
-              end
-            end
-          end
-
-          def processed_content
-            add_explicit_format_modules if @strategy.clean_comments?
-            super
-          end
-
-          def add_explicit_format_modules
-            @content.gsub!(/^ *format +:?(\w+)? *do *$/) do
-              format_name = Regexp.last_match(1)
-              format_name = format_name.blank? ? nil : format_name.to_sym
-              "module #{module_name format_name}; " \
-              "module_parent.send :register_set_format, "\
-              "#{format_class format_name}, self; "\
-              "extend Card::Set::AbstractFormat"
-            end
-          end
-
-          def module_name format_name
-            Card::Format.format_class_name format_name
-          end
-
-          def format_class format_name
-            klass = ["Card::Format"]
-            klass << module_name(format_name) if format_name
-            klass.join "::"
-          end
-
-          def helper_module?
-            if @is_helper_module.nil?
-              @is_helper_module = @content =~ /\A#!\s?not? set module/
-            else
-              @is_helper_module
-            end
-          end
-
-          # correct line number for error messages
-          def offset
-            -5
-          end
-
-          private
-
-          def submodule_chain
-            @modules.map { |m| "module #{m};" }
-          end
-
-          def module_chain
-            @module_chain ||=
-              ["class Card", "module Set", "class #{@pattern.camelize}"] + submodule_chain
-          end
-
-          def preamble_bits
-            capture_last_module
-            [module_chain.join("; "),
-             module_comment,
-             @last_module,
-             set_extension,
-             location_method].compact
-          end
-
-          def auto_comment
-            "# Set: #{label_body(*@modules)}\n#"
-          end
-
-          def label_body *anchors
-            if @pattern == "Abstract"
-              "Abstract (#{@modules.join ', '})"
-            else
-              pattern_label(*anchors)
-            end
-          end
+        # does not include abstract
+        def main_patterns
+          method = @no_all ? :nonbase_codes : :codes
+          Card::Set::Pattern.send method
+        end
 
-          def pattern_label *anchors
-            anchor_count = pattern_class.anchor_parts_count
-            label = pattern_class.label(pattern_anchor(*anchors, anchor_count))
-            remainder = anchors[anchor_count..-1]
-            label += " (#{remainder.join ', '})" if remainder.any?
-            label
-          end
+        def each_file &block
+          # each_file_with_patterns :abstract, &block
+          each_file_with_patterns(*main_patterns, &block)
+        end
 
-          def pattern_anchor *anchors, anchor_count
-            if anchor_count.zero?
-              ""
-            else
-              anchors[0..anchor_count].join(Card::Name.joint)
+        def each_file_with_patterns *patterns, &block
+          each_mod_dir :set do |base_dir|
+            patterns.each do |pattern|
+              each_file_in_dir base_dir, pattern.to_s, &block
             end
           end
-
-          def pattern_class
-            @pattern_class ||= Card::Set.const_get_or_set(@pattern.camelize) { Class.new }
-          end
-
-          def capture_last_module
-            module_chain
-            @last_module = @module_chain.pop
-          end
-
-          def set_extension
-            "extend Card::Set" unless helper_module?
-          end
-
-          def location_method
-            %(def self.source_location; "#{@content_path}"; end)
-          end
-
-          def postamble
-            "end;" * (@modules.size + 3)
-          end
         end
       end
     end