card 1.16.15 → 1.17.0

data/spec/lib/card/reference_spec.rb

@@ -1,7 +1,6 @@
 # -*- encoding : utf-8 -*-
 
 describe Card::Reference do
-
   before do
     Card::Auth.current_id = Card::WagnBotID
   end
@@ -11,47 +10,38 @@ describe Card::Reference do
       Card.create! name: 'JoeForm', type: 'UserForm'
       Card['JoeForm'].format.render(:core)
       assert_equal ['joe_form+age', 'joe_form+description', 'joe_form+name'],
-        Card['JoeForm'].includees.map(&:key).sort
-      expect(Card['JoeForm'].references_expired).not_to eq(true)
+                   Card['JoeForm'].includees.map(&:key).sort
     end
 
     it 'on template creation' do
       Card.create! name: 'SpecialForm', type: 'Cardtype'
       Card.create! name: 'Form1', type: 'SpecialForm', content: 'foo'
-      c = Card['Form1']
-      expect(c.references_expired).to be_nil
       Card.create! name: 'SpecialForm+*type+*structure', content: '{{+bar}}'
-      c = Card['Form1']
-      expect(c.references_expired).to be_truthy
       Card['Form1'].format.render(:core)
-      c = Card['Form1']
-      expect(c.references_expired).to be_nil
       expect(Card['Form1'].includees.map(&:key)).to eq(['form1+bar'])
     end
 
     it 'on template update' do
       Card.create! name: 'JoeForm', type: 'UserForm'
       tmpl = Card['UserForm+*type+*structure']
-      tmpl.content = '{{+monkey}} {{+banana}} {{+fruit}}';
+      tmpl.content = '{{+monkey}} {{+banana}} {{+fruit}}'
       tmpl.save!
-      expect(Card['JoeForm'].references_expired).to be_truthy
       Card['JoeForm'].format.render(:core)
       assert_equal ['joe_form+banana', 'joe_form+fruit', 'joe_form+monkey'],
-        Card['JoeForm'].includees.map(&:key).sort
-      expect(Card['JoeForm'].references_expired).not_to eq(true)
+                   Card['JoeForm'].includees.map(&:key).sort
     end
   end
 
   it 'in references should survive cardtype change' do
-    newcard('Banana','[[Yellow]]')
-    newcard('Submarine','[[Yellow]]')
-    newcard('Sun','[[Yellow]]')
-    newcard('Yellow')
+    newcard 'Banana', '[[Yellow]]'
+    newcard 'Submarine', '[[Yellow]]'
+    newcard 'Sun', '[[Yellow]]'
+    newcard 'Yellow'
     yellow_refs = Card['Yellow'].referencers.map(&:name).sort
     expect(yellow_refs).to eq(%w{ Banana Submarine Sun })
 
-    y=Card['Yellow'];
-    y.type_id= Card.fetch_id 'UserForm';
+    y = Card['Yellow']
+    y.type_id = Card.fetch_id 'UserForm'
     y.save!
 
     yellow_refs = Card['Yellow'].referencers.map(&:name).sort
@@ -75,13 +65,13 @@ describe Card::Reference do
   end
 
   it 'should update references on rename when requested' do
-    watermelon = newcard('watermelon', 'mmmm')
-    watermelon_seeds = newcard('watermelon+seeds', 'black')
+    newcard 'watermelon', 'mmmm'
+    newcard 'watermelon+seeds', 'black'
     lew = newcard('Lew', 'likes [[watermelon]] and [[watermelon+seeds|seeds]]')
 
     watermelon = Card['watermelon']
     watermelon.update_referencers = true
-    watermelon.name='grapefruit'
+    watermelon.name = 'grapefruit'
     watermelon.save!
     result = 'likes [[grapefruit]] and [[grapefruit+seeds|seeds]]'
     expect(lew.reload.content).to eq(result)
@@ -90,25 +80,22 @@ describe Card::Reference do
   it 'should update referencers on rename when requested (case 2)' do
     card = Card['Administrator Menu+*self+*read']
     old_refs = Card::Reference.where(referee_id: Card::AdministratorID)
