card 1.16.13 → 1.16.14

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

@@ -1,30 +1,29 @@
 # -*- encoding : utf-8 -*-
 
-require_dependency File.expand_path( '../reference', __FILE__ )
+require_dependency File.expand_path('../reference', __FILE__)
 
 module Card::Chunk
   class Link < Reference
     attr_reader :link_text
     word = /\s*([^\]\|]+)\s*/
     # Groups: $1, [$2]: [[$1]] or [[$1|$2]] or $3, $4: [$3][$4]
-    Card::Chunk.register_class self, {
-      prefix_re: '\\[',
-      full_re:   /^\[\[([^\]]+)\]\]/,
-      idx_char:  '['
-    }
+    Card::Chunk.register_class self,
+                               prefix_re: '\\[',
+                               full_re:   /^\[\[([^\]]+)\]\]/,
+                               idx_char:  '['
 
-    def interpret match, content
+    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] ]
+          if (i = divider_index(raw_syntax))  # [[A | B]]
+            [raw_syntax[0..(i-1)], raw_syntax[(i+1)..-1]]
           else                                # [[ A ]]
-            [ raw_syntax, nil ]
+            [raw_syntax, nil]
           end
         end
 
       @link_text = objectify @link_text
-      if target =~ /\/|mailto:/
+      if target =~ %r(/|mailto:)
         @explicit_link = objectify target
       else
         @name = target
@@ -32,29 +31,25 @@ module Card::Chunk
     end
 
     def divider_index string
-      #there's probably a better way to do the following.  point is to find the first pipe that's not inside an inclusion
-
-      if string.index '|'
-        string_copy = "#{string}" # had to do this to create new string?!
-        string.scan /\{\{[^\}]*\}\}/ do |incl|
-          string_copy.gsub! incl, ('x'*incl.length)
-        end
-        string_copy.index '|'
+      # there's probably a better way to do the following.  point is to find the first pipe that's not inside an inclusion
+      return unless string.index '|'
+      string_copy = "#{string}" # had to do this to create new string?!
+      string.scan /\{\{[^\}]*\}\}/ do |incl|
+        string_copy.gsub! incl, ('x' * incl.length)
       end
+      string_copy.index '|'
     end
 
     def objectify raw
