card 1.20.4 → 1.21.0

data/tmpsets/set/mod001-core/all/fetch.rb

@@ -11,18 +11,20 @@ module ClassMethods
   # * database
   # * virtual cards
   #
-  # @param args [Integer, String, Card::Name, Symbol]
-  #    one or more of the three unique identifiers
-  #      1. a numeric id (Integer)
-  #      2. a name/key (String or Card::Name)
-  #      3. a codename (Symbol)
-  #    If you pass more then one mark they get joined with a '+'.
-  #    The final argument can be a hash to set the following options
-  #      :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: { opts for Card#new }  Return a new card when not found
+  # @param mark [Integer, String, Card::Name, Symbol, Array]
+  #    one of three unique identifiers
+  #    1. a numeric id (Integer)
+  #    2. a name/key (String or Card::Name)
+  #    3. a codename (Symbol)
+  #    or any combination of those. If you pass more then one mark they get
+  #    joined with a '+'
+  # @param options [Hash]
+  #   Options:
+  #     :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: { opts for Card#new }  Return a new card when not found
   #
   # @return [Card]
   def fetch *args

data/tmpsets/set/mod001-core/all/name.rb

@@ -56,11 +56,11 @@ def update_subcard_names cardname
     # and self is a subcard as well that changed from +B to A+B then
     # +C should change to A+B+C. #replace_part doesn't work in this case
     # because the old name +B is not a part of +C
+    # name_to_replace =
     name_to_replace =
       if subcard.cardname.junction? &&
          subcard.cardname.parts.first.empty? &&
          cardname.parts.first.present?
-        # replace the empty part
         "".to_name
       else
         name

data/tmpsets/set/mod001-core/all/permissions.rb

@@ -187,38 +187,28 @@ event :set_field_read_rules,
   end
 end
 
-# currently doing a brute force search for every card that may be impacted.
-# may want to optimize(?)
-def update_field_read_rules
+def update_read_rule
+  Card.record_timestamps = false
+  reset_patterns # why is this needed?
+  rcard_id, rclass = permission_rule_id_and_class :read
+  # these two are just to make sure vals are correct on current object
+  self.read_rule_id = rcard_id
+  self.read_rule_class = rclass
+  Card.where(id: id).update_all read_rule_id: rcard_id, read_rule_class: rclass
+  expire_hard
+
+  # currently doing a brute force search for every card that may be impacted.
+  # may want to optimize(?)
   Auth.as_bot do
     fields.each do |field|
       field.update_read_rule if field.rule(:read) == "_left"
     end
   end
-end
 
-def without_timestamps
-  Card.record_timestamps = false
-  yield
 ensure
   Card.record_timestamps = true
 end
 
-event :update_read_rule do
-  without_timestamps do
-    reset_patterns # why is this needed?
-    rcard_id, rclass = permission_rule_id_and_class :read
-    # these two are just to make sure vals are correct on current object
-    self.read_rule_id = rcard_id
-    self.read_rule_class = rclass
-    Card.where(id: id).update_all read_rule_id: rcard_id,
-                                  read_rule_class: rclass
-    expire_hard
-
-    update_field_read_rules
-  end
-end
-
 def add_to_read_rule_update_queue updates
   @read_rule_update_queue = Array.wrap(@read_rule_update_queue).concat updates
 end

data/tmpsets/set/mod001-core/all/tracked_attributes.rb

@@ -73,6 +73,82 @@ event :set_content, :store, on: :save do
   reset_patterns_if_rule true
 end
 
