card 1.91 → 1.92

data/mod/core/set/all/fetch_helper.rb

@@ -0,0 +1,130 @@
+
+module ClassMethods
+
+  # a fetch method to support the needs of the card controller.
+  # should be in Decko?
+  def controller_fetch args
+    opts = controller_fetch_opts args
+    if args[:action] == "create"
+      # FIXME: we currently need a "new" card to catch duplicates
+      # (otherwise save will just act like a normal update)
+      # We may need a "#create" instance method to handle this checking?
+      Card.new opts
+    else
+      mark = args[:id] || opts[:name]
+      Card.fetch mark, look_in_trash: args[:look_in_trash], new: opts
+    end
+  end
+
+  private
+
+  def controller_fetch_opts args
+    opts =
+        # clone doesn't work for Parameters
+        if args[:card].respond_to?(:to_unsafe_h)
+          args[:card].to_unsafe_h
+        else
+          (args[:card] || {}).clone
+        end
+    # clone so that original params remain unaltered.  need deeper clone?
+    opts[:type] ||= args[:type] if args[:type]
+    # for /new/:type shortcut.  we should handle in routing and deprecate this
+    opts[:name] ||= Card::Name.url_key_to_standard(args[:id])
+    opts
+  end
+
+  def validate_fetch_opts! opts
+    return unless opts[:new] && opts[:skip_virtual]
+    raise Card::Error, "fetch called with new args and skip_virtual"
+  end
+
+  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? || opts[:skip_type_lookup]
+  end
+
+  def retrieve_existing mark, opts
+    return [nil, false] unless mark.present?
+    mark_type, mark_key = retrievable_mark_type_and_value mark
+    needs_caching = false # until proven true :)
+
+    # look in cache
+    card = send "retrieve_from_cache_by_#{mark_type}", mark_key, opts[:local_only]
+
+    if retrieve_from_db?(card, opts)
+      # look in db if needed
+      card = retrieve_from_db mark_type, mark_key, opts
+      needs_caching = !card.nil? && !card.trash
+    end
+
+    [card, needs_caching]
+  end
+
+  def retrievable_mark_type_and_value mark
+    # return mark_type and mark_value
+    if mark.is_a? Integer
+      [:id, mark]
+    else
+      [:key, mark.key]
+    end
+  end
+
+  def retrieve_from_db? card, opts
+    card.nil? || (opts[:look_in_trash] && card.new_card? && !card.trash)
+  end
+
+  def retrieve_from_db mark_type, mark_key, opts
+    query = { mark_type => mark_key }
+    query[:trash] = false unless opts[:look_in_trash]
+    card = Card.where(query).take
+    card
+  end
+
+  def standard_fetch_results card, mark, opts
+    if card.new_card?
+      new_card_fetch_results card, mark, opts
+    else
+      finalize_fetch_results card, opts
+    end
+  end
+
+  def new_card_fetch_results card, mark, opts
+    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.assign_name_from_fetched_mark! mark, opts
+    return nil unless opts[:new] || card.known?
+    finalize_fetch_results card, opts
+  end
+
+  def finalize_fetch_results card, opts
+    card.include_set_modules unless opts[:skip_modules]
+    card
+  end
+
+  def normalize_fetch_args args
+    opts = args.last.is_a?(Hash) ? args.pop : {}
+    mark = compose_mark args
+    mark = absolutize_fetch_mark mark, opts.dig(:new, :supercard)
+    [mark, opts]
+  end
+
+  def absolutize_fetch_mark mark, supercard
+    return mark unless mark.is_a?(Card::Name) && supercard
+    mark.to_name.absolute_name supercard.name
+  end
+
+end
+
+public
+
+def assign_name_from_fetched_mark! mark, opts
+  return if opts[:local_only]
+  return unless mark && mark.to_s != name
+  self.name = mark.to_s
+end

data/mod/core/set/all/haml.rb

@@ -1,3 +1,16 @@
+
+#set_scope = "haml"
+
+format do
+  define_method :the_scope do
+    set_scope
+  end
+
+  define_method :haml_scope do
+    set_scope
+  end
+end
+
 format do
   # Renders haml templates. The haml template can be passed as string or
   # block or a symbol that refers to a view template.

data/mod/core/set/all/i18n.rb

@@ -1,9 +1,10 @@
-def t key, args={}
-  I18n.t key, args.merge(scope: Card::Set.scope(caller))
+
+def tr key, args={}
+  ::I18n.t key, args.merge(scope: Card::Set.scope(caller))
 end
 
 format do
-  def t key, args={}
-    I18n.t key, args.merge(scope: Card::Set.scope(caller))
+  def tr key, args={}
+    ::I18n.t key, args.reverse_merge(scope: Card::Set.scope(caller))
   end
 end

data/mod/core/set/all/mark.rb

