card 1.18.6 → 1.19.0

data/lib/card/set/inheritance.rb

@@ -0,0 +1,57 @@
+class Card
+  module Set
+    # API to inherit other sets and their formats
+    module Inheritance
+      # include a set module and all its format modules
+      # @param [Module] set
+      # @param [Hash] opts choose the formats you want to include
+      # @option opts [Symbol, Array<Symbol>] :only include only these formats
+      # @option opts [Symbol, Array<Symbol>] :except don't include these formats
+      # #@example
+      # include_set Type::Basic, except: :css
+      def include_set set, opts={}
+        set_type = set.abstract_set? ? :abstract : :nonbase
+        add_set_modules Card::Set.modules[set_type][set.shortname]
+        include_set_formats set, opts
+      end
+
+      # include format modules of a set
+      # @param [Module] set
+      # @param [Hash] opts choose the formats you want to include
+      # @option opts [Symbol, Array<Symbol>] :only include only these formats
+      # @option opts [Symbol, Array<Symbol>] :except don't include these formats
+      # #@example
+      # include_set Type::Basic, except: :css
+      def include_set_formats set, opts={}
+        each_format set do |format, format_mods|
+          format_sym = Card::Format.format_sym format
+          next unless applicable_format?(format_sym, opts[:except], opts[:only])
+          format_mods.each do |format_mod|
+            define_on_format format_sym do
+              include format_mod
+            end
+          end
+        end
+      end
+
+      private
+
+      # iterate through each format associated with a set
+      def each_format set
+        set_type = set.abstract_set? ? :abstract : :nonbase
+        format_type = "#{set_type}_format".to_sym
+        modules[format_type].each_pair do |format, set_format_mod_hash|
+          next unless (format_mods = set_format_mod_hash[set.shortname])
+          yield format, format_mods
+        end
+      end
+
+      def applicable_format? format, except, only
+        format_sym = Card::Format.format_sym format
+        return false if except && Array(except).include?(format_sym)
+        return false if only && !Array(only).include?(format_sym)
+        true
+      end
+    end
+  end
+end

data/lib/card/set/loader.rb

@@ -34,28 +34,36 @@ class Card
       #  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.
-      #
 
-      #
       #
       def write_tmp_file from_file, to_file, rel_path
-        name_parts = rel_path.gsub(/\.rb/, '').split(File::SEPARATOR)
-        submodules = name_parts.map { |a| "module #{a.camelize};" } * ' '
-        file_content = <<EOF
-# -*- encoding : utf-8 -*-
-class Card; module Set; #{submodules} extend Card::Set
-# ~~~~~~~~~~~ above autogenerated; below pulled from #{from_file} ~~~~~~~~~~~
-#{File.read from_file}
-
-# ~~~~~~~~~~~ below autogenerated; above pulled from #{from_file} ~~~~~~~~~~~
-end;end;#{'end;' * name_parts.size}
-EOF
-
+        pattern, submodules = pattern_and_modules_from_path rel_path
         FileUtils.mkdir_p File.dirname(to_file)
-        File.write to_file, file_content
+        File.write to_file, tmp_file_template(pattern, submodules, from_file)
         to_file
       end
 
+      def pattern_and_modules_from_path path
+        # remove file extension and number prefixes
+        parts = path.gsub(/\.rb/, "").gsub(%r{(?<=\A|/)\d+_}, "")
+                    .split(File::SEPARATOR)
+        parts.map! &:camelize
+        [parts.shift, parts]
+      end
+
+      def tmp_file_template pattern, modules, content_path
+        submodules = modules.map { |m| "module #{m};" }
+<<-RUBY
+# -*- encoding : utf-8 -*-
+class Card; module Set; class #{pattern}; #{submodules * ' '} extend Card::Set
+# ~~ above autogenerated; below pulled from #{content_path} ~~
+#{File.read content_path}
+
+# ~~ below autogenerated; above pulled from #{content_path} ~~
+end;end;end;#{'end;' * submodules.size}
+RUBY
+      end
+
       # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       # Organization Phase
 
@@ -63,23 +71,15 @@ EOF
       # Format class
       # 'nonbase modules' are included dynamically on singleton_classes
       def process_base_modules
-        process_base_module_list modules[:base], Card
+        return unless modules[:base]
+        Card.add_set_modules modules[:base]
         modules[:base_format].each do |format_class, modules_list|
-          process_base_module_list modules_list, format_class
+          format_class.add_set_modules modules_list
         end
         modules.delete :base
         modules.delete :base_format
       end
 
-      def process_base_module_list list, klass
-        list.each do |mod|
-          klass.send :include, mod if mod.instance_methods.any?
-          if (class_methods = mod.const_get_if_defined(:ClassMethods))
-            klass.send :extend, class_methods
-          end
-        end
-      end
-
       def clean_empty_modules
         clean_empty_module_from_hash modules[:nonbase]
         modules[:nonbase_format].values.each do |hash|

