card 1.16.14 → 1.16.15

data/lib/cardio.rb

@@ -20,38 +20,56 @@ module Cardio
       @@cache ||= ::Rails.cache
     end
 
-    def set_config config
-      @@config, @@root = config, config.root
+    def default_configs
+      {
+        read_only:              read_only?,
+        allow_inline_styles:    false,
 
-      config.autoload_paths += Dir["#{gem_root}/mod/*/lib/**/"]
-      config.autoload_paths += Dir["#{gem_root}/lib/**/"]
-      config.autoload_paths += Dir["#{root}/mod/*/lib/**/"]
+        recaptcha_public_key:   nil,
+        recaptcha_private_key:  nil,
+        recaptcha_proxy:        nil,
+
+        cache_store:            [:file_store, 'tmp/cache'],
+        override_host:          nil,
+        override_protocol:      nil,
+
+        no_authentication:      false,
+        files_web_path:         'files',
+
+        max_char_count:         200,
+        max_depth:              20,
+        email_defaults:         nil,
 
-      set_default_value config, :read_only,              !!ENV['WAGN_READ_ONLY']
-      set_default_value config, :allow_inline_styles,    false
+        token_expiry:           2.days,
+        revisions_per_page:     10,
+        space_last_in_multispace: true,
+        closed_search_limit:    50,
 
-      set_default_value config, :recaptcha_public_key,   nil
-      set_default_value config, :recaptcha_private_key,  nil
-      set_default_value config, :recaptcha_proxy,        nil
+        non_createable_types:   [%w{ signup setting set }],
+        view_cache:             false,
 
-      set_default_value config, :cache_store,           :file_store, 'tmp/cache'
-      set_default_value config, :override_host,          nil
-      set_default_value config, :override_protocol,      nil
+        encoding:               'utf-8',
+        request_logger:         false,
+        performance_logger:     false,
+        sql_comments:           true
+      }
+    end
 
-      set_default_value config, :no_authentication,      false
-      set_default_value config, :files_web_path,         'files'
+    def set_config config
+      @@config = config
+      @@root = config.root
 
-      set_default_value config, :max_char_count,         200
-      set_default_value config, :max_depth,              20
-      set_default_value config, :email_defaults,         nil
+      config.autoload_paths += Dir["#{gem_root}/mod/*/lib/**/"]
+      config.autoload_paths += Dir["#{gem_root}/lib/**/"]
+      config.autoload_paths += Dir["#{root}/mod/*/lib/**/"]
 
-      set_default_value config, :token_expiry,           2.days
-      set_default_value config, :revisions_per_page,     10
-      set_default_value config, :space_last_in_multispace, true
-      set_default_value config, :closed_search_limit,    50
+      default_configs.each_pair do |setting, value|
+        set_default_value(config, setting, *value)
+      end
+    end
 
-      set_default_value config, :non_createable_types,  %w{ signup setting set }
-      set_default_value config, :view_cache,             false
+    def read_only?
+      !ENV['WAGN_READ_ONLY'].nil?
     end
 
     # In production mode set_config gets called twice.
@@ -162,7 +180,7 @@ module Cardio
       root_dir = (type == :deck_cards ? root : gem_root)
       stamp_dir = ENV['SCHEMA_STAMP_PATH'] || File.join(root_dir, 'db')
 
-      File.join stamp_dir, "version#{ schema_suffix(type) }.txt"
+      File.join stamp_dir, "version#{schema_suffix type}.txt"
     end
   end
 end

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

@@ -5,7 +5,7 @@ require_dependency File.expand_path( '../reference', __FILE__ )
 module Card::Chunk
   class Include < Reference
     cattr_reader :options