-    old_referers = old_refs.map(&:referer_id).sort
 
     card.update_referencers = true
-    card.name='Administrator Menu+*type+*read'
+    card.name = 'Administrator Menu+*type+*read'
     card.save
 
     new_refs = Card::Reference.where(referee_id: Card::AdministratorID)
-    new_referers = new_refs.map(&:referer_id).sort
     expect(old_refs).to eq(new_refs)
   end
 
   it 'should not update references when not requested' do
-
-    watermelon = newcard('watermelon', 'mmmm')
-    watermelon_seeds = newcard('watermelon+seeds', 'black')
+    newcard 'watermelon', 'mmmm'
+    newcard 'watermelon+seeds', 'black'
     lew = newcard('Lew', 'likes [[watermelon]] and [[watermelon+seeds|seeds]]')
 
     assert_equal [1, 1, 1, 1], lew.references_to.map(&:present),
-      'links should not be Wanted before'
+                 'links should not be Wanted before'
 
     watermelon = Card['watermelon']
     watermelon.update_referencers = false
@@ -118,21 +105,21 @@ describe Card::Reference do
     expect(lew.reload.content).to eq(correct_content)
 
     ref_types = lew.references_to.order(:id).map(&:ref_type)
-    assert_equal ref_types, ['L','P','P','L'], 'links should be a LINK'
+    assert_equal ref_types, ['L', 'P', 'P', 'L'], 'links should be a LINK'
     refs_are_present = lew.references_to.order(:id).map(&:present)
     assert_equal refs_are_present, [0, 0, 1, 0],
-      'only reference to +seeds should be present'
+                 'only reference to +seeds should be present'
   end
 
   it 'update referencing content on rename junction card' do
-    @ab = Card['A+B'] #linked to from X, included by Y
+    @ab = Card['A+B'] # linked to from X, included by Y
     @ab.update_attributes! name: 'Peanut+Butter', update_referencers: true
     @x = Card['X']
     expect(@x.content).to eq('[[A]] [[Peanut+Butter]] [[T]]')
   end
 
   it 'update referencing content on rename junction card' do
-    @ab = Card['A+B'] #linked to from X, included by Y
+    @ab = Card['A+B'] # linked to from X, included by Y
     @ab.update_attributes! name: 'Peanut+Butter', update_referencers: false
     @x = Card['X']
     expect(@x.content).to eq('[[A]] [[A+B]] [[T]]')
@@ -142,7 +129,7 @@ describe Card::Reference do
     Card.create! name: 'ColorType', type: 'Cardtype', content: ''
     Card.create! name: 'ColorType+*type+*structure', content: '{{+rgb}}'
     green = Card.create! name: 'green', type: 'ColorType'
-    rgb = newcard 'rgb'
+    newcard 'rgb'
     green_rgb = Card.create! name: 'green+rgb', content: '#00ff00'
 
     expect(green.reload.includees.map(&:name)).to eq(['green+rgb'])
@@ -163,7 +150,6 @@ describe Card::Reference do
     expect(Card['alpha card'].referencers.map(&:name)).to eq(['beta card'])
   end
 
-
   it 'simple inclusion' do
     Card.create name: 'alpha'
     Card.create name: 'beta', content: 'I nest {{alpha}}'
@@ -188,7 +174,7 @@ describe Card::Reference do
     expect(y_referencers).to include('search with references')
 
     search_referees = Card['search with references'].referees.map(&:name).sort
-    expect(search_referees).to eq ['A','B','X','Y']
+    expect(search_referees).to eq(%w{ A B X Y })
   end
 
   it 'handles contextual names in Basic cards' do
@@ -208,7 +194,6 @@ describe Card::Reference do
     expect(c.errors.any?).to be_falsey
   end
 
-
   it 'pickup new links on create' do
     @l = newcard('woof', '[[Lewdog]]')  # no Lewdog card yet...
     @e = newcard('Lewdog')              # now there is
