card 1.16.1 → 1.16.2

data/lib/card/loader.rb

@@ -21,7 +21,7 @@ class Card
         load_set_patterns
         load_formats
         load_sets
-        
+
         if Wagn.config.performance_logger
           Card::Log::Performance.load_config Wagn.config.performance_logger
         end
@@ -48,11 +48,6 @@ class Card
 
       def mod_dirs
         @@mod_dirs ||= begin
-          if Card.paths['local-mod']
-            Card.paths['mod'] << Card.paths['local-mod']
-            Rails.logger.warn 'DEPRECATION WARNING: Append to paths[\'mod\'] vs. local-mod for configuring location of local (deck) modules.'
-          end
-
           Card.paths['mod'].existent.map do |dirname|
             Dir.entries( dirname ).sort.map do |filename|
               "#{dirname}/#{filename}" if filename !~ /^\./
@@ -65,12 +60,12 @@ class Card
 
       def load_set_patterns
         if rewrite_tmp_files?
-          load_set_patterns_from_source
+          generate_set_pattern_tmp_files
         end
         load_dir "#{Card.paths['tmp/set_pattern'].first}/*.rb"
       end
 
-      def load_set_patterns_from_source
+      def generate_set_pattern_tmp_files
         prepare_tmp_dir 'tmp/set_pattern'
         seq = 100
         mod_dirs.each do |mod|
@@ -95,44 +90,49 @@ class Card
       end
 
       def load_sets
-        prepare_tmp_dir 'tmp/set'
-        load_sets_by_pattern
+        generate_tmp_set_modules
+        load_tmp_set_modules
         Set.process_base_modules
         Set.clean_empty_modules
       end
 
 
-      def load_sets_by_pattern
-        Card.set_patterns.reverse.map(&:pattern_code).each do |set_pattern|
-          pattern_tmp_dir = "#{Card.paths['tmp/set'].first}/#{set_pattern}"
-          if rewrite_tmp_files?
-            Dir.mkdir pattern_tmp_dir
-            load_implicit_sets_from_source set_pattern
-          end
-          if Dir.exists? pattern_tmp_dir
-            load_dir "#{pattern_tmp_dir}/**/*.rb"
+      def generate_tmp_set_modules
+        if prepare_tmp_dir 'tmp/set'
+          seq = 1
+          mod_dirs.each do |mod_dir|
+            mod_tmp_dir = make_set_module_tmp_dir mod_dir, seq
+            Dir.glob("#{mod_dir}/set/**/*.rb").each do |abs_filename|
+              rel_filename = abs_filename.gsub "#{mod_dir}/set/", ''
+              tmp_filename = "#{mod_tmp_dir}/#{rel_filename}"
+              Set.write_tmp_file abs_filename, tmp_filename, rel_filename
+            end
+            seq = seq + 1
           end
         end
       end
 
-      def load_implicit_sets_from_source set_pattern
-        seq = 1000
-        mod_dirs.each do |mod_dir|
-          dirname = [mod_dir, 'set', set_pattern] * '/'
-          next unless File.exists?( dirname )
-
-          old_pwd = Dir.pwd
-          Dir.chdir dirname
-          Dir.glob( "**/*.rb" ).sort.each do |anchor_path|
-            path_parts = anchor_path.gsub(/\.rb/,'').split(File::SEPARATOR)
-            filename = File.join dirname, anchor_path
-            Set.write_tmp_file set_pattern, path_parts, filename, seq
-            seq = seq + 1
+
+      def load_tmp_set_modules
+        patterns = Card.set_patterns.reverse.map(&:pattern_code).unshift 'abstract'
+        Dir.glob( "#{Card.paths['tmp/set'].first}/*" ).sort.each do |tmp_mod|
+          patterns.each do |pattern|
+            pattern_dir = "#{tmp_mod}/#{pattern}"
+            if Dir.exists? pattern_dir
+              load_dir "#{pattern_dir}/**/*.rb"
+            end
           end