@@ -0,0 +1,66 @@
+
+module ClassMethods
+  # translates marks (and other inputs) into a Card
+  #
+  # @param cardish [Card, Card::Name, String, Symbol, Integer]
+  # @return Card
+  def cardish cardish
+    if cardish.is_a? Card
+      cardish
+    else
+      fetch cardish, new: {}
+    end
+  end
+
+  # translates various inputs into either an id or a name.
+  #
+  # @param mark [Symbol, Integer, Card, String, or Card::Name]
+  # @return [Integer or Card::Name]
+  def id_or_name mark
+    case mark
+    when Symbol            then id_from_codename! mark
+    when Integer           then mark
+    when Card              then mark.cardname
+    when nil               then "".to_name
+    when String, Cardname  then id_or_name_from_string mark.to_s
+    # there are some situations where this breaks if we use Card::Name
+    # rather than Cardname, which would seem more correct.
+    # very hard to reproduce, not captured in a spec :(
+    end
+  end
+
+  # translates string identifiers into an id or name, including:
+  #   - string id notation (eg "~75")
+  #   - string codename notation (eg ":options")
+  #
+  # @param mark [String]
+  # @return [Integer or Card::Name]
+  def id_or_name_from_string mark
+    case mark
+    when /^\~(\d+)$/  then  Regexp.last_match[1].to_i
+    when /^\:(\w+)$/  then  id_from_codename!Regexp.last_match[1].to_sym
+    else                    mark.to_name
+    end
+  end
+
+  # @param parts [Array] of mark or mark parts
+  # @return [Integer or Card::Name]
+  def compose_mark parts
+    parts.flatten!
+    return id_or_name(parts.first) if parts.size == 1
+    parts.map do |part|
+      Card::Name.cardish id_or_name(part)
+    end.join("+").to_name
+  end
+
+  # @param codename [Symbol]
+  # @return [Integer]
+  def id_from_codename! codename
+    Card::Codename[codename] || missing_codename!
+  end
+
+  def missing_codename!
+    raise Card::Error::NotFound, "missing card with codename: #{mark}"
+  end
+
+end

data/mod/core/set/all/name.rb

@@ -2,39 +2,40 @@ require "uuid"
 
 module ClassMethods
   def uniquify_name name, rename=:new
-    return name unless Card.exists?(name)
+    return name unless Card.exists? name
+    uniq_name = generate_alternative_name name
+    return uniq_name unless rename == :old
+    rename!(name, uniq_name)
+    name
+  end
+
+  def generate_alternative_name name
     uniq_name = "#{name} 1"
     uniq_name.next! while Card.exists?(uniq_name)
-    if rename == :old
-      # name conflict resolved; original name can be used
-      Card[name].update_attributes! name: uniq_name,
-                                    update_referers: true
-      name
-    else
-      uniq_name
-    end
+    uniq_name
   end
-end
 
-def name= newname
-  cardname = newname.to_name
-  if @supercard
-    @supercard.subcards.rename key, cardname.key
-    @contextual_name = cardname.to_s
-    relparts = cardname.parts
-    if relparts.size == 2 &&
-       (relparts.first.blank? || relparts.first.to_name.key == @supercard.key)
-      @superleft = @supercard
-    end
-    cardname = cardname.to_absolute_name @supercard.name
+  def rename! oldname, newname
+    Card[oldname].update_attributes! name: newname, update_referers: true
   end
+end
 
+def name= newname
+  cardname = superize_name newname.to_name
   newkey = cardname.key
   self.key = newkey if key != newkey
   update_subcard_names cardname
   write_attribute :name, cardname.s
 end
 
+def superize_name cardname
+  return cardname unless @supercard
+  @raw_name = cardname.s
+  @supercard.subcards.rename key, cardname.key
+  @superleft = @supercard if cardname.field_of? @supercard.name
+  cardname.absolute_name @supercard.name
+end
+
 def key= newkey
   was_in_cache = Card.cache.soft.delete key
   write_attribute :key, newkey
@@ -71,6 +72,10 @@ def cardname
   name.to_name
 end
 
+def codename
+  super&.to_sym
+end
+
 def autoname name
   if Card.exists?(name) || ActManager.include?(name)
     autoname name.next
@@ -88,13 +93,13 @@ def junction?
   cardname.junction?
 end
 
-def contextual_name
-  @contextual_name || name
+def raw_name
+  @raw_name || name
 end
 
 def relative_name context_name=nil
   context_name ||= @supercard.cardname if @supercard
-  cardname.relative_name context_name
+  cardname.name_from context_name
 end
 
 def absolute_name context_name=nil
@@ -106,7 +111,7 @@ def left *args
   case
   when simple?    then nil
   when @superleft then @superleft
-  when name_changed? && name.to_name.trunk_name.key == name_was.to_name.key
+  when attribute_is_changing?(:name) && name.to_name.trunk_name.key == name_before_act.to_name.key
     nil # prevent recursion when, eg, renaming A+B to A+B+C
   else
     Card.fetch cardname.left, *args
@@ -240,36 +245,9 @@ event :set_left_and_right, :store,
   end
 end
 