-    @@options = ::Set.new [ :inc_name, :inc_syntax, :view, :items, :type, :size, :title, :hide, :show, :structure, :params ]
+    @@options = ::Set.new [ :inc_name, :inc_syntax, :view, :items, :type, :size, :title, :hide, :show, :structure, :params, :variant ]
     attr_reader :options
 
     Card::Chunk.register_class self, {

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

@@ -1,27 +1,28 @@
 
 module ClassMethods
-  def search spec
-    results = ::Card::Query.run(spec)
-    if block_given? and Array===results
+  def search spec, comment=nil
+    results = ::Card::Query.run(spec, comment)
+    if block_given? && results.is_a?(Array)
       results.each { |result| yield result }
     end
     results
   end
 
-  def count_by_wql(spec)
+  def count_by_wql spec
     spec = spec.clone
     spec.delete(:offset)
     search spec.merge(return: 'count')
   end
 
-  def find_each(options = {})
-    #this is a copy from rails (3.2.16) and is needed because this is performed by a relation (ActiveRecord::Relation)
+  def find_each options={}
+    # this is a copy from rails (3.2.16) and is needed because this
+    # is performed by a relation (ActiveRecord::Relation)
     find_in_batches(options) do |records|
       records.each { |record| yield record }
     end
   end
 
-  def find_in_batches(options = {})
+  def find_in_batches options={}
     if block_given?
       super(options) do |records|
         yield(records)
@@ -33,11 +34,11 @@ module ClassMethods
   end
 end
 
-def item_names(args={})
+def item_names _args={}
   format._render_raw.split /[,\n]/
 end
 
-def item_cards(args={})  ## FIXME this is inconsistent with item_names
+def item_cards _args={} # FIXME: this is inconsistent with item_names
   [self]
 end
 
@@ -52,39 +53,32 @@ def item_keys args={}
 end
 
 def include_item? item
-  key = if Card === item
-    item.cardname.key
-  else
-    item.to_name.key
-  end
-  item_names.map{|name| name.to_name.key}.member? key
+  key = item.is_a?(Card) ? item.cardname.key : item.to_name.key
+  item_names.map { |name| name.to_name.key }.member? key
 end
 
 def add_item item
-  unless include_item? item
-    self.content="#{self.content}\n#{name}"
-  end
+  return if include_item? item
+  self.content = "#{content}\n#{name}"
 end
 
 def drop_item item
-  if include_item? item
-    new_names = item_names.reject{ |i| i == item }
-    self.content = new_names.empty? ? '' : new_names.join("\n")
-  end
+  return unless include_item? item
+  new_names = item_names.reject { |i| i == item }
+  self.content = new_names.empty? ? '' : new_names.join("\n")
 end
 
 def insert_item index, name
   new_names = item_names
-  new_names.delete(name)
-  new_names.insert(index,name)
-  self.content =  new_names.join "\n"
+  new_names.delete name
+  new_names.insert index, name
+  self.content = new_names.join "\n"
 end
 
-
 def extended_item_cards context = nil
-  context = (context ? context.cardname : self.cardname)
-  args={ limit: '' }
-  items = self.item_cards(args.merge(context: context))
+  context = (context ? context.cardname : cardname)
+  args = { limit: '' }
+  items = item_cards(args.merge(context: context))
   extended_list = []
   already_extended = ::Set.new # avoid loops
 
@@ -103,42 +97,44 @@ def extended_item_cards context = nil
   extended_list
 end
 
-def extended_item_contents context = nil
+def extended_item_contents context=nil
   extended_item_cards(context).map(&:item_names).flatten
 end
 
-def extended_list context = nil
-  context = (context ? context.cardname : self.cardname)
-  args={ limit: '' }
-  self.item_cards(args.merge(context: context)).map do |x|
+def extended_list context=nil
+  context = (context ? context.cardname : cardname)
+  args = { limit: '' }
+  item_cards(args.merge(context: context)).map do |x|
     x.item_cards(args)
   end.flatten.map do |x|
     x.item_cards(args)
   end.flatten.map do |y|
     y.item_names(args)
   end.flatten
-  # this could go on and on.  more elegant to recurse until you don't have a collection
+  # this could go on and on.  more elegant to recurse until you don't have
+  # a collection
 end
 
 def contextual_content context_card, format_args={}, view_args={}
   context_card.format(format_args).process_content(
-    self.format(format_args)._render_raw(view_args), view_args
+    format(format_args)._render_raw(view_args), view_args
   )
 end
 
 format do
-
-  def item_links(args={})
+  def item_links _args={}
     raw(render_core).split /[,\n]/
   end
 
   def item_view args
-    args[:item] || (@inclusion_opts && @inclusion_opts[:view]) || default_item_view
+    args[:item] ||
+      (@inclusion_opts && @inclusion_opts[:view]) ||
+      default_item_view
   end
 
   def item_args args
-    i_args = { view: item_view(args)}
-    if type = card.item_type
+    i_args = { view: item_view(args) }
+    if (type = card.item_type)
       i_args[:type] = type
     end
     i_args
@@ -171,24 +167,24 @@ format do
 
   def set_search_params_variables! hash
     hash[:vars] = params[:vars] || {}
-    params.each do |key,val|
+    params.each do |key, val|
       case key.to_s
-      when '_wql'      ;  hash.merge! val
-      when /^\_(\w+)$/ ;  hash[:vars][$1.to_sym] = val
+      when '_wql'      then hash.merge! val
+      when /^\_(\w+)$/ then hash[:vars][$1.to_sym] = val
       end
     end
   end
 
-
   def each_reference_with_args args={}
-    Card::Content.new(_render_raw(args), card).find_chunks( Card::Chunk::Reference ).each do |chunk|
-      yield(chunk.referee_name.to_s, nest_args(args,chunk))
+    content_object = Card::Content.new _render_raw(args), card
+    content_object.find_chunks(Card::Chunk::Reference).each do |chunk|
+      yield chunk.referee_name.to_s, nest_args(args, chunk)
     end
   end
 
-
   def each_nested_chunk args={}
-    Card::Content.new(_render_raw(args), card).find_chunks( Card::Chunk::Include).each do |chunk|
+    content_object = Card::Content.new(_render_raw(args), card)
+    content_object.find_chunks(Card::Chunk::Include).each do |chunk|
       yield(chunk) if chunk.referee_name # filter commented nests
     end
   end
@@ -202,19 +198,21 @@ format do
   end
 
   def unique_chunks chunk, processed_set, &block
-    if !processed_set.include? chunk.referee_name.key
-      processed_set << chunk.referee_name.key
-      block.call(chunk)
-    end
+    return if processed_set.include? chunk.referee_name.key
+    processed_set << chunk.referee_name.key
+    block.call(chunk)
   end
 
   def each_nested_field args, &block
     processed_chunk_keys = ::Set.new([card.key])
 
     each_nested_chunk(args) do |chunk|
-      # TODO handle structures that are non-virtual
+      # TODO: handle structures that are non-virtual
       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)