data/lib/card/set_pattern.rb

@@ -1,189 +1,202 @@
 class Card
-  class SetPattern
-    class << self
-      attr_accessor :pattern_code, :pattern_id, :junction_only, :assigns_type,
-                    :anchorless, :anchor_parts_count
-
-      def card_keys
-        @@card_keys ||= Card.set_patterns.inject({}) do |hash, set_pattern|
-          card_key = Card.quick_fetch(set_pattern.pattern_code.to_sym).key
-          hash[card_key] = true
-          hash
+  module Set
+    class Pattern
+      class << self
+        def find pattern_code
+          Card.set_patterns.find { |sub| sub.pattern_code == pattern_code }
         end
-      end
-
-      def find pattern_code
-        Card.set_patterns.find { |sub| sub.pattern_code == pattern_code }
-      end
-
-      def junction_only?
-        !!junction_only
-      end
-
-      def anchorless?
-        !!anchorless
-      end
-
-      def new card
-        super if pattern_applies? card
-      end
 
-      def pattern
-        Card.fetch(pattern_id, skip_modules: true).cardname
-      end
-
-      def register pattern_code, opts={}
-        if (self.pattern_id = Card::Codename[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}"
+        def card_keys
+          @card_keys ||=
+            Card.set_patterns.inject({}) do |hash, set_pattern|
+              card_key = Card.quick_fetch(set_pattern.pattern_code.to_sym).key
+              hash[card_key] = true
+              hash
+            end
         end
-      end
 
-      def pattern_applies? card
-        junction_only? ? card.cardname.junction? : true
-      end
-
-      def anchor_parts_count
-        @anchor_parts_count ||= (anchorless? ? 0 : 1)
-      end
-
-      def write_tmp_file pattern_code, from_file, seq
-        to_file = "#{Card.paths['tmp/set_pattern'].first}/" \
-                  "#{seq}-#{pattern_code}.rb"
-        klass = "Card::#{pattern_code.camelize}Set"
-        file_content = <<EOF
+        def write_tmp_file pattern_code, from_file, seq
+          to_file = "#{Card.paths['tmp/set_pattern'].first}/" \
+                    "#{seq}-#{pattern_code}.rb"
+          klass = "Card::Set::#{pattern_code.camelize}"
+          file_content = <<EOF
 # -*- encoding : utf-8 -*-
-class #{klass} < Card::SetPattern
+class #{klass} < Card::Set::Pattern::Abstract
   cattr_accessor :options
   class << self
-# ~~~~~~~~~~~ above autogenerated; below pulled from #{from_file} ~~~~~~~~~~~
+# ~~ above autogenerated; below pulled from #{from_file} ~~
 
 #{File.read from_file}
 
-# ~~~~~~~~~~~ below autogenerated; above pulled from #{from_file} ~~~~~~~~~~~
+# ~~ below autogenerated; above pulled from #{from_file} ~~
   end
   register "#{pattern_code}", (options || {})
 end
 
 EOF
-        File.write to_file, file_content
-        to_file
+          File.write to_file, file_content
+          to_file
+        end
       end
-    end
 
-    # Instance methods
+      class Abstract
+        class << self
+          attr_accessor :pattern_code, :pattern_id, :junction_only,
+                        :assigns_type, :anchorless, :anchor_parts_count
+
+          def new card
+            super if pattern_applies? card
+          end
+
+          def register pattern_code, opts={}
+            if (self.pattern_id = Card::Codename[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).cardname
+          end
+
+          def pattern_applies? card
+            junction_only? ? card.cardname.junction? : true
+          end
+
+          def anchor_parts_count
+            @anchor_parts_count ||= (anchorless? ? 0 : 1)
+          end
+        end
 
-    def initialize card
-      unless self.class.anchorless?
-        @anchor_name = self.class.anchor_name(card).to_name
-        @anchor_id = if self.class.respond_to? :anchor_id
-                       self.class.anchor_id card
-                     else
-                       Card.fetch_id @anchor_name
-                     end
-      end
-      self
-    end
+        # Instance methods
+
+        def initialize card
+          unless self.class.anchorless?
+            @anchor_name = self.class.anchor_name(card).to_name
+            @anchor_id = if self.class.respond_to? :anchor_id
+                           self.class.anchor_id card
+                         else
+                           Card.fetch_id @anchor_name
+                         end
+          end
+          self
+        end
 
-    def module_key
-      (defined? @module_key) ? @module_key : @module_key = begin
-        if self.class.anchorless?
-          self.class.pattern_code.camelize
-        elsif anchor_codenames
-          codenames = [self.class.pattern_code] + anchor_codenames.map(&:to_s)
-          codenames.map(&:camelize).join '::'
+        def module_key
+          if defined? @module_key
+            @module_key
+          else
+            @module_key = begin
+              if self.class.anchorless?
+                self.class.pattern_code.camelize
+              elsif anchor_codenames
+                codenames = [self.class.pattern_code] +
+                            anchor_codenames.map(&:to_s)
+                codenames.map(&:camelize).join "::"
+              end
+            end
+          end
         end
-      end
-    end
 
-    def lookup_module_list modules_hash
-      module_key && modules_hash[module_key]
-    end
+        def lookup_module_list modules_hash
+          module_key && modules_hash[module_key]
+        end
 
-    def module_list
-      lookup_module_list Card::Set.modules[:nonbase]
-    end
+        def module_list
+          lookup_module_list Card::Set.modules[:nonbase]
+        end
 
-    def format_module_list klass
-      hash = Card::Set.modules[:nonbase_format][klass]
-      hash && lookup_module_list(hash)
-    end
+        def format_module_list klass
+          hash = Card::Set.modules[:nonbase_format][klass]
+          hash && lookup_module_list(hash)
+        end
 
-    def anchor_codenames
-      @anchor_name.parts.map do |part|
-        part_id = Card.fetch_id part
-        part_id && Card::Codename[part_id.to_i] || (return nil)
-      end
-    end
+        def anchor_codenames
+          @anchor_name.parts.map do |part|
+            part_id = Card.fetch_id part
+            part_id && Card::Codename[part_id.to_i] || (return nil)
+          end
+        end
 
-    def pattern
-      @pattern ||= self.class.pattern
-    end
+        def pattern
+          @pattern ||= self.class.pattern
+        end
 
-    def to_s
-      self.class.anchorless? ? pattern.s : "#{@anchor_name}+#{pattern}"
-    end
+        def to_s
+          self.class.anchorless? ? pattern.s : "#{@anchor_name}+#{pattern}"
+        end
 
-    def inspect
-      "<#{self.class} #{to_s.to_name.inspect}>"
-    end
+        def inspect
+          "<#{self.class} #{to_s.to_name.inspect}>"
+        end
 
-    def safe_key
-      caps_part = self.class.pattern_code.tr(' ', '_').upcase
-      if self.class.anchorless?
-        caps_part
-      else
-        "#{caps_part}-#{@anchor_name.safe_key}"
-      end
-    end
+        def safe_key
+          caps_part = self.class.pattern_code.tr(" ", "_").upcase
+          if self.class.anchorless?
+            caps_part
+          else
+            "#{caps_part}-#{@anchor_name.safe_key}"
+          end
+        end
 
-    def rule_set_key
-      if self.class.anchorless?
-        self.class.pattern_code
-      elsif @anchor_id
-        "#{@anchor_id}+#{self.class.pattern_code}"
+        def rule_set_key
+          if self.class.anchorless?
+            self.class.pattern_code
+          elsif @anchor_id
+            "#{@anchor_id}+#{self.class.pattern_code}"
+          end
+        end
       end
     end
-  end
 
-  class TypeSet < SetPattern
-    def initialize card
-      super
-      @inherit_card = card unless module_key
-    end
+    class Type < Pattern::Abstract
+      def initialize card
+        super
+        # support type inheritance
+        @inherit_card = card unless module_key
+      end
 
-    def lookup_inherited_key
-      return unless @inherit_card
-      card = @inherit_card
-      @inherit_card = nil
-
-      (default_rule = card.rule_card(:default)) &&
-        (type_code = default_rule.type_code) &&
-        # default_rule.cardname.size > 2 and
-        # default_rule.left.right.codename == self.class.pattern_code
-        (mod_key = "Type::#{type_code.to_s.camelize}") &&
-        (Card::Set.modules[:nonbase_format].values +
-          [Card::Set.modules[:nonbase]]).any? { |hash| hash[mod_key] } &&
-        mod_key
-    end
+      def lookup_module_list modules_hash
+        if module_key
+          modules_hash[module_key]
+        else
+          inherited_key && modules_hash[inherited_key]
+        end
+      end
 
-    def inherited_key
-      if defined?(@inherited_key)
-        @inherited_key
-      else
-        @inherited_key = lookup_inherited_key
+      def inherited_key
+        if defined?(@inherited_key)
+          @inherited_key
+        else
+          @inherited_key = lookup_inherited_key
+        end
       end
-    end
 
-    def lookup_module_list modules_hash
-      if module_key
-        modules_hash[module_key]
-      else
-        inherited_key && modules_hash[inherited_key]
+      def lookup_inherited_key
+        return unless @inherit_card
+        card = @inherit_card
+        @inherit_card = nil
+
+        (default_rule = card.rule_card(:default)) &&
+          (type_code = default_rule.type_code) &&
+          # default_rule.cardname.size > 2 and
+          # default_rule.left.right.codename == self.class.pattern_code
+          (mod_key = "Type::#{type_code.to_s.camelize}") &&
+          (Card::Set.modules[:nonbase_format].values +
+            [Card::Set.modules[:nonbase]]).any? { |hash| hash[mod_key] } &&
+          mod_key
       end
     end
   end