-          Dir.chdir old_pwd
         end
       end
 
+      def make_set_module_tmp_dir mod_dir, seq
+        modname = mod_dir.match(/[^\/]+$/)[0]
+        mod_tmp_dir = "#{Card.paths['tmp/set'].first}/mod#{"%03d" % seq}-#{modname}"
+        Dir.mkdir mod_tmp_dir
+        mod_tmp_dir
+      end
+
+
       def prepare_tmp_dir path
         if rewrite_tmp_files?
           p = Card.paths[ path ]

data/lib/card/name.rb

@@ -53,5 +53,13 @@ class Card
         self.s.match /^\s*\+/
       end
     end
+    
+    def is_setting?
+      Set::Type::Setting.member_names[ key ]
+    end
+    
+    def is_set?
+      SetPattern.card_keys[ tag_name.key ]
+    end
   end
 end

data/lib/card/set.rb

@@ -10,7 +10,7 @@ class Card
 
 
 =begin
-    A "Set" is a group of cards to which "Rules" may be applied.  Sets can be as specific as
+    A "Set" is a group of Cards to which "Rules" may be applied.  Sets can be as specific as
     a single card, as general as all cards, or anywhere in between.
 
     Rules take two main forms: card rules and code rules.
@@ -236,6 +236,22 @@ class Card
     end
 
 
+    def ensure_set &block
+      begin
+        set_module = block.call
+      rescue NameError => e
+        if e.message.match /uninitialized constant (?:Card::Set::)?(.+)$/
+          $1.split('::').inject(Card::Set) do |set_module, module_name|
+            set_module.const_get_or_set module_name do
+              Module.new
+            end
+          end
+        end
+        ensure_set &block # try again - there might be another submodule that doesn't exist
+      else
+        set_module.extend Card::Set
+      end
+    end
 
 
     # the set loading process has two main phases:
@@ -254,35 +270,34 @@ class Card
         register_set mod
       end
 
+
+      # make the set available for use
       def register_set set_module
-        if set_module.all_set?
+        if set_module.abstract_set?
+          # noop; only used by explicit inclusion in other set modules
+        elsif set_module.all_set?
+          # automatically included in Card class
           modules[ :base ] << set_module
         else
+          # made ready for dynamic loading via #include_set_modules
           modules[ :nonbase ][ set_module.shortname ] ||= []
           modules[ :nonbase ][ set_module.shortname ] << set_module
         end
       end
 
-      def write_tmp_file set_pattern, anchors, from_file, seq
-        # FIXME - this does not properly handle anchorless sets
-        # There are special hacks for *all, but others (like *rstar) will not be found by
-        # include_set_modules, which will look for Card::Set::Rstar, not Card::Set::Rstar::Blah
-        # This issue appears to be addressed by making the entries, in modules arrays.
-        # If yes remove this comment.
-
-        to_file = "#{Cardio.paths['tmp/set'].first}/#{set_pattern}/#{seq}-#{anchors * '-'}.rb"
-        anchor_modules = anchors.map { |a| "module #{a.camelize};" } * ' '
+      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; module #{set_pattern.camelize}; #{anchor_modules}
-extend Card::Set
-# ~~~~~~~~~~~ above autogenerated; below pulled from #{from_file} ~~~~~~~~~~~
-
+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;#{'end;'*anchors.size}
+end;end;#{'end;'*name_parts.size}
 EOF
+
+        FileUtils.mkdir_p to_file.gsub /[^\/]*$/, ''
         File.write to_file, file_content
         to_file
       end
@@ -331,10 +346,14 @@ EOF
 
 
     def register_set_format format_class, mod
-      if self.all_set?
+      if self.abstract_set?
+        # noop; only used by explicit inclusion in other set modules
+      elsif self.all_set?
+        # ready to include in base format classes
         modules[ :base_format ][ format_class ] ||= []
         modules[ :base_format ][ format_class ] << mod
       else