+# FIXME: the following don't really belong here, but they have to come after
+# the reference stuff.  we need to organize a bit!
+
+event :update_ruled_cards, :finalize do
+  if is_rule?
+    # warn "updating ruled cards for #{name}"
+    self.class.clear_rule_cache
+    set = rule_set
+
+    if right_id == Card::ReadID && (name_changed? || trash_changed?)
+      update_read_ruled_cards set
+    end
+  end
+end
+
+def update_read_rules_of_set_members_not_governed_by_narrower_rules set
+  return {} if trash || !set || !(set_class = set.tag) ||
+               !(class_id = set_class.id)
+  in_set = {}
+  rule_class_ids = set_patterns.map(&:pattern_id)
+  Auth.as_bot do
+    cur_index = rule_class_ids.index Card[read_rule_class].id
+    if (rule_class_index = rule_class_ids.index(class_id))
+      set.item_cards(limit: 0).each do |item_card|
+        in_set[item_card.key] = true
+        next if cur_index < rule_class_index
+        item_card.update_read_rule if cur_index >= rule_class_index
+      end
+    else
+      warn "No current rule index #{class_id}, #{rule_class_ids.inspect}"
+    end
+  end
+  in_set
+end
+
+def update_read_ruled_cards set
+  self.class.clear_read_rule_cache
+  Card.cache.reset # maybe be more surgical, just Auth.user related
+  expire # probably shouldn't be necessary,
+  # but was sometimes getting cached version when card should be in the
+  # trash.  could be related to other bugs?
+
+  updated = update_read_rules_of_set_members_not_governed_by_narrower_rules set
+
+  # then find all cards with me as read_rule_id that were not just updated
+  # and regenerate their read_rules
+  return if new_card?
+  Card.search(read_rule_id: id) do |card|
+    card.update_read_rule unless updated[card.key]
+  end
+end
+
+event :process_read_rule_update_queue, :finalize do
+  Array.wrap(@read_rule_update_queue).each(&:update_read_rule)
+  @read_rule_update_queue = []
+end
+
+event :expire_related, :finalize do
+  subcards.keys.each do |key|
+    Card.cache.soft.delete key
+  end
+  expire # FIXME: where do we put this. Here it deletes @stage
+  reset_patterns
+  if is_structure?
+    structuree_names.each do |name|
+      Card.expire name
+    end
+  end
+end
+
+event :expire_related_names, before: :expire_related, changed: :name do
+  # FIXME: look for opportunities to avoid instantiating the following
+  descendants.each(&:expire)
+  name_referers.each(&:expire)
+end
+
 
 # ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/tracked_attributes.rb ~~
 end;end;end;end;

data/tmpsets/set/mod001-core/all/utils.rb

@@ -8,6 +8,7 @@ module ClassMethods
     Card::Action.delete_cardless
     Card::Reference.unmap_if_referee_missing
     Card::Reference.delete_if_referer_missing
+    Card.delete_tmp_files_of_cached_uploads
   end
 
   # deletes any file not associated with a real card.
@@ -43,6 +44,20 @@ module ClassMethods
     sql_results.map(&:values).flatten.map(&:to_i)
   end
 