-      if raw
-        raw.strip!
-        if raw =~ /(^|[^\\])\{\{/
-          Card::Content.new raw, format
-        else
-          raw
-        end
+      return unless raw
+      raw.strip!
+      if raw =~ /(^|[^\\])\{\{/
+        Card::Content.new raw, format
+      else
+        raw
       end
     end
 
-
     def render_link
       @link_text = render_obj @link_text
 
@@ -62,7 +57,8 @@ module Card::Chunk
         @explicit_link = render_obj @explicit_link
         format.web_link @explicit_link, text: @link_text
       elsif @name
-        format.card_link referee_name, text: @link_text, known: referee_card.send_if(:known?)
+        format.card_link referee_name, text: @link_text,
+                                       known: referee_card.send_if(:known?)
       end
     end
 
@@ -71,19 +67,26 @@ module Card::Chunk
     end
 
     def inspect
-      "<##{self.class}:e[#{@explicit_link}]n[#{@name}]l[#{@link_text}] p[#{@process_chunk}] txt:#{@text}>"
+      "<##{self.class}:e[#{@explicit_link}]n[#{@name}]l[#{@link_text}]" \
+      "p[#{@process_chunk}] txt:#{@text}>"
     end
 
     def replace_reference old_name, new_name
       replace_name_reference old_name, new_name
 
-      if Card::Content===@link_text
-        @link_text.find_chunks(Card::Chunk::Reference).each { |chunk| chunk.replace_reference old_name, new_name }
-      else
-        @link_text = new_name if old_name.to_name == @link_text
+      if Card::Content === @link_text
+        @link_text.find_chunks(Card::Chunk::Reference).each do |chunk|
+          chunk.replace_reference old_name, new_name
+        end
+      elsif old_name.to_name == @link_text
+        @link_text = new_name
       end
 
-      @text = @link_text.nil? ? "[[#{referee_name.to_s}]]" : "[[#{referee_name.to_s}|#{@link_text}]]"
+      @text = if @link_text.nil?
+                "[[#{referee_name}]]"
+              else
+                "[[#{referee_name}|#{@link_text}]]"
+              end
     end
   end
 end

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

@@ -68,7 +68,7 @@ module Card::Chunk
 
     def replace_reference old_name, new_name
       replace_name_reference old_name, new_name
-      @text = "\"#{@name.to_s}\""
+      @text = "\"#{@name}\""
     end
   end
 end

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

@@ -1,9 +1,8 @@
 # = Card#fetch
 #
-# A multipurpose retrieval operator that incorporates caching, "virtual" card retrieval
-
+# A multipurpose retrieval operator that integrates caching, database lookups,
+# and "virtual" card construction
 module ClassMethods
-
   # === fetch
   #
   # looks for cards in
@@ -23,7 +22,7 @@ module ClassMethods
   #     :local_only                 Use only local cache for lookup and storing
   #     new: {  card opts }      Return a new card when not found
   #
-  def fetch mark, opts = {}
+  def fetch mark, opts={}
     validate_fetch_opts! opts
     mark = normalize_mark mark
 
@@ -43,22 +42,25 @@ module ClassMethods
     end
 
     write_to_cache card, opts if needs_caching
+    standard_fetch_results card, mark, opts
+  end
 
+  def standard_fetch_results card, mark, opts
     if card.new_card?
       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.rename_from_mark mark unless opts[:local_only]
+      card.name_from_mark! mark, opts
     end
     # need to load modules here to call the right virtual? method
     card.include_set_modules unless opts[:skip_modules]
     card if opts[:new] || card.known?
   end
 
-  def fetch_local mark, opts = {}
-    fetch mark, opts.merge(:local_only=>true)
+  def fetch_local mark, opts={}
+    fetch mark, opts.merge(local_only: true)
   end
 
   def fetch_id mark
@@ -76,7 +78,7 @@ module ClassMethods
     fetch mark, skip_virtual: true, skip_modules: true
   end
 
-  def assign_or_initialize_by name, attributes, fetch_opts = {}
+  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
@@ -99,24 +101,24 @@ module ClassMethods
     card.present?
   end
 
-  def expire name, subcards = false
+  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 subcards
-        card.expire_subcards
-      else
-        card.preserve_subcards
-      end
-      Card.cache.delete key
-      Card.cache.delete "~#{card.id}" if card.id
+    return unless (card = Card.cache.read key)
+    if subcards
+      card.expire_subcards
+    else
+      card.preserve_subcards
     end
-    # Rails.logger.warn "expiring #{name}, #{card.inspect}"
+    Card.cache.delete key
+    Card.cache.delete "~#{card.id}" if card.id
   end
 
   # set_names reverse map (cached)
-  def members key
-    (v=Card.cache.read "$#{key}").nil? ? [] : v.keys
+  # FIXME: move to set handling
+  def cached_set_members key
+    set_cache_list = Card.cache.read "$#{key}"
+    set_cache_list.nil? ? [] : set_cache_list.keys
   end
 
   def set_members set_names, key
@@ -135,9 +137,8 @@ module ClassMethods
   end
 
   def validate_fetch_opts! opts
-    if opts[:new] && opts[:skip_virtual]
-      fail Card::Error, 'fetch called with new args and skip_virtual'
-    end
+    return unless opts[:new] && opts[:skip_virtual]
+    fail Card::Error, 'fetch called with new args and skip_virtual'
   end
 
   def cache
@@ -145,45 +146,59 @@ module ClassMethods
   end
 
   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
+    return unless Card.cache
+    if local_only
+      Card.cache.read_local cache_key
+    else
+      Card.cache.read cache_key
+    end
+  end
+
+  def parse_mark! mark, opts
+    # return mark_type, mark_value, and absolutized mark
+    if mark.is_a? Integer
+      [:id, mark, mark]
+    else
+      fullname = fullname_from_name mark, opts[:new]
+      [:key, fullname.key, fullname.s]
     end
   end
 
   def fetch_from_cache_or_db mark, opts
-    needs_caching = false
-    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
+    mark_type, mark_key, mark = parse_mark! mark, opts
+    needs_caching = false # until proven true :)
+
+    # look in cache
+    card = send "fetch_from_cache_by_#{mark_type}", mark_key, opts[:local_only]
+
+    # if that doesn't work, look in db
+    if card.nil? || retrieve_trashed_from_db?(card, opts)
+      card = fetch_from_db mark_type, mark_key, opts
       needs_caching = card && !card.trash
-      card.restore_subcards if card
     end
 
     [card, mark, needs_caching]
   end
 
-  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
+  def retrieve_trashed_from_db? card, opts
+    opts[:look_in_trash] && card.new_card? && !card.trash
+  end
+
+  def fetch_from_cache_by_id id, local_only=false
+    name = fetch_from_cache "~#{id}", local_only
+    fetch_from_cache name, local_only if name
   end
 
-  def fetch_from_cache_by_key key, local_only = false
+  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
+  def fetch_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.restore_subcards if card
+    card
   end
 
   def new_for_cache name, opts
@@ -197,7 +212,7 @@ module ClassMethods
     # 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_virtual] || opts[:new].present? || opts[:skip_type_lookup]
   end
 
   def write_to_cache card, opts
@@ -215,14 +230,6 @@ module ClassMethods
     Card.cache.write_local "~#{card.id}", card.key if card.id && card.id != 0
   end
 
-  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
@@ -242,7 +249,7 @@ module ClassMethods
   end
 
   def fullname_from_name name, new_opts={}
-    if new_opts && supercard = new_opts[:supercard]
+    if new_opts && (supercard = new_opts[:supercard])
       name.to_name.to_absolute_name supercard.name
     else
       name.to_name
@@ -304,7 +311,8 @@ def type_unknown?
   type_id.nil?
 end
 
-def rename_from_mark mark
+def name_from_mark! mark, opts
+  return if opts[:local_only]
   return unless mark && mark.to_s != name
   self.name = mark.to_s
 end

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

@@ -1,15 +1,15 @@
 
-Card.error_codes.merge! permission_denied: [:denial, 403], captcha: [:errors,449]
-
+Card.error_codes.merge! permission_denied: [:denial, 403],
+                        captcha: [:errors, 449]
 
 # ok? and ok! are public facing methods to approve one action at a time
 #
 #   fetching: if the optional :trait parameter is supplied, it is passed
 #      to fetch and the test is perfomed on the fetched card, therefore:
 #
-#      trait: :account         would fetch this card plus a tag codenamed :account
-#      trait: :roles, new: {} would initialize a new card with default ({}) options.
-
+#      trait: :account      would fetch this card plus a tag codenamed :account
+#      trait: :roles, new: {} would initialize a new card with default ({})
+# options.
 
 def ok? action
   @action_ok = true
@@ -21,31 +21,35 @@ def ok_with_fetch? action, opts={}
   card = opts[:trait].nil? ? self : fetch(opts)
   card && card.ok_without_fetch?(action)
 end
-alias_method_chain :ok?, :fetch # note: method is chained so that we can return the instance variable @action_ok
 
+# note: method is chained so that we can return the instance variable @action_ok
+alias_method_chain :ok?, :fetch
 
 def ok! action, opts={}
   raise Card::PermissionDenied.new self unless ok? action, opts
 end
 
 def who_can action
-  #warn "who_can[#{name}] #{(prc=permission_rule_card(action)).inspect}, #{prc.first.item_cards.map(&:id)}" if action == :update
+  # warn "who_can[#{name}] #{(prc=permission_rule_card(action)).inspect},
+  # #{prc.first.item_cards.map(&:id)}" if action == :update
   permission_rule_card(action).first.item_cards.map &:id
 end
 
-
 def permission_rule_card action
   opcard = rule_card action
 
-  unless opcard # RULE missing.  should not be possible.  generalize this to handling of all required rules
+  # RULE missing.  should not be possible.
+  # generalize this to handling of all required rules
+  unless opcard
     errors.add :permission_denied, "No #{action} rule for #{name}"
     raise Card::PermissionDenied.new(self)
   end
 
   rcard = Auth.as_bot do
-    if ['_left','[[_left]]'].member?(opcard.db_content) && self.junction?  # compound cards can inherit permissions from left parent
-      lcard = left_or_new( skip_virtual: true, skip_modules: true )
-      if action==:create && lcard.real? && !lcard.action==:create
+    # compound cards can inherit permissions from left parent
+    if ['_left', '[[_left]]'].member?(opcard.db_content) && self.junction?
+      lcard = left_or_new(skip_virtual: true, skip_modules: true)
+      if action == :create && lcard.real? && !lcard.action == :create
         action = :update
       end
       lcard.permission_rule_card(action).first
@@ -64,67 +68,61 @@ def you_cant what
   "You don't have permission to #{what}"
 end
 
-
 def deny_because why
   @permission_errors << why if @permission_errors
   @action_ok = false
 end
 
 def permitted? action
+  return if Card.config.read_only
+  return true if action != :comment and Auth.always_ok?
 
-  if !Card.config.read_only
-    return true if action != :comment and Auth.always_ok?
-
-    permitted_ids = who_can action
-    if action == :comment && Auth.always_ok?
-      # admin can comment if anyone can
-      !permitted_ids.empty?
-    else
-      Auth.among? permitted_ids
-    end
+  permitted_ids = who_can action
+  if action == :comment && Auth.always_ok?
+    # admin can comment if anyone can
+    !permitted_ids.empty?
+  else
+    Auth.among? permitted_ids
   end
 end
 
 def permit action, verb=nil
-
   if Card.config.read_only # not called by ok_to_read
-    deny_because "Currently in read-only mode"
+    deny_because 'Currently in read-only mode'
   end
 
+  return if permitted? action
   verb ||= action.to_s
-  unless permitted? action
-    deny_because you_cant("#{verb} #{name.present? ? name : 'this'}")
-  end
+  deny_because you_cant("#{verb} #{name.present? ? name : 'this'}")
 end
 
 def ok_to_create
   permit :create
-  if @action_ok and junction?
-    [:left, :right].each do |side|
-      next if side==:left && @superleft   # left is supercard; create permissions will get checked there.
-      part_card = send side, new: {}
-      if part_card && part_card.new_card? # if no card, there must be other errors
-        unless part_card.ok? :create
-          deny_because you_cant("create #{part_card.name}")
-        end
+  return if !@action_ok || !junction?
+
+  [:left, :right].each do |side|
+    # left is supercard; create permissions will get checked there.
+    next if side == :left && @superleft
+    part_card = send side, new: {}
+    if part_card && part_card.new_card? # if no card, there must be other errors
+      unless part_card.ok? :create
+        deny_because you_cant("create #{part_card.name}")
       end
     end
   end
 end
 
 def ok_to_read
-  if !Auth.always_ok?
-    @read_rule_id ||= permission_rule_card(:read).first.id.to_i
-    if !Auth.as_card.read_rules.member? @read_rule_id
-      deny_because you_cant "read this"
-    end
-  end
+  return if Auth.always_ok?
+  @read_rule_id ||= permission_rule_card(:read).first.id.to_i
+  return if Auth.as_card.read_rules.member? @read_rule_id
+  deny_because you_cant 'read this'
 end
 
 def ok_to_update
   permit :update
-  if @action_ok and type_id_changed? and !permitted? :create
-    deny_because you_cant( "change to this type (need create permission)" )
+  if @action_ok && type_id_changed? && !permitted?(:create)
+    deny_because you_cant('change to this type (need create permission)')
   end
   ok_to_read if @action_ok
 end
@@ -135,13 +133,11 @@ end
 
 def ok_to_comment
   permit :comment, 'comment on'
-  if @action_ok
-    deny_because "No comments allowed on templates" if is_template?
-    deny_because "No comments allowed on structured content" if structure
-  end
+  return unless @action_ok
+  deny_because 'No comments allowed on templates' if is_template?
+  deny_because 'No comments allowed on structured content' if structure
 end
 
-
 event :set_read_rule, before: :store do
   if trash == true
     self.read_rule_id = self.read_rule_class = nil
@@ -150,7 +146,8 @@ event :set_read_rule, before: :store do
     rcard, rclass = permission_rule_card(:read)
     self.read_rule_id = rcard.id
     self.read_rule_class = rclass
-    #find all cards with me as trunk and update their read_rule (because of *type plus right)
+    # find all cards with me as trunk and update their read_rule
+    # (because of *type plus right)
     # skip if name is updated because will already be resaved
 
     if !new_card? && type_id_changed?
@@ -168,16 +165,18 @@ def update_read_rule
 
   reset_patterns # why is this needed?
   rcard, rclass = permission_rule_card :read
-  self.read_rule_id = rcard.id #these two are just to make sure vals are correct on current object
-  #warn "updating read rule for #{inspect} to #{rcard.inspect}, #{rclass}"
+  # these two are just to make sure vals are correct on current object
+  self.read_rule_id = rcard.id
+  # warn "updating read rule for #{inspect} to #{rcard.inspect}, #{rclass}"
 
   self.read_rule_class = rclass
-  Card.where(id: self.id).update_all(read_rule_id: rcard.id, read_rule_class: rclass)
+  Card.where(id: id).update_all read_rule_id: rcard.id, read_rule_class: rclass
   expire
 
-  # currently doing a brute force search for every card that may be impacted.  may want to optimize(?)
+  # currently doing a brute force search for every card that may be impacted.
+  # may want to optimize(?)
   Auth.as_bot do
-    Card.search(left: self.name).each do |plus_card|
+    Card.search(left: name).each do |plus_card|
       if plus_card.rule(:read) == '_left'
         plus_card.update_read_rule
       end
@@ -192,13 +191,13 @@ def add_to_read_rule_update_queue updates
   @read_rule_update_queue = Array.wrap(@read_rule_update_queue).concat updates
 end
 
-
 event :check_permissions, after: :approve do
-  task = if @action != :delete && comment #will be obviated by new comment handling
-    :comment
-  else
-    @action
-  end
+  task =
+    if @action != :delete && comment # will be obviated by new comment handling
+      :comment
+    else
+      @action
+    end
   track_permission_errors do
     ok? task
   end
@@ -216,19 +215,22 @@ def track_permission_errors
   result
 end
 
-
 def recaptcha_on?
   have_recaptcha_keys? &&
-  Env[:controller]     &&
-  !Auth.signed_in?     &&
-  !Auth.needs_setup?   &&
-  !Auth.always_ok?     &&
-  Card.toggle( rule :captcha )
+    Env[:controller]   &&
+    !Auth.signed_in?   &&
+    !Auth.needs_setup? &&
+    !Auth.always_ok?   &&
+    Card.toggle(rule :captcha)
 end
 
 def have_recaptcha_keys?
-  @@have_recaptcha_keys = defined?(@@have_recaptcha_keys) ? @@have_recaptcha_keys :
-    !!( Card.config.recaptcha_public_key && Card.config.recaptcha_private_key )
+  @@have_recaptcha_keys =
+    if defined?(@@have_recaptcha_keys)
+      @@have_recaptcha_keys
+    else
+      !!(Card.config.recaptcha_public_key && Card.config.recaptcha_private_key)
+    end
 end
 
 event :recaptcha, before: :approve do
@@ -239,21 +241,23 @@ event :recaptcha, before: :approve do
 end
 
 module Accounts
-  # This is a short-term hack that is used in account-related cards to allow a permissions pattern where
-  # permissions are restricted to the owner of the account (and, by default, Admin)
-  # That pattern should be permitted by our card representation (without creating
-  # separate rules for each account holder) but is not yet.
+  # This is a short-term hack that is used in account-related cards to allow a
+  # permissions pattern where permissions are restricted to the owner of the
+  # account (and, by default, Admin)
+  # That pattern should be permitted by our card representation
+  # (without creating separate rules for each account holder) but is not yet.
 
   def permit action, verb=nil
     case
-    when action==:comment  ; @action_ok = false
-    when action==:create   ; @superleft ? true : super( action, verb )
-      #restricts account creation to subcard handling on permitted card (unless explicitly permitted)
-    when is_own_account?   ; true
-    else                   ; super action, verb
+    when action == :comment then @action_ok = false
+    when action == :create  then @superleft ? true : super(action, verb)
+      # restricts account creation to subcard handling on permitted card
+      # (unless explicitly permitted)
+    when own_account? then true
+    else
+      super action, verb
     end
   end
-
 end
 
 module Follow
@@ -271,13 +275,10 @@ module Follow
 
   def permit action, verb=nil
     if [:create, :delete, :update].include?(action) && Auth.signed_in? &&
-        (user = rule_user) && Auth.current_id == user.id
+       (user = rule_user) && Auth.current_id == user.id
       return true
     else
       super action, verb
     end
   end
-
 end
-
-