+        # ready to include dynamically in set members' format singletons
         format_hash = modules[ :nonbase_format ][ format_class ] ||= {}
         format_hash[ shortname ] ||= []
         format_hash[ shortname ] << mod
@@ -350,6 +369,10 @@ EOF
       parts[first..last].join '::'
     end
 
+    def abstract_set?
+      name =~ /^Card::Set::Abstract::/
+    end
+
     def all_set?
       name =~ /^Card::Set::All::/
     end
@@ -417,6 +440,10 @@ EOF
       end
     end
 
+    def set_specific_attributes *args
+      Card.set_specific_attributes ||= []
+      Card.set_specific_attributes += args.map(&:to_s)
+    end
   end
 end
 

data/lib/card/set_pattern.rb

@@ -5,6 +5,14 @@ class Card
     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.fetch( set_pattern.pattern_code.to_sym, :skip_modules=>true ).key
+          hash[ card_key ] = true
+          hash
+        end
+      end
+      
       def find pattern_code
         Card.set_patterns.find { |sub| sub.pattern_code == pattern_code }        
       end

data/lib/cardio.rb

@@ -2,10 +2,11 @@
 
 require 'active_support/core_ext/numeric/time'
 
-CARD_GEM_ROOT = File.expand_path('../..', __FILE__)
 
 module Cardio
 
+  CARD_GEM_ROOT = File.expand_path('../..', __FILE__)
+
   ActiveSupport.on_load :card do
     if Card.count > 0
       Card::Loader.load_mods
@@ -68,6 +69,7 @@ module Cardio
       add_path 'tmp/set_pattern', :root => root
 
       add_path 'mod'
+
       add_path "db"
       add_path 'db/migrate'
       add_path "db/migrate_core_cards"
@@ -75,8 +77,22 @@ module Cardio
       add_path "db/seeds", :with => "db/seeds.rb"
 
       add_path 'config/initializers',  :glob => '**/*.rb'
-      paths['config/initializers'] << "#{gem_root}/mod/**{,/*/**}/initializers"
-      paths['config/initializers'] << "#{root}/mod/**{,/*/**}/initializers"
+
+    end
+
+
+    def set_mod_paths
+      each_mod_path do |mod_path|
+        Dir.glob( "#{mod_path}/*/initializers" ).each do |initializers_dir|
+          paths['config/initializers'] << initializers_dir
+        end
+      end
+    end
+
+    def each_mod_path
+      paths['mod'].each do |mod_path|
+        yield mod_path
+      end
     end
 
     def root

data/mod/01_core/chunk/link.rb

@@ -14,13 +14,14 @@ module Card::Chunk
     }
 
     def interpret match, content
-      target, @link_text = if raw_syntax = match[1]
-        if i = divider_index( raw_syntax )  # [[ A | B ]]
-          [ raw_syntax[0..(i-1)], raw_syntax[(i+1)..-1] ]
-        else                                # [[ A ]]
-          [ raw_syntax, nil ]
+      target, @link_text =
+        if (raw_syntax = match[1])
+          if i = divider_index( raw_syntax )  # [[ A | B ]]
+            [ raw_syntax[0..(i-1)], raw_syntax[(i+1)..-1] ]
+          else                                # [[ A ]]
+            [ raw_syntax, nil ]
+          end
         end
-      end
 
       @link_text = objectify @link_text
       if target =~ /\/|mailto:/

data/mod/01_core/chunk/query_reference.rb