+        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|
             unique_chunks sub_chunk, processed_chunk_keys, &block
@@ -224,7 +222,6 @@ format do
         end
       end
     end
-
   end
 
   def map_references_with_args args={}, &block
@@ -238,21 +235,19 @@ format do
   # process args for links and nests
   def nest_args args, chunk=nil
     r_args = item_args(args)
-    if @inclusion_opts
-      r_args.merge! @inclusion_opts.clone
-    end
-    if chunk.kind_of? Card::Chunk::Include
+    r_args.merge! @inclusion_opts.clone if @inclusion_opts
+
+    case chunk
+    when Card::Chunk::Include
       r_args.merge!(chunk.options)
-    elsif chunk.kind_of? Card::Chunk::Link
+    when Card::Chunk::Link
       r_args.reverse_merge!(view: :link)
       r_args.reverse_merge!(title: chunk.link_text) if chunk.link_text
     end
     r_args
   end
-
 end
 
-
 format :html do
   view :count do |args|
     card.item_names(args).size
@@ -266,11 +261,13 @@ format :html do
       id         = "#{card.cardname.safe_key}-#{name.to_name.safe_key}"
       url        = nest_path name, nest_args
       tab_name   = nest_args[:title] || name
-      tab_buttons += tab_button( "##{id}", tab_name, active_tab, 'data-url'=>url.html_safe, class: (active_tab ? nil : 'load'))
+      tab_buttons += tab_button(
+        "##{id}", tab_name, active_tab, 'data-url' => url.html_safe,
+                                        class: (active_tab ? nil : 'load'))
 
       # only render the first active tab, other tabs get loaded via ajax
       tab_content = active_tab ? nest(Card.fetch(name, new: {}), nest_args) : ''
-      tab_panes += tab_pane( id, tab_content, active_tab )
+      tab_panes += tab_pane(id, tab_content, active_tab)
       active_tab = false
     end
     tab_panel tab_buttons, tab_panes, args[:tab_type]
@@ -279,7 +276,6 @@ format :html do
     args[:tab_type] ||= 'tabs'
   end
 
-
   # create a path for a nest with respect ot the inclusion options
   def nest_path name, nest_args
     path_args = {}
@@ -299,9 +295,9 @@ format :html do
     tab_panes = ''
     card.item_cards.each_with_index do |item, index|
       id = "#{card.cardname.safe_key}-#{item.cardname.safe_key}"
-      tab_buttons += tab_button( "##{id}", item.name, index == 0 )
+      tab_buttons += tab_button("##{id}", item.name, index == 0)
       tab_content = nest item, item_args(args)
-      tab_panes += tab_pane( id, tab_content, index == 0 )
+      tab_panes += tab_pane(id, tab_content, index == 0)
     end
     tab_panel tab_buttons, tab_panes, args[:tab_type]
   end
@@ -315,24 +311,31 @@ format :html do
   end
 
   def tab_panel tab_buttons, tab_panes, tab_type='tabs'
-    wrap_with :div, role: "tabpanel" do
+    wrap_with :div, role: 'tabpanel' do
       [
-        content_tag(:ul, tab_buttons.html_safe, class: "nav nav-#{tab_type}", role: "tablist"),
+        content_tag(:ul, tab_buttons.html_safe, class: "nav nav-#{tab_type}",
+                                                role: 'tablist'),
         content_tag(:div, tab_panes.html_safe, class: 'tab-content')
       ]
     end
   end
 
   def tab_button target, text, active=false, link_attr={}
