card 1.16.8 → 1.16.9

data/lib/card/simplecov_helper.rb

@@ -6,20 +6,24 @@ def card_simplecov_filters
   add_filter 'spec/'
   add_filter '/config/'
   add_filter '/tasks/'
-	
-	# filter all card mods
+  # filter all card mods
   add_filter do |src_file|
     src_file.filename =~ /tmp\// and not
-    /\d+-(.+\.rb)/.match(src_file.filename) { |m| Dir["mod/**/#{m[1].gsub("-","/")}"].present? }
+    /\d+-(.+\.rb)/.match(src_file.filename) do |m|
+      Dir["mod/**/#{m[1].gsub("-","/").sub("/","/set/")}"].present?
+    end
   end
-	
-	# add group for each deck mod
+  # add group for each deck mod
   Dir['mod/*'].map{ |path| path.sub('mod/','') }.each do |mod|
     add_group mod.capitalize do |src_file|
-      src_file.filename =~ /mod\/#{mod}\// or 
+      src_file.filename =~ /mod\/#{mod}\// or
         (
           src_file.filename =~ /tmp\// and
-          /\d+-(.+\.rb)/.match(src_file.filename) { |m| Dir["mod/#{mod}/**/#{m[1].gsub("-","/")}"].present? } and
+          match = /\d+-(.+\.rb)/.match(src_file.filename) do |m|
+            # '/set' is not in the path anymore after some updates
+            # but `set` exists in the path of the source files
+            Dir["mod/**/#{m[1].gsub("-","/").sub("/","/set/")}"].present?
+          end and
           is_in_mod? src_file,mod
         )
     end

data/lib/card/subcards.rb

