card 1.16.15 → 1.17.0

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

@@ -1,6 +1,5 @@
 
 module ClassMethods
-
   def empty_trash
     Card.delete_trashed_files
     Card.where(trash: true).delete_all
@@ -10,25 +9,39 @@ module ClassMethods
     Card.delete_tmp_files_of_cached_uploads
   end
 
-  def delete_trashed_files #deletes any file not associated with a real card.
-    dir = Card.paths['files'].existent.first
-    trashed_card_sql = %{ select id from cards where trash is true }
-    trashed_card_ids = Card.connection.select_all( trashed_card_sql ).map( &:values ).flatten.map &:to_i
-    file_ids = Dir.entries( dir )[2..-1].map( &:to_i )
+  # deletes any file not associated with a real card.
+  def delete_trashed_files
+    trashed_card_ids = all_trashed_card_ids
+    file_ids = all_file_ids
     file_ids.each do |file_id|
       if trashed_card_ids.member?(file_id)
-        raise Card::Error, "Narrowly averted deleting current file" if Card.exists?(file_id) #double check!
+        if Card.exists?(file_id) # double check!
+          fail Card::Error, 'Narrowly averted deleting current file'
+        end
         FileUtils.rm_rf "#{dir}/#{file_id}", secure: true
       end
     end
   end
 