+  def delete_tmp_files_of_cached_uploads
+    actions = Card::Action.find_by_sql "SELECT * FROM card_actions
+      INNER JOIN cards ON card_actions.card_id = cards.id
+      WHERE cards.type_id IN (#{Card::FileID}, #{Card::ImageID})
+      AND card_actions.draft = true"
+    actions.each do |action|
+      # we don't want to delete uploads in progress
+      if older_than_five_days?(action.created_at) && (card = action.card)
+        # we don't want to delete uploads in progress
+        card.delete_files_for_action action
+      end
+    end
+  end
+
   def merge_list attribs, opts={}
     unmerged = []
     attribs.each do |row|
@@ -72,7 +87,7 @@ module ClassMethods
   end
 
   def merge name, attribs={}, opts={}
-    puts "merging #{name}"
+    # puts "merging #{name}"
     card = fetch name, new: {}
     [:image, :file].each do |attach|
       next unless attribs[attach] && attribs[attach].is_a?(String)
@@ -85,11 +100,33 @@ module ClassMethods
     end
   end
 
-  def seed_test_db
-    system "env RAILS_ENV=test bundle exec rake db:fixtures:load"
+  def older_than_five_days? time
+    Time.now - time > 432_000
   end
 end
 
+def debug_type
+  "#{type_code || ''}:#{type_id}"
+end
+
+def to_s
+  "#<#{self.class.name}[#{debug_type}]#{attributes['name']}>"
+end
+
+def inspect
+  tags = []
+  tags << "trash"    if trash
+  tags << "new"      if new_card?
+  tags << "frozen"   if frozen?
+  tags << "readonly" if readonly?
+  tags << "virtual"  if @virtual
+  tags << "set_mods_loaded" if @set_mods_loaded
+
+  error_messages = errors.any? ? "<E*#{errors.full_messages * ', '}*>" : ""
+
+  "#<Card##{id}[#{debug_type}](#{name})#{error_messages}{#{tags * ','}}"
+end
+
 
 # ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/core/set/all/utils.rb ~~
 end;end;end;end;

data/tmpsets/set/mod002-history/all/history.rb

@@ -85,8 +85,7 @@ event :rollback_actions, :prepare_to_validate,
   Env.params["action_ids"] = nil
   update_attributes! revision
   rollback_actions.each do |action|
-    # rollback file and image cards
-    action.card.try :rollback_to, action
+    action.card.try :symlink_to, action.id
   end
   clear_drafts
   abort :success

data/tmpsets/set/mod008-solid_cache/abstract/solid_cache.rb

@@ -31,7 +31,7 @@ module ClassMethods
   # cards whose solid caches are expired because of the update.
   # @param set_of_changed_card [set constant] a set of cards that triggers
   #   a cache update
-  # @param args [Hash]
+  # @params args [Hash]
   # @option args [Symbol, Array of symbols] :on the action(s)
   #   (:create, :update, or :delete) on which the cache update
   #   should be triggered. Default is all actions.

data/tmpsets/set/mod013-carrierwave/abstract/attachment.rb

@@ -0,0 +1,282 @@
+# -*- encoding : utf-8 -*-
+class Card; module Set; class Abstract; module Attachment; extend Card::Set
+# ~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/carrierwave/set/abstract/attachment.rb ~~
+require "carrier_wave/cardmount"
+
+def self.included host_class
+  host_class.extend CarrierWave::CardMount
+end
+
+event :select_file_revision, after: :select_action do
+  attachment.retrieve_from_store!(attachment.identifier)
+end
+
+event :upload_attachment, :prepare_to_validate,
+      on: :save, when: proc { |c| c.preliminary_upload? } do
+  save_original_filename  # save original filename as comment in action
+  write_identifier        # set db_content
+  # (needs original filename to determine extension)
+  store_attachment!
+  finalize_action         # create Card::Change entry for db_content
+
+  card_id = new_card? ? upload_cache_card.id : id
+  @current_action.update_attributes! draft: true, card_id: card_id
+  success << {
+    target: (new_card? ? upload_cache_card : self),
+    type: type_name,
+    view: "preview_editor",
+    rev_id: current_action.id
+  }
+  abort :success
+end
+
+event :assign_attachment_on_create, :initialize,
+      after: :assign_action, on: :create,
+      when: proc { |c| c.save_preliminary_upload? } do
+  if (action = Card::Action.fetch(@action_id_of_cached_upload))
+    upload_cache_card.selected_action_id = action.id
+    upload_cache_card.select_file_revision
+    assign_attachment upload_cache_card.attachment.file, action.comment
+  end
+end
+
+event :assign_attachment_on_update, :initialize,
+      after: :assign_action, on: :update,
+      when:  proc { |c| c.save_preliminary_upload? } do
+  if (action = Card::Action.fetch(@action_id_of_cached_upload))
+    uploaded_file =
+      with_selected_action_id(action.id) do
+        attachment.file
+      end
+    assign_attachment uploaded_file, action.comment
+  end
+end
+
+def assign_attachment file, original_filename
+  send "#{attachment_name}=", file
+  write_identifier
+  @current_action.update_attributes! comment: original_filename
+end
+
+# we need a card id for the path so we have to update db_content when we have
+# an id
+event :correct_identifier, :finalize, on: :create do
+  update_column(:db_content, attachment.db_content(mod: load_from_mod))
+  expire
+end
+
+def file_ready_to_save?
+  attachment.file.present? &&
+    !preliminary_upload? &&
+    !save_preliminary_upload? &&
+    attachment_changed?
+end
+
+event :save_original_filename, :prepare_to_store,
+      when: proc { |c| c.file_ready_to_save? } do
+  return unless @current_action
+  @current_action.update_attributes! comment: original_filename
+end
+
+event :delete_cached_upload_file_on_create, :integrate,
+      on: :create, when: proc { |c| c.save_preliminary_upload? } do
+  if (action = Card::Action.fetch(@action_id_of_cached_upload))
+    upload_cache_card.delete_files_for_action action
+    action.delete
+  end
+  clear_upload_cache_dir_for_new_cards
+end
+
+event :delete_cached_upload_file_on_update, :integrate,
+      on: :update, when: proc { |c| c.save_preliminary_upload? } do
+  if (action = Card::Action.fetch(@action_id_of_cached_upload))
+    delete_files_for_action action
+    action.delete
+  end
+end
+
+event :validate_file_exist, :validate, on: :create do
+  unless attachment.file.present? || empty_ok?
+    errors.add attachment_name, "is missing"
+  end
+end
+
+event :write_identifier, after: :save_original_filename do
+  self.content = attachment.db_content(mod: load_from_mod)
+end
+
+def item_names _args={} # needed for flexmail attachments.  hacky.
+  [cardname]
+end
+
+def original_filename
+  attachment.original_filename
+end
+
+def unfilled?
+  !attachment.present? && !save_preliminary_upload? && !subcards.present?
+end
+
+def preliminary_upload?
+  Card::Env && Card::Env.params[:attachment_upload]
+end
+
+def save_preliminary_upload?
+  @action_id_of_cached_upload.present?
+end
+
+def attachment_changed?
+  send "#{attachment_name}_changed?"
+end
+
+def create_versions?
+  true
+end
+
+# used for uploads for new cards until the new card is created
+def upload_cache_card
+  @upload_cache_card ||= Card["new_#{attachment_name}".to_sym]
+end
+
+# action id of the cached upload
+attr_writer :action_id_of_cached_upload
+
+attr_reader :action_id_of_cached_upload
+
+attr_writer :empty_ok
+
+def empty_ok?
+  @empty_ok
+end
+
+def load_from_mod= value
+  @mod = value
+  write_identifier
+  @store_in_mod = true if value
+end
+
+def load_from_mod
+  @mod
+end
+
+def store_dir
+  if @store_in_mod
+    mod_dir
+  else
+    upload_dir
+  end
+end
+
+def retrieve_dir
+  if mod_file?
+    mod_dir
+  else
+    upload_dir
+  end
+end
+
+# place for files of regular file cards
+def upload_dir
+  if id
+    "#{Card.paths['files'].existent.first}/#{id}"
+  else
+    tmp_upload_dir
+  end
+end
+
+# place for files if card doesn't have an id yet
+def tmp_upload_dir _action_id=nil
+  "#{Card.paths['files'].existent.first}/#{upload_cache_card.id}"
+end
+
+# place for files of mod file cards
+def mod_dir
+  mod = @mod || mod_file?
+  Card.paths["mod"].to_a.each do |mod_path|
+    dir = File.join(mod_path, mod, "file", codename)
+    return dir if Dir.exist? dir
+  end
+end
+
+def mod_file?
+  return @mod if @store_in_mod
+  # when db_content was changed assume that it's no longer a mod file
+  return if db_content_changed? || !content.present?
+  case content
+  when %r{^:[^/]+/([^.]+)} then Regexp.last_match(1) # current mod_file format
+  when /^\~/               then false  # current id file format
+  else
+    if (lines = content.split("\n")) && (lines.size == 4)
+      # old format, still used in card_changes.
+      lines.last
+    end
+  end
+end
+
+def assign_set_specific_attributes
+  # reset content if we really have something to upload
+  if @set_specific.present? && @set_specific[attachment_name.to_s].present?
+    self.content = nil
+  end
+  super
+end
+
+def clear_upload_cache_dir_for_new_cards
+  Dir.entries(tmp_upload_dir).each do |filename|
+    if filename =~ /^\d+/
+      path = File.join(tmp_upload_dir, filename)
+      FileUtils.rm path if Card.older_than_five_days? File.ctime(path)
+    end
+  end
+end
+
+def delete_files_for_action action
+  with_selected_action_id(action.id) do
+    FileUtils.rm attachment.file.path
+    attachment.versions.each_value do |version|
+      FileUtils.rm version.path
+    end
+  end
+end
+
+# create filesystem links to files from prior action
+def symlink_to prior_action_id
+  return unless prior_action_id != last_action_id
+  save_action_id = selected_action_id
+  links = {}
+
+  self.selected_action_id = prior_action_id
+  attachment.versions.each do |name, version|
+    links[name] = version.store_path
+  end
+  original = attachment.store_path
+
+  self.selected_action_id = last_action_id
+  attachment.versions.each do |name, version|
+    ::File.symlink links[name], version.store_path
+  end
+  ::File.symlink original, attachment.store_path
+
+  self.selected_action_id = save_action_id
+end
+
+def attachment_format ext
+  if ext.present? && attachment && (original_ext = attachment.extension)
+    if ["file", original_ext].member? ext
+      original_ext
+    elsif (exts = MIME::Types[attachment.content_type])
+      if exts.find { |mt| mt.extensions.member? ext }
+        ext
+      else
+        exts[0].extensions[0]
+      end
+    end
+  end
+rescue => e
+  Rails.logger.info "attachment_format issue: #{e.message}"
+  nil
+end
+
+
+# ~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/carrierwave/set/abstract/attachment.rb ~~
+end;end;end;end;