@@ -0,0 +1,249 @@
+# -*- encoding : utf-8 -*-
+
+# API to create/update/delete additional cards together with the main card.
+# The most common case is for fields but subcards don't have to be descendants.
+#
+# Example toghether with "my address" you want to create the subcards
+# "my address+name", "my address+street", etc.
+#
+# Subcards can be added as card objects or attribute hashes.
+
+class Card
+  def subcards
+    @subcards ||= Subcards.new(self)
+  end
+
+  def preserve_subcards
+    return unless subcards.present?
+    Card.cache.write_local subcards_cache_key, @subcards
+  end
+
+  def restore_subcards
+    cached_subcards = Card.cache.read_local(subcards_cache_key)
+    return unless cached_subcards
+    @subcards = cached_subcards
+    @subcards.context_card = self
+  end
+
+  def expire_subcards
+    Card.cache.delete_local subcards_cache_key
+    subcards.clear
+  end
+
+  def subcards_cache_key
+    "#{key}#SUBCARDS#"
+  end
+
+  class Subcards
+    attr_accessor :context_card, :keys
+    def initialize context_card
+      @context_card = context_card
+      @keys = ::Set.new
+    end
+
+    def clear
+      @keys.each do |key|
+        Card.cache.delete_local key
+      end
+      @keys = ::Set.new
+    end
+
+    def remove name_or_card
+      key = case name_or_card
+            when Card
+              name_or_card.key
+            when Symbol
+              fetch_subcard(name_or_card).key
+            else
+              name_or_card.to_name.key
+            end
+
+      key = absolutize_subcard_name(key).key unless @keys.include?(key)
+      @keys.delete key
+      removed_card = fetch_subcard key
+      Card.cache.delete_local key
+      removed_card
+    end
+
+    def add name_or_card_or_attr, card_or_attr=nil
+      if card_or_attr
+        name = name_or_card_or_attr
+      else
+        card_or_attr = name_or_card_or_attr
+      end
+      case card_or_attr
+      when Hash
+        args = card_or_attr
+        if name
+          new_by_attributes name, args
+        elsif args[:name]
+          new_by_attributes args.delete(:name), args
+        else
+          args.each_pair do |key, val|
+            case val
+            when String then new_by_attributes key, content: val
+            when Card
+              val.name = absolutize_subcard_name key
+              new_by_card val
+            else new_by_attributes key, val
+            end
+          end
+        end
+      when Card
+        new_by_card card_or_attr
+      when Symbol, String
+        new_by_attributes card_or_attr, {}
+      end
+    end
+
+    def rename old_name, new_name
+      return unless @keys.include? old_name.to_name.key
+
+    end
+
+
+
+    def << value
+      add value
+    end
+
+    def method_missing method, *args
+      return unless @keys.respond_to? method
+      @keys.send method, *args
+    end
+
+    def each_card
+      # fetch all cards first to avoid side effects
+      # e.g. deleting a user adds follow rules and +*account to subcards
+      # for deleting but deleting follow rules can remove +*account from the
+      # cache if it belongs to the rule cards
+      cards = @keys.map do |key|
+        fetch_subcard key
+      end
+      cards.each do |card|
+        yield(card) if card
+      end
+    end
+
+    alias_method :each, :each_card
+
+    def each_with_key
+      @keys.each do |key|
+        card = fetch_subcard(key)
+        yield(card, key) if card
+      end
+    end
+
+    def []= name, card_or_attr
+      case card_or_attr
+      when Hash
+        new_by_attributes name, card_or_attr
+      when Card
+        new_by_card card_or_attr
+      end
+    end
+
+    def [] name
+      card(name) || field(name)
+    end
+
+    def field name
+      key = field_name_to_key name
+      if @keys.include? key
+        fetch_subcard key
+      end
+    end
+
+    def card name
+      return unless @keys.include? name.to_name.key
+      fetch_subcard name
+    end
+
+    def add_child name, args
+      add prepend_plus(name), args
+    end
+
+    def remove_child name_or_card
+      if name_or_card.is_a? Card
+        remove name_or_card
+      else
+        absolute_name = @context_card.cardname.field_name(name_or_card)
+        if @keys.include? absolute_name.key
+          remove absolute_name
+        else
+          remove @context_card.cardname.relative_field_name(name_or_card)
+        end
+      end
+    end
+
+    alias_method :add_field, :add_child
+    alias_method :remove_field, :remove_child
+
+    def present?
+      @keys.present?
+    end
+
+    private
+
+    def fetch_subcard key
+      Card.fetch key, local_only: true, new: {}
+    end
+
+    def prepend_plus name
+      case name
+      when Symbol
+        "+#{Card[name].name}"
+      when /^\+/
+        name
+      else
+        "+#{name}"
+      end
+    end
+
+    def field_name_to_key name
+      if @context_card.name =~ /^\+/
+        @context_card.cardname.relative_field_name(name).key
+      else
+        absolute_key = @context_card.cardname.field_name(name).key
+        if @keys.include? absolute_key
+          absolute_key
+        else
+          @context_card.cardname.relative_field_name(name).key
+        end
+      end
+    end
+
+    def new_by_attributes name, attributes={}
+      absolute_name = absolutize_subcard_name name
+      if absolute_name.field_of?(@context_card.name) &&
+         (absolute_name.parts.size - @context_card.cardname.parts.size) > 2
+        left_card = new_by_attributes absolute_name.left
+        new_by_card left_card
+        left_card.new_by_attributes absolute_name, attributes
+      else
+        card = Card.assign_or_initialize_by absolute_name.s, attributes,
+                                            local_only: true
+        new_by_card card
+      end
+    end
+
+    def absolutize_subcard_name name
+      if @context_card.name =~ /^\+/
+        name.to_name
+      else
+        name.to_name.to_absolute_name(@context_card.name)
+      end
+    end
+
+    def new_by_card card
+      card.supercard = @context_card
+      if !card.cardname.simple? &&
+         card.cardname.field_of?(@context_card.cardname)
+        card.superleft = @context_card
+      end
+      @keys << card.key
+      Card.write_to_local_cache card
+      card
+    end
+  end
+end

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