@@ -0,0 +1,65 @@
+# -*- encoding : utf-8 -*-
+
+require_dependency File.expand_path( '../reference', __FILE__ )
+
+module Card::Chunk
+
+  # This should find +Alfred+ in expressions like
+  # 1) {"name":"Alfred"}
+  # 2a) {"name":["in","Alfred"]}
+  # 3a) {"plus_right":["Alfred"]}
+  # but not in
+  # 2b) "content":"foo", "Alfred":"bar"
+  # 3b) {"name":["Alfred", "Toni"]}
+  # It's not possible to distinguish between 2a) and 2b) or 3a) and 3b) with a simple regex
+  # hence we use a too general regex and check for query keywords after the match
+  # which of course means that we don't find references with query keywords as name
+  class QueryReference < Reference
+    QUERY_KEYWORDS = ::Set.new(
+      (
+        Card::Query::MODIFIERS.keys                +
+        Card::Query::OPERATORS.keys                +
+        Card::Query::CardClause::ATTRIBUTES.keys   +
+        Card::Query::CardClause::CONJUNCTIONS.keys +
+        ['desc', 'asc', 'count']
+      ).map(&:to_name)
+    )
+    word = /\s*([^"]+)\s*/
+
+    # we check for colon, comma or square bracket before a quote
+    # OPTIMIZE: instead of comma or square bracket check for operator followed by comma or "plus_right"|"plus_left"|"plus" followed by square bracket
+    Card::Chunk.register_class self, {
+      :prefix_re => '(?<=[:,\\[])\\s*"',  # we have to use a lookbehind, otherwise
+                                                  # if the colon matches it would be
+                                                  # identified mistakenly as an URI chunk
+      :full_re   => /"([^"]+)"/,
+      :idx_char  => '"'
+    }
+
+    class << self
+      def full_match content, prefix
+        match, offset = super(content,prefix)
+        if match && !QUERY_KEYWORDS.include?(match[1].to_name)
+          [match, offset]
+        end
+      end
+    end
+
+    def interpret match, content
+      @name = match[1]
+    end
+
+    def process_chunk
+      @process_chunk ||= @text
+    end
+
+    def inspect
+      "<##{self.class}:n[#{@name}] p[#{@process_chunk}] txt:#{@text}>"
+    end
+
+    def replace_reference old_name, new_name
+      replace_name_reference old_name, new_name
+      @text = "\"#{referee_name.to_s}\""
+    end
+  end
+end

data/mod/01_core/set/all/content.rb

@@ -55,7 +55,7 @@ end
 
 
 event :set_default_content, :on=>:create, :before=>:approve do
-  if !db_content_changed? and template and template.db_content.present?
+  if !db_content_changed? && template && template.db_content.present?
     self.db_content = template.db_content
   end
 end

data/mod/01_core/set/all/fetch.rb

@@ -11,17 +11,17 @@ module ClassMethods
   #   - database
   #   - virtual cards
   #
-  # "mark" here means a generic identifier -- can be a numeric id, a name, a string name, etc.
+  # "mark" here means one of three unique identifiers
+  #    1. a numeric id (Integer)
+  #    2. a name/key (String or Card::Name)
+  #    3. a codename (Symbol)
   #
   #   Options:
   #     :skip_virtual               Real cards only
   #     :skip_modules               Don't load Set modules
+  #     :look_in_trash              Return trashed card objects
   #     :new => {  card opts }      Return a new card when not found
   #
-
-
-
-
   def fetch mark, opts={}
     if String === mark
       case mark
@@ -143,14 +143,22 @@ module ClassMethods
       val = mark
     end
 
-    card = send( "fetch_from_cache_by_#{mark_type}", val ) || begin
+    card = send( "fetch_from_cache_by_#{mark_type}", val )
+
+    if opts[:look_in_trash]
+      if card.nil? || (card.new_card? && !card.trash)
+        card = Card.where( mark_type => val ).take
+        needs_caching = card && !card.trash
+      end
+    elsif card.nil?
       needs_caching = true
-      send "find_by_#{mark_type}_and_trash", val, false
+      card = Card.where( mark_type => val, trash: false).take
     end
 
     [ card, mark, needs_caching ]
   end
 
+
   def fetch_from_cache_by_id id
     if name = fetch_from_cache("~#{id}")
       fetch_from_cache name