@@ -223,5 +208,4 @@ describe Card::Reference do
     # now it's inititated
     expect(@e.name_referencers.map(&:name).include?('woof')).not_to eq(nil)
   end
-
 end

data/spec/lib/card/subcards_spec.rb

@@ -111,6 +111,16 @@ describe Card::Subcards do
       @card._add_subfield :phrase, content: 'this is a sub'
       expect(@card.subfield(':phrase').content).to eq 'this is a sub'
     end
+
+    it 'works together with type change' do
+      Card::Auth.as_bot do
+        @card = Card.create!(
+          name: 'card with subs', '+sub1' => 'first'
+        )
+        @card.update_attributes! type_id: Card::PhraseID, '+sub1' => 'second'
+      end
+      expect(Card['card with subs+sub1'].content).to eq 'second'
+    end
   end
 
   describe '#add' do
@@ -123,4 +133,32 @@ describe Card::Subcards do
       expect(Card['sub'].content).to eq 'sub content'
     end
   end
+  describe 'two levels of subcards' do
+    it 'creates cards with subcards with subcards' do
+      Card::Auth.as_bot do
+        in_phase before: :approve, trigger: -> {
+          Card.create! name: 'test'
+        } do
+          if name == 'test'
+            add_subfield('first-level')
+            subfield('first-level').add_subfield 'second-level', content: 'yeah'
+          end
+        end
+      end
+      expect(Card.fetch('test+first-level+second-level').content).to eq 'yeah'
+    end
+    it 'creates cards with subcards with subcards using codenames' do
+      Card::Auth.as_bot do
+        in_phase before: :approve, trigger: -> {
+          Card.create! name: 'test'
+        } do
+          if name == 'test'
+            add_subfield :children
+            subfield(:children).add_subfield :title, content: 'yeah'
+          end
+        end
+      end
+      expect(Card.fetch('test+*child+*title').content).to eq 'yeah'
+    end
+  end
 end

data/spec/lib/card/view_cache_spec.rb

@@ -0,0 +1,8 @@
+describe Card::ViewCache do
+  it 'gets cleared by Card::Cache.reset_all' do
+    Card::ViewCache.cache.write 'testkey', 1
+    expect(Card::ViewCache.cache.exist? 'testkey').to be_truthy
+    Card::Cache.reset_all
+    expect(Card::ViewCache.cache.exist? 'testkey').to be_falsey
+  end
+end

data/spec/spec_helper.rb

@@ -33,7 +33,7 @@ Spork.prefork do
     config.include RSpec::Rails::Matchers::RoutingMatchers,  {
       file_path: /\bspec\/controllers\//
     }
-
+    config.include RSpecHtmlMatchers
     # format_index = ARGV.find_index {|arg| arg =~ /--format|-f/ }
     # formatter = format_index ? ARGV[ format_index + 1 ] : 'documentation' #'textmate'
     # config.default_formatter=formatter

data/tmpsets/set/mod001-01_core/all/collection.rb

@@ -3,32 +3,33 @@ class Card; module Set; module All; module Collection; extend Card::Set
 # ~~~~~~~~~~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/01_core/set/all/collection.rb ~~~~~~~~~~~
 
 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)
-        Card::Cache.reset_global
+        Card::Cache.reset_all
       end
     else
       super(options)
@@ -36,11 +37,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
 
@@ -55,39 +56,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
 
@@ -106,42 +100,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
@@ -174,24 +170,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
@@ -205,19 +201,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
@@ -227,7 +225,6 @@ format do
         end
       end
     end
-
   end
 
   def map_references_with_args args={}, &block
@@ -241,21 +238,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
@@ -269,11 +264,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]
@@ -282,7 +279,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 = {}
@@ -302,9 +298,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
@@ -318,28 +314,35 @@ 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
 
 
-
 # ~~~~~~~~~~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/01_core/set/all/collection.rb ~~~~~~~~~~~
 end;end;end;end;