@@ -193,7 +193,6 @@ format do
     end
   end
 
-
   def nested_fields args={}
     result = []
     each_nested_field(args) do |chunk|
@@ -214,7 +213,7 @@ format do
 
     each_nested_chunk(args) do |chunk|
       # TODO handle structures that are non-virtual
-      if chunk.referee_name.to_name.is_a_field_of? card.name
+      if chunk.referee_name.to_name.field_of? card.name
         if chunk.referee_card && chunk.referee_card.virtual? && !processed_chunk_keys.include?(chunk.referee_name.key)
           processed_chunk_keys << chunk.referee_name.key
           subformat(chunk.referee_card).each_nested_field(args) do |sub_chunk|

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

@@ -20,64 +20,77 @@ module ClassMethods
   #     :skip_virtual               Real cards only
   #     :skip_modules               Don't load Set modules
   #     :look_in_trash              Return trashed card objects
+  #     :local_only                 Use only local cache for lookup and storing
   #     new: {  card opts }      Return a new card when not found
   #
-  def fetch mark, opts={}
-    if String === mark
-      case mark
-      when /^\~(\d+)$/ # get by id
-        mark = $1.to_i
-      when /^\:(\w+)$/ # get by codename
-        mark = $1.to_sym
-      end
-    end
-    mark = Card::Codename[mark] if Symbol === mark # id from codename
+  def fetch mark, opts = {}
+    validate_fetch_opts! opts
+    mark = normalize_mark mark
 
     if mark.present?
-      card, mark, needs_caching = fetch_from_cache_or_db mark, opts # have existing
+      card, mark, needs_caching = fetch_from_cache_or_db mark, opts
     else
       return unless opts[:new]
     end
 
-    if Integer===mark
-      return if card.nil? || mark.nil?
-    else
-      return card.renew(opts) if card and card.eager_renew?(opts)
-      if !card or card.type_id==-1 && clean_cache_opts?(opts)       # new (or improved) card for cache
-        needs_caching = true
-        card = new_for_cache mark, opts
-      end
+    if mark.is_a?(Integer)
+      return if card.nil?
+    elsif card && card.new_card? && opts[:new].present?
+      return card.renew(opts)
+    elsif !card || (card.type_unknown? && !skip_type_lookup?(opts))
+      needs_caching = true
+      card = new_for_cache mark, opts # new (or improved) card for cache
     end
 
-    write_to_cache card if Card.cache && needs_caching
+    write_to_cache card, opts if needs_caching
 
     if card.new_card?
-      if opts[:new]
-        return card.renew(opts) if !clean_cache_opts? opts
-      elsif opts[:skip_virtual]
-        return
-      else
-        card.include_set_modules unless opts[:skip_modules]  # need to load modules here to call the right virtual? method
-        return unless card.virtual?
+      case
+      when opts[:new].present? then return card.renew(opts)
+      when opts[:new] # noop for empty hash
+      when opts[:skip_virtual] then return nil
       end
-      card.name = mark.to_s if mark && mark.to_s != card.name
+      card.rename_from_mark mark unless opts[:local_only]
     end
-
+    # need to load modules here to call the right virtual? method
     card.include_set_modules unless opts[:skip_modules]
-    card
+    card if opts[:new] || card.known?
+  end
+
+  def fetch_local mark, opts = {}
+    fetch mark, opts.merge(:local_only=>true)
+  end
+
+  def fetch_id mark
+    if mark.is_a?(Integer)
+      mark
+    elsif mark.is_a?(Symbol) && Card::Codename[mark]
+      Card::Codename[mark]
+    else
+      card = quick_fetch mark.to_s
+      card && card.id
+    end
+  end
+
+  def quick_fetch mark
+    fetch mark, skip_virtual: true, skip_modules: true
   end
 