-event :rename, after: :set_name, on: :update do
-  if (existing_card = Card.find_by_key_and_trash(cardname.key, true)) &&
-     existing_card != self
-    existing_card.name = existing_card.name + "*trash"
-    existing_card.rename_without_callbacks
-    existing_card.save!
-  end
-end
-
-def suspend_name name
-  # move the current card out of the way, in case the new name will require
-  # re-creating a card with the current name, ie.  A -> A+B
-  Card.expire name
-  tmp_name = "tmp:" + UUID.new.generate
-  Card.where(id: id).update_all(name: tmp_name, key: tmp_name)
-end
-
-event :cascade_name_changes, :finalize, on: :update, changed: :name do
-  des = descendants
-  @descendants = nil # reset
-
-  des.each do |de|
-    # here we specifically want NOT to invoke recursive cascades on these
-    # cards, have to go this low level to avoid callbacks.
-    Rails.logger.info "cascading name: #{de.name}"
-    Card.expire de.name # old name
-    newname = de.cardname.replace name_was, name
-    Card.where(id: de.id).update_all name: newname.to_s, key: newname.key
-    de.update_referers = update_referers
-    de.refresh_references_in
-    Card.expire newname
-  end
+event :name_change_finalized, :finalize, changed: :name, on: :save do
+  # The events to update references has to happen after :cascade_name_changes,
+  # but :cascade_name_changes is defined after the reference events and
+  # and additionaly it is defined on :update but some of the reference
+  # events are on :save. Hence we need this additional hook to organize these events.
 end

data/mod/core/set/all/permissions.rb

@@ -176,9 +176,12 @@ def ok_to_comment
   deny_because "No comments allowed on structured content" if structure
 end
 
-event :clear_read_rule, :store, on: :delete do
-  self.read_rule_id = self.read_rule_class = nil
-end
+# don't know why we introduced this
+# but we have to preserve read rules to make
+# delete acts visible in recent changes -pk
+# event :clear_read_rule, :store, on: :delete do
+#   self.read_rule_id = self.read_rule_class = nil
+# end
 
 event :set_read_rule, :store,
       on: :save, changed: %i[type_id name] do

data/mod/core/set/all/references.rb

@@ -75,7 +75,7 @@ end
 # delete references from this card
 def delete_references_out
   raise "id required to delete references" if id.nil?
-  Card::Reference.delete_all referer_id: id
+  Card::Reference.where(referer_id: id).delete_all
 end
 
 # interpretation phase helps to prevent duplicate references
@@ -138,7 +138,7 @@ event :prepare_referer_update, :validate, on: :update, changed: :name do
 end
 
 # when name changes, update references to card
-event :refresh_references_in, :finalize, on: :save, changed: :name do
+event :refresh_references_in, :finalize, on: :save, after: :name_change_finalized do
   Card::Reference.unmap_referees id if @action == :update && !update_referers
   Card::Reference.map_referees key, id
 end
@@ -156,14 +156,14 @@ end
 
 # on rename, update names in cards that refer to self by name (as directed)
 event :update_referer_content, :finalize,
-      on: :update, changed: :name,
+      on: :update, after: :name_change_finalized,
       when: proc { |card| card.update_referers } do
   # FIXME: break into correct stages
   Auth.as_bot do
     family_referers.each do |card|
       next if card == self || card.structure
       card = card.refresh
-      card.db_content = card.replace_reference_syntax name_was, name
+      card.db_content = card.replace_reference_syntax name_before_last_save, name
       card.save!
     end
   end
@@ -174,7 +174,7 @@ end
 # eg.  A links to X+Y.  if X+Y is renamed and we're not updating the link in A,
 # then we need to be sure that A has a partial reference
 event :update_referer_references_out, :finalize,
-      on: :update, changed: :name,
+      on: :update, after: :name_change_finalized,
       when: proc { |c| !c.update_referers } do
   family_referers.map(&:update_references_out)
 end

data/mod/core/set/all/rename.rb

@@ -0,0 +1,34 @@
+event :rename, after: :set_name, on: :update do
+  if (existing_card = Card.find_by_key_and_trash(cardname.key, true)) &&
+    existing_card != self
+    existing_card.name = existing_card.name + "*trash"
+    existing_card.rename_without_callbacks
+    existing_card.save!
+  end
+end
+
+def suspend_name name
+  # move the current card out of the way, in case the new name will require
+  # re-creating a card with the current name, ie.  A -> A+B
+  Card.expire name
+  tmp_name = "tmp:" + UUID.new.generate
+  Card.where(id: id).update_all(name: tmp_name, key: tmp_name)
+end
+
+event :cascade_name_changes, :finalize, on: :update, changed: :name,
+                                        before: :name_change_finalized do
+  des = descendants
+  @descendants = nil # reset
+
+  des.each do |de|
+    # here we specifically want NOT to invoke recursive cascades on these
+    # cards, have to go this low level to avoid callbacks.
+    Rails.logger.info "cascading name: #{de.name}"
+    Card.expire de.name # old name
+    newname = de.cardname.replace name_before_last_save, name
+    Card.where(id: de.id).update_all name: newname.to_s, key: newname.key
+    de.update_referers = update_referers
+    de.refresh_references_in
+    Card.expire newname
+  end
+end