+  def all_file_ids
+    dir = Card.paths['files'].existent.first
+    Dir.entries(dir)[2..-1].map(&:to_i)
+  end
+
+  def all_trashed_card_ids
+    trashed_card_sql = %{ select id from cards where trash is true }
+    sql_results = Card.connection.select_all(trashed_card_sql)
+    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"
+      WHERE cards.type_id IN (#{Card::FileID}, #{Card::ImageID})
+      AND card_actions.draft = true"
     actions.each do |action|
-      if older_than_five_days?(action.created_at) && card = action.card # 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
@@ -39,31 +52,31 @@ module ClassMethods
     attribs.each do |row|
       result = begin
         merge row['name'], row, opts
-#      rescue => e
-#        Rails.logger.info "merge_list problem: #{ e.message }"
-#        false
       end
       unmerged.push row unless result == true
     end
 
     if unmerged.empty?
-      Rails.logger.info "successfully merged all!"
+      Rails.logger.info 'successfully merged all!'
     else
       unmerged_json = JSON.pretty_generate unmerged
-      if output_file = opts[:output_file]
-        ::File.open output_file, 'w' do |f|
-          f.write unmerged_json
-        end
-      else
-        Rails.logger.info "failed to merge:\n\n#{ unmerged_json }"
-      end
+      report_unmerged_json unmerged_json, opts[:output_file]
     end
     unmerged
   end
 
+  def report_unmerged_json unmerged_json, output_file
+    if output_file
+      ::File.open output_file, 'w' do |f|
+        f.write unmerged_json
+      end
+    else
+      Rails.logger.info "failed to merge:\n\n#{unmerged_json}"
+    end
+  end
 
   def merge name, attribs={}, opts={}
-    puts "merging #{ name }"
+    puts "merging #{name}"
     card = fetch name, new: {}
 
     if opts[:pristine] && !card.pristine?
@@ -74,64 +87,60 @@ module ClassMethods
     end
   end
 
-
   def older_than_five_days? time
     Time.now - time > 432000
   end
-
 end
 
 def debug_type
-  "#{type_code||'no code'}:#{type_id}"
+  "#{type_code || 'no code'}:#{type_id}"
 end
 
 def to_s
-  "#<#{self.class.name}[#{debug_type}]#{self.attributes['name']}>"
+  "#<#{self.class.name}[#{debug_type}]#{attributes['name']}>"
 end
 
 def inspect
-  "#<#{self.class.name}" + "##{id}" +
-  "###{object_id}" + #"l#{left_id}r#{right_id}" +
-  "[#{debug_type}]" + "(#{self.name})" + #"#{object_id}" +
-  #(errors.any? ? '*Errors*' : 'noE') +
-  (errors.any? ? "<E*#{errors.full_messages*', '}*>" : '') +
-  #"{#{references_expired==1 ? 'Exp' : "noEx"}:" +
-  "{#{trash&&'trash:'||''}#{new_card? &&'new:'||''}#{frozen? ? 'Fz' : readonly? ? 'RdO' : ''}" +
-  "#{@virtual &&'virtual:'||''}#{@set_mods_loaded&&'I'||'!loaded' }:#{references_expired.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
 
 format :html do
-  view :views_by_format do |args|
-    format_views = self.class.ancestors.each_with_object({}) do |format_class, hash|
-      views =
-        format_class.instance_methods.map do |method|
-          if method.to_s.match /^_view_(.+)$/
-            "<li>#{$1}</li>"
-          end
-        end.compact.join "\n"
-      if views.present?
-        format_class.name.match /^Card(::Set)?::(.+?)$/ #::(\w+Format)
-        hash[$2] = views
+  view :views_by_format do
+    format_views =
+      self.class.ancestors.each_with_object({}) do |format_class, hash|
+        views =
+          format_class.instance_methods.map do |method|
+            if method.to_s.match(/^_view_(.+)$/)
+              "<li>#{$1}</li>"
+            end
+          end.compact.join "\n"
+        if views.present?
+          format_class.name.match(/^Card(::Set)?::(.+?)$/) #::(\w+Format)
+          hash[$2] = views
+        end
       end
-    end
     accordion_group format_views
   end
 
-  view :views_by_name do |args|
+  view :views_by_name do
     views = methods.map do |method|
-      if method.to_s.match /^_view_(.+)$/
+      if method.to_s.match(/^_view_(.+)$/)
         $1
       end
     end.compact.sort
-    "<ul>
-    #{ wrap_each_with :li, views }
-    </ul>"
+    "<ul>#{wrap_each_with :li, views}</ul>"
   end
 
-
-
-
   def accordion_group list, collapse_id=card.cardname.safe_key
     accordions = ''
     index = 1
@@ -139,35 +148,37 @@ format :html do
       accordions << accordion(title, content, "#{collapse_id}-#{index}")
       index += 1
     end
-    content_tag :div, accordions.html_safe, class: "panel-group", id: "accordion-#{collapse_id}", role: "tablist", 'aria-multiselectable'=>"true"
+    content_tag :div, accordions.html_safe, class: 'panel-group',
+                                            id: "accordion-#{collapse_id}",
+                                            role: 'tablist',
+                                            'aria-multiselectable' => 'true'
   end
 
   def accordion title, content, collapse_id=card.cardname.safe_key
     panel_body =
       case content
-      when Hash
-        accordion_group accordion(content, collapse_id)
-      when Array
-        content.join "\n"
-      else
-        content
+      when Hash  then accordion_group accordion(content, collapse_id)
+      when Array then content.join "\n"
+      else            content
       end
     %{
       <div class="panel panel-default">
         <div class="panel-heading" role="tab" id="heading-#{collapse_id}">
           <h4 class="panel-title">
-            <a data-toggle="collapse" data-parent="#accordion-#{collapse_id}" href="##{collapse_id}" aria-expanded="true" aria-controls="#{collapse_id}">
-              #{ title }
+            <a data-toggle="collapse" data-parent="#accordion-#{collapse_id}" \
+              href="##{collapse_id}" aria-expanded="true" \
+              aria-controls="#{collapse_id}">
+              #{title}
             </a>
           </h4>
         </div>
-        <div id="#{collapse_id}" class="panel-collapse collapse" role="tabpanel" aria-labelledby="heading-#{collapse_id}">
+        <div id="#{collapse_id}" class="panel-collapse collapse" \
+          role="tabpanel" aria-labelledby="heading-#{collapse_id}">
           <div class="panel-body">
-            #{ panel_body }
+            #{panel_body}
           </div>
         </div>
       </div>
       }.html_safe
   end
 end
-

data/mod/01_core/set_pattern/07_type_plus_right.rb

@@ -9,15 +9,18 @@ def label name
 end
 
 def prototype_args anchor
-  { name: "+#{anchor.tag}", supercard: Card.new( name: '*dummy', type: anchor.trunk_name ) }
+  {
+    name: "+#{anchor.tag}",
+    supercard: Card.new(name: '*dummy', type: anchor.trunk_name)
+  }
 end
 
 def anchor_name card
   left = card.left
-  type_name = (left && left.type_name) || Card[ Card.default_type_id ].name
+  type_name = (left && left.type_name) || Card[Card.default_type_id].name
   "#{type_name}+#{card.cardname.tag}"
 end
 
 def follow_label name
-  %{all  "+#{name.to_name.tag}" on "#{name.to_name.left_name}s"}
+  %{all "+#{name.to_name.tag}" on "#{name.to_name.left_name}s"}
 end

data/mod/01_core/spec/set/all/fetch_spec.rb

@@ -10,196 +10,248 @@ describe Card::Set::All::Fetch do
       expect(Card.fetch('A')).to be_instance_of(Card)
     end
 
-    it "returns nil and caches missing cards" do
-      expect(Card.fetch("Zork")).to be_nil
-      expect(Card.cache.read("zork").new_card?).to be_truthy
-      expect(Card.fetch("Zork")).to be_nil
+    it 'returns nil and caches missing cards' do
+      expect(Card.fetch('Zork')).to be_nil
+      expect(Card.cache.read('zork').new_card?).to be_truthy
+      expect(Card.fetch('Zork')).to be_nil
     end
 
-    it "returns nil and caches trash cards" do
+    it 'returns nil and caches trash cards' do
       Card::Auth.as_bot do
-        card_double = class_double("Card")
-        Card.fetch("A").delete!
-        expect(Card.fetch("A")).to be_nil
+        card_double = class_double('Card')
+        Card.fetch('A').delete!
+        expect(Card.fetch('A')).to be_nil
         expect(card_double).not_to receive(:find_by_key_and_trash)
-        expect(Card.fetch("A")).to be_nil
+        expect(Card.fetch('A')).to be_nil
       end
     end
 
-    it "returns and caches builtin cards" do
-      expect(Card.fetch("*head")).to be_instance_of(Card)
-      expect(Card.cache.read("*head")).not_to be_nil
+    it 'returns and caches builtin cards' do
+      expect(Card.fetch('*head')).to be_instance_of(Card)
+      expect(Card.cache.read('*head')).not_to be_nil
     end
 
-    it "returns virtual cards and caches them as missing" do
+    it 'returns virtual cards and caches them as missing' do
       Card::Auth.as_bot do
-        card = Card.fetch("Joe User+*email")
+        card = Card.fetch('Joe User+*email')
         expect(card).to be_instance_of(Card)
-        expect(card.name).to eq("Joe User+*email")
+        expect(card.name).to eq('Joe User+*email')
         expect(card.format.render_raw).to eq('joe@user.com')
       end
-      #card.raw_content.should == 'joe@user.com'
-      #cached_card = Card.cache.read("joe_user+*email")
-      #cached_card.missing?.should be_true
-      #cached_card.virtual?.should be_true
+      # card.raw_content.should == 'joe@user.com'
+      # cached_card = Card.cache.read('joe_user+*email')
+      # cached_card.missing?.should be_true
+      # cached_card.virtual?.should be_true
     end
 
-    it "fetches virtual cards after skipping them" do
+    it 'fetches virtual cards after skipping them' do
       expect(Card['A+*self']).to be_nil
-      expect(Card.fetch( 'A+*self' )).not_to be_nil
+      expect(Card.fetch('A+*self')).not_to be_nil
     end
 
-
-    it "fetches newly virtual cards" do
-      expect(Card.fetch( 'A+virtual')).to be_nil
+    it 'fetches newly virtual cards' do
+      expect(Card.fetch('A+virtual')).to be_nil
       Card::Auth.as_bot { Card.create name: 'virtual+*right+*structure' }
-      expect(Card.fetch( 'A+virtual')).not_to be_nil
+      expect(Card.fetch('A+virtual')).not_to be_nil
     end
 
-    it "handles name variants of cached cards" do
+    it 'handles name variants of cached cards' do
       expect(Card.fetch('yomama+*self').name).to eq('yomama+*self')
       expect(Card.fetch('YOMAMA+*self').name).to eq('YOMAMA+*self')
       expect(Card.fetch('yomama', new: {}).name).to eq('yomama')
       expect(Card.fetch('YOMAMA', new: {}).name).to eq('YOMAMA')
-      expect(Card.fetch('yomama!', new: { name: 'Yomama'} ).name).to eq('Yomama')
+      expect(Card.fetch('yomama!', new: { name: 'Yomama' }).name)
+        .to eq('Yomama')
     end
 
-    it "does not recurse infinitely on template templates" do
-      expect(Card.fetch("*structure+*right+*structure")).to be_nil
+    it 'does not recurse infinitely on template templates' do
+      expect(Card.fetch('*structure+*right+*structure')).to be_nil
     end
 
-    it "expires card and dependencies on save" do
-      #Card.cache.dump # should be empty
-      Card.cache.reset_local
-      expect(Card.cache.local.keys).to eq([])
+    it 'expires card and dependencies on save' do
+      # Card.cache.dump # should be empty
+      Card.cache.soft.reset
+      expect(Card.cache.soft.store.keys).to eq([])
 
       Card::Auth.as_bot do
-        a = Card.fetch("A")
+        a = Card.fetch('A')
         expect(a).to be_instance_of(Card)
 
         # expires the saved card
-        expect(Card.cache).to receive(:delete).with('a').and_call_original
-        expect(Card.cache).to receive(:delete).with(/~\d+/).at_least(1)
+        expect(a).to receive(:expire).and_call_original
+        # expect().to receive(:delete).with('a#SUBCARDS#').and_call_original
         # expires plus cards
-        #expect(Card.cache).to receive(:delete).with('c+a')
-        #expect(Card.cache).to receive(:delete).with('d+a')
-        #expect(Card.cache).to receive(:delete).with('f+a')
-        #expect(Card.cache).to receive(:delete).with('a+b')
-        #expect(Card.cache).to receive(:delete).with('a+c')
-        #expect(Card.cache).to receive(:delete).with('a+d')
-        #expect(Card.cache).to receive(:delete).with('a+e')
-        #expect(Card.cache).to receive(:delete).with('a+b+c')
+        # expect(Card.cache).to receive(:delete).with('c+a')
+        # expect(Card.cache).to receive(:delete).with('d+a')
+        # expect(Card.cache).to receive(:delete).with('f+a')
+        # expect(Card.cache).to receive(:delete).with('a+b')
+        # expect(Card.cache).to receive(:delete).with('a+c')
+        # expect(Card.cache).to receive(:delete).with('a+d')
+        # expect(Card.cache).to receive(:delete).with('a+e')
+        # expect(Card.cache).to receive(:delete).with('a+b+c')
 
         # expired including? cards
-        #expect(Card.cache).to receive(:delete).with('x').exactly(2).times
-        #expect(Card.cache).to receive(:delete).with('y').exactly(2).times
-
+        # expect(Card.cache).to receive(:delete).with('x').exactly(2).times
+        # expect(Card.cache).to receive(:delete).with('y').exactly(2).times
         a.save!
       end
     end
+    describe 'default option' do
+      context "when card doesn't exist" do
+        it 'initializes new cards' do
+          card = Card.fetch 'non-existent',
+                            new: { default_content: 'default content' }
+          expect(card.content).to eq 'default content'
+        end
+      end
+      context 'when new card exist' do
+        it "doesn't change anything" do
+          Card.new name: 'new card',
+                   '+sub' => { content: 'some content' }
+          card = Card.fetch 'new card+sub',
+                            new: { default_content: 'new content' }
+          expect(card.content).to eq 'some content'
+        end
+      end
+    end
 
-    describe "preferences" do
+    describe 'preferences' do
       before do
         Card::Auth.current_id = Card::WagnBotID
       end
 
-      it "prefers db cards to pattern virtual cards" do
-        c1=Card.create!(name: "y+*right+*structure", content: "Formatted Content")
-        c2=Card.create!(name: "a+y", content: "DB Content")
-        card = Card.fetch("a+y")
+      it 'prefers db cards to pattern virtual cards' do
+        c1=Card.create!(name: 'y+*right+*structure', content: 'Formatted Content')
+        c2=Card.create!(name: 'a+y', content: 'DB Content')
+        card = Card.fetch('a+y')
         expect(card.virtual?).to be_falsey
-        expect(card.rule(:structure)).to eq("Formatted Content")
-        expect(card.content).to eq("DB Content")
+        expect(card.rule(:structure)).to eq('Formatted Content')
+        expect(card.content).to eq('DB Content')
       end
 
-      it "prefers a pattern virtual card to trash cards" do
-        Card.create!(name: "y+*right+*structure", content: "Formatted Content")
-        Card.create!(name: "a+y", content: "DB Content")
-        Card.fetch("a+y").delete!
+      it 'prefers a pattern virtual card to trash cards' do
+        Card.create!(name: 'y+*right+*structure', content: 'Formatted Content')
+        Card.create!(name: 'a+y', content: 'DB Content')
+        Card.fetch('a+y').delete!
 
-        card = Card.fetch("a+y")
+        card = Card.fetch('a+y')
         expect(card.virtual?).to be
-        expect(card.raw_content).to eq("Formatted Content")
+        expect(card.raw_content).to eq('Formatted Content')
       end
 
-      it "should recognize pattern overrides" do
-        #~~~ create right rule
-        tc=Card.create!(name: "y+*right+*structure", content: "Right Content")
-        card = Card.fetch("a+y")
+      it 'should recognize pattern overrides' do
+        # ~~~ create right rule
+        tc=Card.create!(name: 'y+*right+*structure', content: 'Right Content')
+        card = Card.fetch('a+y')
         expect(card.virtual?).to be
-        expect(card.raw_content).to eq("Right Content")
+        expect(card.raw_content).to eq('Right Content')
 
-#        warn "creating template"
-        tpr = Card.create!(name: "Basic+y+*type plus right+*structure", content: "Type Plus Right Content")
-        card = Card.fetch("a+y")
+        #        warn 'creating template'
+        tpr = Card.create! name: 'Basic+y+*type plus right+*structure',
+                           content: 'Type Plus Right Content'
+        card = Card.fetch('a+y')
         expect(card.virtual?).to be
-        expect(card.raw_content).to eq("Type Plus Right Content")
+        expect(card.raw_content).to eq('Type Plus Right Content')
 
-        #~~~ delete type plus right rule
+        # ~~~ delete type plus right rule
         tpr.delete!
-        card = Card.fetch("a+y")
+        card = Card.fetch('a+y')
         expect(card.virtual?).to be
-        expect(card.raw_content).to eq("Right Content")
-
+        expect(card.raw_content).to eq('Right Content')
       end
 
-      it "should not hit the database for every fetch_virtual lookup" do
-        card_double = class_double("Card")
-        Card.create!(name: "y+*right+*structure", content: "Formatted Content")
-        Card.fetch("a+y")
+      it 'should not hit the database for every fetch_virtual lookup' do
+        card_double = class_double('Card')
+        Card.create!(name: 'y+*right+*structure', content: 'Formatted Content')
+        Card.fetch('a+y')
         expect(card_double).not_to receive(:find_by_key)
-        Card.fetch("a+y")
+        Card.fetch('a+y')
       end
 
-      it "should not be a new_record after being saved" do
+      it 'should not be a new_record after being saved' do
         Card.create!(name: 'growing up')
         card = Card.fetch('growing up')
         expect(card.new_record?).to be_falsey
       end
     end
+
+    describe 'default_content option' do
+      context "when card doesn't exist" do
+        it 'initializes card with default content' do
+          card = Card.fetch 'non-existent',
+                            new: { default_content: 'default content' }
+          expect(card.content).to eq 'default content'
+        end
+      end
+      context 'when new card exist' do
+        it "doesn't change content" do
+          Card.new name: 'new card',
+                   '+sub' => { content: 'some content' }
+          card = Card.fetch 'new card+sub',
+                            new: { default_content: 'new content' }
+          expect(card.content).to eq 'some content'
+        end
+      end
+    end
   end
 
-  describe "#fetch new: { ... }" do
+  describe '#fetch new: { ... }' do
     it "returns a new card if it doesn't find one" do
-      new_card = Card.fetch "Never Seen Me Before", new: {}
+      new_card = Card.fetch 'Never Seen Me Before', new: {}
       expect(new_card).to be_instance_of(Card)
       expect(new_card.new_record?).to be_truthy
     end
 
-    it "returns a card if it finds one" do
-      new_card = Card.fetch "A+B", new: {}
+    it 'returns a card if it finds one' do
+      new_card = Card.fetch 'A+B', new: {}
       expect(new_card).to be_instance_of(Card)
       expect(new_card.new_record?).to be_falsey
     end
 
-    it "takes a second hash of options as new card options" do
-      new_card = Card.fetch "Never Before", new: { type: "Image" }
+    it 'takes a second hash of options as new card options' do
+      new_card = Card.fetch 'Never Before', new: { type: 'Image' }
       expect(new_card).to be_instance_of(Card)
       expect(new_card.type_code).to eq(:image)
       expect(new_card.new_record?).to be_truthy
-      expect(Card.fetch( 'Never Before', new: {} ).type_id).to eq(Card::BasicID)
+      expect(Card.fetch('Never Before', new: {}).type_id).to eq(Card::BasicID)
     end
   end
 
-  describe "#fetch_virtual" do
-    it "should find cards with *right+*structure specified" do
+  describe '#fetch_virtual' do
+    before do
       Card::Auth.as_bot do
-        Card.create! name: "testsearch+*right+*structure", content: '{"plus":"_self"}', type: 'Search'
+        Card.create! name: 'testsearch+*right+*structure',
+                     content: '{"plus":"_self"}', type: 'Search'
       end
-      c = Card.fetch("A+testsearch".to_name)
+    end
+    it 'should find cards with *right+*structure specified' do
+      c = Card.fetch('A+testsearch'.to_name)
       assert c.virtual?
       expect(c.type_code).to eq(:search_type)
-      expect(c.raw_content).to eq("{\"plus\":\"_self\"}")
+      expect(c.raw_content).to eq('{"plus":"_self"}')
+    end
+    context 'fetched virtual card with new args' do
+      it 'should fetch the virtual card with type set in patterns' do
+        Card.fetch '+testsearch', new: { name: '+testsearch',
+                                         supercard: Card['home'] }
+
+        c = Card.fetch('Home+testsearch'.to_name)
+        assert c.virtual?
+        expect(c.type_code).to eq(:search_type)
+        expect(c.raw_content).to eq('{"plus":"_self"}')
+        patterns = c.instance_variable_get('@patterns').map(&:to_s)
+        expect(patterns).to include('Search+*type')
+      end
     end
   end
 
-  describe "#exists?" do
-    it "is true for cards that are there" do
-      expect(Card.exists?("A")).to eq(true)
+  describe '#exists?' do
+    it 'is true for cards that are there' do
+      expect(Card.exists?('A')).to eq(true)
     end
 
-    it "is false for cards that arent'" do
-      expect(Card.exists?("Mumblefunk is gone")).to eq(false)
+    it "is false for cards that aren't" do
+      expect(Card.exists?('Mumblefunk is gone')).to eq(false)
     end
   end
 end