-  def fetch_id mark #should optimize this.  what if mark is int?  or codename?
-    card = fetch mark, skip_virtual: true, skip_modules: true
-    card and card.id
+  def assign_or_initialize_by name, attributes, fetch_opts = {}
+    if (known_card = Card.fetch(name, fetch_opts))
+      known_card.refresh.assign_attributes attributes
+      known_card
+    else
+      Card.new attributes.merge(name: name)
+    end
   end
 
-  def [](mark)
+  def [] mark
     fetch mark, skip_virtual: true
   end
 
   def exists? mark
-    card = fetch mark, skip_virtual: true, skip_modules: true
+    card = quick_fetch mark
     card.present?
   end
 
@@ -86,14 +99,19 @@ module ClassMethods
     card.present?
   end
 
-  def expire name
-    #note: calling instance method breaks on dirty names
+  def expire name, subcards = false
+    # note: calling instance method breaks on dirty names
     key = name.to_name.key
-    if card = Card.cache.read( key )
+    if card = Card.cache.read(key)
+      if subcards
+        card.expire_subcards
+      else
+        card.preserve_subcards
+      end
       Card.cache.delete key
       Card.cache.delete "~#{card.id}" if card.id
     end
-    #Rails.logger.warn "expiring #{name}, #{card.inspect}"
+    # Rails.logger.warn "expiring #{name}, #{card.inspect}"
   end
 
   # set_names reverse map (cached)
@@ -116,90 +134,135 @@ module ClassMethods
     end
   end
 
-  def cache
-    Card::Cache[Card]
+  def validate_fetch_opts! opts
+    if opts[:new] && opts[:skip_virtual]
+      fail Card::Error, 'fetch called with new args and skip_virtual'
+    end
   end
 
-  def fetch_from_cache cache_key
-    Card.cache.read cache_key if Card.cache
+  def cache
+    Card::Cache[Card]
   end
 
-  def fullname_from_name name, new_opts={}
-    if new_opts and supercard = new_opts[:supercard]
-      name.to_name.to_absolute_name supercard.name
-    else
-      name.to_name
+  def fetch_from_cache cache_key, local_only=false
+    if Card.cache
+      if local_only
+        Card.cache.read_local cache_key
+      else
+        Card.cache.read cache_key
+      end
     end
   end
 
   def fetch_from_cache_or_db mark, opts
     needs_caching = false
-    mark_type = Integer===mark ? :id : :key
-
-    if mark_type == :key
-      mark = fullname_from_name mark, opts[:new]
-      val = mark.key
-    else
-      val = mark
+    mark_type = mark.is_a?(Integer) ? :id : :key
+    expanded_mark = expand_mark mark, opts
+    card = send("fetch_from_cache_by_#{mark_type}",
+                expanded_mark, opts[:local_only])
+
+    if card.nil? || (opts[:look_in_trash] && card.new_card? && !card.trash)
+      query = { mark_type => expanded_mark }
+      query[:trash] = false unless opts[:look_in_trash]
+      card = fetch_from_db query
+      needs_caching = card && !card.trash
+      card.restore_subcards if card
     end
 
-    card = send( "fetch_from_cache_by_#{mark_type}", val )
+    [card, mark, needs_caching]
+  end
 
-    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
-      card = Card.where( mark_type => val, trash: false).take
+  def fetch_from_cache_by_id id, local_only = false
+    if name = fetch_from_cache("~#{id}", local_only)
+      fetch_from_cache name, local_only
     end
+  end
 
-    [ card, mark, needs_caching ]
+  def fetch_from_cache_by_key key, local_only = false
+    fetch_from_cache key, local_only
   end
 
+  def fetch_from_db query
+    Card.where(query).take
+  end
 
-  def fetch_from_cache_by_id id
-    if name = fetch_from_cache("~#{id}")
-      fetch_from_cache name
-    end
+  def new_for_cache name, opts
+    new name: name,
+        skip_modules: true,
+        skip_type_lookup: skip_type_lookup?(opts)
   end
 