-    link = link_to fancy_title(text), target, link_attr.merge('role'=>'tab','data-toggle'=>'tab')
+    link = link_to(
+      fancy_title(text),
+      target,
+      link_attr.merge('role' => 'tab', 'data-toggle' => 'tab'))
     li_args = { role: :presentation }
     li_args[:class] = 'active' if active
     content_tag :li, link, li_args
   end
 
   def tab_pane id, content, active=false
-    div_args = {role: :tabpanel, id: id, class: "tab-pane #{'active' if active}"}
+    div_args = {
+      role: :tabpanel,
+      id: id,
+      class: "tab-pane #{'active' if active}"
+    }
     content_tag :div, content.html_safe, div_args
   end
 end
-

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

@@ -34,10 +34,6 @@ def clean_html?
   true
 end
 
-def history?
-  false
-end
-
 def save_content_draft _content
   clear_drafts
 end

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

@@ -24,23 +24,16 @@ module ClassMethods
   #
   def fetch mark, opts={}
     validate_fetch_opts! opts
-    mark = normalize_mark mark
+    mark = normalize_mark mark, opts
 
-    if mark.present?
-      card, mark, needs_caching = fetch_from_cache_or_db mark, opts
-    else
-      return unless opts[:new]
-    end
+    card, needs_caching = fetch_existing mark, opts
 
-    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))
+    if (new_card = new_for_cache card, mark, opts)
+      card = new_card
       needs_caching = true
-      card = new_for_cache mark, opts # new (or improved) card for cache
     end
 
+    return if card.nil?
     write_to_cache card, opts if needs_caching
     standard_fetch_results card, mark, opts
   end
@@ -63,11 +56,10 @@ module ClassMethods
     fetch mark, opts.merge(local_only: true)
   end
 
-  def fetch_id mark
+  def fetch_id mark, opts={}
+    mark = normalize_mark mark, opts
     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
@@ -154,34 +146,34 @@ module ClassMethods
     end
   end
 
-  def parse_mark! mark, opts
+  def parse_mark! mark
     # return mark_type, mark_value, and absolutized mark
     if mark.is_a? Integer
-      [:id, mark, mark]
+      [:id, mark]
     else
-      fullname = fullname_from_name mark, opts[:new]
-      [:key, fullname.key, fullname.s]
+      [:key, mark.key]
     end
   end
 
-  def fetch_from_cache_or_db mark, opts
-    mark_type, mark_key, mark = parse_mark! mark, opts
+  def fetch_existing mark, opts
+    return [nil, false] if !mark.present?
+    mark_type, mark_key = parse_mark! mark
     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)
+    if retrieve_from_db?(card, opts)
+      # look in db if needed
       card = fetch_from_db mark_type, mark_key, opts
-      needs_caching = card && !card.trash
+      needs_caching = !card.nil? && !card.trash
     end
 
-    [card, mark, needs_caching]
+    [card, needs_caching]
   end
 
-  def retrieve_trashed_from_db? card, opts
-    opts[:look_in_trash] && card.new_card? && !card.trash
+  def retrieve_from_db? card, opts
+    card.nil? || (opts[:look_in_trash] && card.new_card? && !card.trash)
   end
 
   def fetch_from_cache_by_id id, local_only=false
@@ -201,7 +193,10 @@ module ClassMethods
     card
   end
 
-  def new_for_cache name, opts
+  def new_for_cache card, name, opts
+    return if name.is_a? Integer
+    return if !name.present? && !opts[:new]
+    return unless !card || (card.type_unknown? && !skip_type_lookup?(opts))
     new name: name,
         skip_modules: true,
         skip_type_lookup: skip_type_lookup?(opts)
@@ -230,25 +225,23 @@ module ClassMethods
     Card.cache.write_local "~#{card.id}", card.key if card.id && card.id != 0
   end
 
-  def normalize_mark mark
+  def normalize_mark mark, opts
     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
+    when Symbol        then Card::Codename[mark]
+    when Integer       then mark.to_i
+    when String, SmartName
+      # there are some situations where this breaks if we use Card::Name
+      # rather than SmartName, which would seem more correct.
+      # very hard to reproduce, not captured in a spec :(
+      case mark.to_s
+      when /^\~(\d+)$/ then $1.to_i                   # id
+      when /^\:(\w+)$/ then Card::Codename[$1.to_sym] # codename
+      else fullname_from_mark mark, opts[:new]        # name
       end
-    when Symbol
-      Card::Codename[mark] # id from codename
-    else
-      mark
     end
   end
 
-  def fullname_from_name name, new_opts={}
+  def fullname_from_mark name, new_opts={}
     if new_opts && (supercard = new_opts[:supercard])
       name.to_name.to_absolute_name supercard.name
     else