-  def fetch_from_cache_by_key key
-    fetch_from_cache key
+  def skip_type_lookup? opts
+    # if opts[:new] is not empty then we are initializing a variant that is
+    # different from the cached variant
+    # and can postpone type lookup for the cached variant
+    # if skipping virtual no need to look for actual type
+    opts[:skip_virtual] || opts[:new].present?
   end
 
-  def new_for_cache name, opts
-    new_args = { name: name, skip_modules: true }
-    new_args[:type_id] = -1 unless clean_cache_opts? opts
-    # The -1 type_id allows us to skip all the type lookup and flag the need for
-    # reinitialization later.  *** It should NEVER be seen elsewhere ***
-    new new_args
+  def write_to_cache card, opts
+    if opts[:local_only]
+      write_to_local_cache card
+    elsif Card.cache
+      Card.cache.write card.key, card
+      Card.cache.write "~#{card.id}", card.key if card.id && card.id != 0
+    end
   end
 
-  def clean_cache_opts? opts
-    !opts[:skip_virtual] && !opts[:new].present?
+  def write_to_local_cache card
+    if Card.cache
+      Card.cache.write_local card.key, card
+      Card.cache.write_local "~#{card.id}", card.key if card.id && card.id != 0
+    end
   end
 
-  def write_to_cache card
-    Card.cache.write card.key, card
-    Card.cache.write "~#{card.id}", card.key if card.id and card.id != 0
+  def expand_mark mark, opts
+    if mark.is_a?(Integer)
+      mark
+    else
+      fullname_from_name(mark, opts[:new]).key
+    end
   end
 
+  def normalize_mark mark
+    case mark
+    when String
+      case mark
+      when /^\~(\d+)$/ # get by id
+        $1.to_i
+      when /^\:(\w+)$/ # get by codename
+        Card::Codename[$1.to_sym]
+      else
+        mark
+      end
+    when Symbol
+      Card::Codename[mark] # id from codename
+    else
+      mark
+    end
+  end
 
+  def fullname_from_name name, new_opts = {}
+    if new_opts && supercard = new_opts[:supercard]
+      name.to_name.to_absolute_name supercard.name
+    else
+      name.to_name
+    end
+  end
 end
 
 # ~~~~~~~~~~ Instance ~~~~~~~~~~~~~
 
-def fetch opts={}
+def fetch opts = {}
   if traits = opts.delete(:trait)
-    traits = [traits] unless Array===traits
-    traits.inject(self) { |card, trait| Card.fetch( card.cardname.trait(trait), opts ) }
+    traits = Array.wrap traits
+    traits.inject(self) do |card, trait|
+      Card.fetch card.cardname.trait(trait), opts
+    end
   end
 end
 
-
-def renew args={}
+def renew args = {}
   opts = args[:new].clone
   opts[:name] ||= cardname
   opts[:skip_modules] = args[:skip_modules]
@@ -208,18 +271,22 @@ end
 
 def expire_pieces
   cardname.piece_names.each do |piece|
-    Card.expire piece
+    Card.expire piece, !cardname.field_of?(piece)
   end
 end
 
-
-def expire
-  #Rails.logger.warn "expiring i:#{id}, #{inspect}"
+def expire subcards = false
+  # Rails.logger.warn "expiring i:#{id}, #{inspect}"
+  if subcards
+    expire_subcards
+  else
+    preserve_subcards
+  end
   Card.cache.delete key
   Card.cache.delete "~#{id}" if id
 end
 
-def refresh force=false
+def refresh force = false
   if force || self.frozen? || self.readonly?
     fresh_card = self.class.find id
     fresh_card.include_set_modules
@@ -233,4 +300,12 @@ def eager_renew? opts
   opts[:skip_virtual] && new_card? && opts[:new].present?
 end
 
+def type_unknown?
+  type_id.nil?
+end
+
+def rename_from_mark mark
+  return unless mark && mark.to_s != name
+  self.name = mark.to_s
+end