card 1.17.4 → 1.18.0

data/mod/02_basic_types/spec/set/all/all_css_spec.rb

@@ -1,10 +1,10 @@
 # -*- encoding : utf-8 -*-
 
 describe Card::Set::All::AllCss do
-  it "should render content view" do
+  it 'should render content view' do
     content = '#box { display: block }'
     rendered = render_card :content, { content: content }, format: :css
-#    rendered.should =~ /Style Card\:/
+    #    rendered.should =~ /Style Card\:/
     expect(rendered).to match(/#{ Regexp.escape content }/)
   end
 end

data/mod/02_basic_types/spec/set/all/all_csv_spec.rb

@@ -1,9 +1,11 @@
 # -*- encoding : utf-8 -*-
 
-describe Card::Set::All::AllCsv, "CSV mod" do
-  context "csv_row view" do
-    it "should handle inclusions" do
-      expect(render_card( :csv_row, { content: '{{A+B}} {{T}}' }, format: :csv )).to eq("AlphaBeta,Theta")
+describe Card::Set::All::AllCsv, 'CSV mod' do
+  context 'csv_row view' do
+    it 'should handle nests' do
+      rendered = render_card :csv_row, { content: '{{A+B}} {{T}}' },
+                             format: :csv
+      expect(rendered).to eq('AlphaBeta,Theta')
     end
   end
 end

data/mod/02_basic_types/spec/set/all/base_spec.rb

@@ -21,8 +21,8 @@ describe Card::Set::All::Base do
       end
     end
 
-    it('key'     ) { expect(render_card(:key)).to       eq('tempo_rary') }
-    it('linkname') { expect(render_card(:linkname)).to  eq('Tempo_Rary') }
+    it('key') { expect(render_card(:key)).to eq('tempo_rary') }
+    it('linkname') { expect(render_card(:linkname)).to eq('Tempo_Rary') }
 
     it 'url' do
       Card::Env[:protocol] = 'http://'
@@ -47,12 +47,12 @@ describe Card::Set::All::Base do
       it 'of search items' do
         Card.create! name: 'n+a', type: 'Number', content: '10'
         sleep 1
-        Card.create! name: 'n+b', type: 'Phrase', content: "say:\"what\""
+        Card.create! name: 'n+b', type: 'Phrase', content: 'say:"what"'
         sleep 1
         Card.create! name: 'n+c', type: 'Number', content: '30'
         c = Card.new name: 'nplusarray',
                      content: '{{n+*children+by create|array}}'
-        expect(c.format._render(:core)).to eq(%{["10", "say:\\"what\\"", "30"]})
+        expect(c.format._render(:core)).to eq(%(["10", "say:\\"what\\"", "30"]))
       end
 
       it 'of pointer items' do
@@ -62,11 +62,11 @@ describe Card::Set::All::Base do
         Card.create! name: 'npoint', type: 'Pointer',
                      content: "[[n+a]]\n[[n+b]]\n[[n+c]]"
         c = Card.new name: 'npointArray', content: '{{npoint|array}}'
-        expect(c.format._render(:core)).to eq(%{["10", "20", "30"]})
+        expect(c.format._render(:core)).to eq(%(["10", "20", "30"]))
       end
 
       it 'of basic items' do
-        expect(render_card(:array, content: 'yoing')).to eq(%{["yoing"]})
+        expect(render_card(:array, content: 'yoing')).to eq(%(["yoing"]))
       end
     end
     it 'renders template rule of embed cards based on set' do

data/mod/02_basic_types/spec/set/all/json_spec.rb

@@ -1,25 +1,25 @@
 # -*- encoding : utf-8 -*-
 
-describe Card::Set::All::Json, "JSON mod" do
-  context "status view" do
-    it "should handle real and virtual cards" do
+describe Card::Set::All::Json, 'JSON mod' do
+  context 'status view' do
+    it 'should handle real and virtual cards' do
       jf = Card::JsonFormat
       real_json = jf.new(Card['T']).show :status, {}
-      expect(JSON[real_json]).to eq({"key"=>"t","status"=>"real","id"=>Card['T'].id, 'url_key'=>'T'})
+      expect(JSON[real_json]).to eq('key' => 't', 'status' => 'real', 'id' => Card['T'].id, 'url_key' => 'T')
       virtual_json = jf.new(Card.fetch('T+*self')).show :status, {}
-      expect(JSON[virtual_json]).to eq({"key"=>"t+*self","status"=>"virtual",'url_key'=>'T+*self'})
+      expect(JSON[virtual_json]).to eq('key' => 't+*self', 'status' => 'virtual', 'url_key' => 'T+*self')
     end
 
-    it "should treat both unknown and unreadable cards as unknown" do
+    it 'should treat both unknown and unreadable cards as unknown' do
       Card::Auth.as Card::AnonymousID do
         jf = Card::JsonFormat
 
         unknown = Card.new name: 'sump'
         unreadable = Card.new name: 'kumq', type: 'Fruit'
         unknown_json = jf.new(unknown).show :status, {}
-        expect(JSON[unknown_json]).to eq({"key"=>"sump","status"=>"unknown", 'url_key'=>'sump'})
+        expect(JSON[unknown_json]).to eq('key' => 'sump', 'status' => 'unknown', 'url_key' => 'sump')
         unreadable_json = jf.new(unreadable).show :status, {}
-        expect(JSON[unreadable_json]).to eq({"key"=>"kumq","status"=>"unknown", 'url_key'=>'kumq'})
+        expect(JSON[unreadable_json]).to eq('key' => 'kumq', 'status' => 'unknown', 'url_key' => 'kumq')
       end
     end
   end

data/mod/02_basic_types/spec/set/type/plain_text_spec.rb

@@ -1,11 +1,11 @@
 # -*- encoding : utf-8 -*-
 
 describe Card::Set::Type::PlainText do
-  it "should have special editor" do
+  it 'should have special editor' do
     assert_view_select render_editor('Plain Text'), 'textarea[rows="5"]'
   end
 
-  it "should have special content that escapes HTML" do
-    render_card(:core, type: 'Plain Text', content: "<b></b>").should == '&lt;b&gt;&lt;/b&gt;'
+  it 'should have special content that escapes HTML' do
+    render_card(:core, type: 'Plain Text', content: '<b></b>').should == '&lt;b&gt;&lt;/b&gt;'
   end
 end

data/mod/02_basic_types/spec/set/type/pointer_spec.rb

@@ -1,9 +1,9 @@
 # -*- encoding : utf-8 -*-
 describe Card::Set::Type::Pointer do
-  describe "item_names" do
+  describe 'item_names' do
     it 'should return array of names of items referred to by a pointer' do
-      card = Card.new(type: 'Pointer', content:"[[Busy]]\n[[Body]]")
-      card.item_names.should == ['Busy', 'Body']
+      card = Card.new(type: 'Pointer', content: "[[Busy]]\n[[Body]]")
+      card.item_names.should == %w(Busy Body)
     end
   end
 
@@ -49,7 +49,6 @@ describe Card::Set::Type::Pointer do
     end
   end
 
-
   let(:pointer) do
     Card.create name: 'tp', type: 'pointer',
                 content: "[[item1]]\n[[item2]]"
@@ -59,13 +58,13 @@ describe Card::Set::Type::Pointer do
     it 'recognizes added items' do
       Card::Auth.as_bot do
         pointer
-        in_phase before: :approve,
+        in_stage :validate,
                  on: :save,
-                 trigger: ->{
-                   pointer.update_attributes!(
-                     content: "[[item1]]\n[[item2]]\n[[item3]]"
-                  )
-                } do
+                 trigger: -> do
+                            pointer.update_attributes!(
+                              content: "[[item1]]\n[[item2]]\n[[item3]]"
+                            )
+                          end do
           expect(added_item_names).to eq ['item3']
         end
       end
@@ -74,13 +73,13 @@ describe Card::Set::Type::Pointer do
     it 'ignores order' do
       Card::Auth.as_bot do
         pointer
-        in_phase before: :approve,
+        in_stage :validate,
                  on: :save,
-                 trigger: ->{
+                 trigger: -> do
                    pointer.update_attributes!(
                      content: "[[item2]]\n[[item1]]"
                    )
-                 } do
+                 end do
           expect(added_item_names).to eq []
         end
       end
@@ -91,13 +90,13 @@ describe Card::Set::Type::Pointer do
     it 'recognizes dropped items' do
       Card::Auth.as_bot do
         pointer
-        in_phase before: :approve,
+        in_stage :validate,
                  on: :save,
-                 trigger: ->{
+                 trigger: -> do
                    pointer.update_attributes!(
-                     content: "[[item1]]"
+                     content: '[[item1]]'
                    )
-                 } do
+                 end do
           expect(dropped_item_names).to eq ['item2']
         end
       end
@@ -106,13 +105,13 @@ describe Card::Set::Type::Pointer do
     it 'ignores order' do
       Card::Auth.as_bot do
         pointer
-        in_phase before: :approve,
+        in_stage :validate,
                  on: :save,
-                 trigger: ->{
+                 trigger: -> do
                    pointer.update_attributes!(
                      content: "[[item2]]\n[[item1]]"
                    )
-                 } do
+                 end do
           expect(dropped_item_names).to eq []
         end
       end
@@ -123,21 +122,19 @@ describe Card::Set::Type::Pointer do
     it 'recognizes changed items' do
       Card::Auth.as_bot do
         pointer
-        in_phase before: :approve,
+        in_stage :validate,
                  on: :save,
-                 trigger: ->{
+                 trigger: -> do
                    pointer.update_attributes!(
                      content: "[[item1]]\n[[item3]]"
                    )
-                 } do
-          expect(changed_item_names.sort).to eq ['item2','item3']
+                 end do
+          expect(changed_item_names.sort).to eq %w(item2 item3)
         end
       end
     end
   end
 
-
-
   describe 'html' do
     before do
       Card::Auth.as_bot do
@@ -184,17 +181,17 @@ describe Card::Set::Type::Pointer do
     end
     it 'should render CSS of items' do
       css_list = render_card(:content,
-        { type: Card::PointerID, name: 'my style list', content: '[[my css]]' },
-        format: :css
-      )
-#      css_list.should =~ /STYLE GROUP\: \"my style list\"/
-#      css_list.should =~ /Style Card\: \"my css\"/
+                             { type: Card::PointerID, name: 'my style list', content: '[[my css]]' },
+                             format: :css
+                            )
+      #      css_list.should =~ /STYLE GROUP\: \"my style list\"/
+      #      css_list.should =~ /Style Card\: \"my css\"/
       css_list.should =~ /#{ Regexp.escape @css }/
     end
   end
 
   describe '#standardize_item' do
-    it "should handle unlinked items" do
+    it 'should handle unlinked items' do
       pointer1 = Card.create!(
         name: 'pointer1', type: 'Pointer', content: 'bracketme'
       )

data/mod/03_machines/lib/card/machine.rb

@@ -1,15 +1,16 @@
 # WHAT IS THIS?
 # The Machine module together with the MachineInput module implements a kind of
 # observer pattern. It handles a collection of input cards to generate an
-# outputcard (default is a file card). If one of the input cards is changed the
+# output card (default is a file card). If one of the input cards is changed the
 # output card will be updated.
 #
 # The classic example: A style card observes a collection of css and sccs card
-# to generate a file card with a css file containg the assembled compressed css.
+# to generate a file card with a css file that contains the assembled
+# compressed  css.
 #
 # HOW TO USE IT?
 # Include the Machine module in the card set that is supposed to produce the
-# output card. If the output card should be autmatically updated when a input
+# output card. If the output card should be automatically updated when a input
 # card is changed the input card has to be in a set that includes the
 # MachineInput module.
 #
@@ -19,19 +20,17 @@
 #  -  can be changed by passing a block to collect_input_cards
 #  -  takes the raw view of the input cards to generate the output;
 #  -  can be changed by passing a block to machine_input (in the input card set)
-#  -  stores the output as a .txt file in the "+machine output" card;
+#  -  stores the output as a .txt file in the '+machine output' card;
 #  -  can be changed by passing a filetype and/or a block to
 #     store_machine_output
 #
 #
 # HOW DOES IT WORK?
-# Machine cards have a "+machine input" and a "+machine output" card. The
-# "+machine input" card is a pointer to all input cards. Including the
-# MachineInput module creates an "on: save" event that runs the machines of
+# Machine cards have a '+machine input' and a '+machine output' card. The
+# '+machine input' card is a pointer to all input cards. Including the
+# MachineInput module creates an 'on: save' event that runs the machines of
 # all cards that are linked to that card via the +machine input pointer.
 
-
-
 class Card
   module Machine
     module ClassMethods
@@ -51,103 +50,120 @@ class Card
 
       def store_machine_output args={}, &block
         output_config.merge!(args)
-        if block_given?
-          define_method :after_engine, &block
-        end
+        return unless block_given?
+        define_method :after_engine, &block
       end
     end
 
-    def self.included(host_class)
-      host_class.extend( ClassMethods )
+    def self.included host_class
+      host_class.extend(ClassMethods)
       host_class.output_config = { filetype: 'txt' }
 
+      # for compatibility with old migrations
+      return unless  Codename[:machine_output]
 
-      if Codename[:machine_output]  # for compatibility with old migrations
-        host_class.card_accessor :machine_output, type: :file
-        host_class.card_accessor :machine_input, type: :pointer
-
-        # define default machine behaviour
-        host_class.collect_input_cards do
-          # traverse through all levels of pointers and
-          # collect all item cards as input
-          items = [self]
-          new_input = []
-          already_extended = {} # avoid loops
-          loop_limit = 5
-          while items.size > 0
-            item = items.shift
-            next if item.trash
-            next if already_extended[item.id].to_i > loop_limit
-            if item.item_cards == [item]  # no pointer card
-              new_input << item
-            else
-              items.insert(0, item.item_cards)
-              items.flatten!
-              new_input << item if item != self
-              already_extended[item] = already_extended[item].to_i + 1
-            end
-          end
-          new_input
-        end
+      host_class.card_accessor :machine_output, type: :file
+      host_class.card_accessor :machine_input, type: :pointer
 
-        host_class.prepare_machine_input {}
-        host_class.machine_engine { |input| input }
-        host_class.store_machine_output do |output|
-          filetype = host_class.output_config[:filetype]
-          file = Tempfile.new [ id.to_s, ".#{filetype}" ]
-          file.write output
-          file.rewind
-          Card::Auth.as_bot do
-            p = machine_output_card
-            p.file = file
-            p.save!
-          end
-          file.close
-          file.unlink
+      set_default_machine_behaviour host_class
+      define_machine_views host_class
+      define_machine_events host_class
+    end
+
+    def self.define_machine_events host_class
+      event_suffix = host_class.name.tr ':', '_'
+      event_name = "reset_machine_output_#{event_suffix}".to_sym
+      host_class.event event_name, after: :expire_related, on: :save do
+        reset_machine_output!
+      end
+    end
+
+    def self.define_machine_views host_class
+      host_class.format do
+        view :machine_output_url do |_args|
+          machine_output_url
         end
+      end
+    end
 
+    def self.set_default_machine_behaviour host_class
+      set_default_input_collection_method host_class
+      set_default_input_preparation_method host_class
+      set_default_output_storage_method host_class
+      host_class.machine_engine { |input| input }
+    end
 
-        host_class.format do
-          view :machine_output_url do |args|
-            machine_output_url
-          end
+    def self.set_default_input_preparation_method host_class
+      host_class.prepare_machine_input {}
+    end
+
+    def self.set_default_output_storage_method host_class
+      host_class.store_machine_output do |output|
+        filetype = host_class.output_config[:filetype]
+        file = Tempfile.new [id.to_s, ".#{filetype}"]
+        file.write output
+        file.rewind
+        Card::Auth.as_bot do
+          p = machine_output_card
+          p.file = file
+          p.save!
         end
+        file.close
+        file.unlink
+      end
+    end
 
-        event_suffix = host_class.name.gsub ':', '_'
-        host_class.event(
-          "reset_machine_output_#{ event_suffix }".to_sym,
-          after: :expire_related, on: :save
-        ) do
-          reset_machine_output!
+    def self.set_default_input_collection_method host_class
+      host_class.collect_input_cards do
+        # traverse through all levels of pointers and
+        # collect all item cards as input
+        items = [self]
+        new_input = []
+        already_extended = {} # avoid loops
+        loop_limit = 5
+        while items.size > 0
+          item = items.shift
+          next if item.trash || already_extended[item.id].to_i > loop_limit
+          if item.item_cards == [item] # no pointer card
+            new_input << item
+          else
+            # item_cards instantiates non-existing cards
+            # we don't want those
+            items.insert(0, item.item_cards.reject(&:unknown?))
+            items.flatten!
+
+            new_input << item if item != self && item.known?
+            already_extended[item] = already_extended[item].to_i + 1
+          end
         end
+        new_input
       end
     end
 
     def run_machine joint="\n"
       before_engine
-      output = input_item_cards.map do |input|
-        unless input.kind_of? Card::Set::Type::Pointer
+      output =
+        input_item_cards.map do |input|
+          next if input.is_a? Card::Set::Type::Pointer
           if input.respond_to? :machine_input
-            engine( input.machine_input )
+            engine(input.machine_input)
           else
-            engine( input.format._render_raw )
+            engine(input.format._render_raw)
           end
-        end
-      end.select(&:present?).join( joint )
+        end.select(&:present?).join(joint)
       after_engine output
     end
 
     def reset_machine_output!
       Auth.as_bot do
-        moc = machine_output_card and moc.real? and moc.delete!
-        #mic = machine_input_card  and mic.real? and mic.delete!
+        (moc = machine_output_card) && moc.real? && moc.delete!
+        # mic = machine_input_card  and mic.real? and mic.delete!
         update_input_card
       end
     end
 
-
     def update_machine_output
-      if ok? :read and not was_already_locked = locked?
+      if ok?(:read) && !(was_already_locked = locked?)
         Auth.as_bot do
           lock!
           update_input_card
@@ -155,7 +171,7 @@ class Card
         end
       end
     ensure
-       unlock! unless was_already_locked
+      unlock! unless was_already_locked
     end
 
     def lock_cache_key
@@ -184,7 +200,7 @@ class Card
 
     def machine_output_url
       ensure_machine_output
-      machine_output_card.file.url #(:default, timestamp: false)
+      machine_output_card.file.url # (:default, timestamp: false)
       # to get rid of additional number in url
     end
 
@@ -195,10 +211,8 @@ class Card
 
     def ensure_machine_output
       output = fetch trait: :machine_output
-      if !output || !output.selected_content_action_id
-        update_machine_output
-      end
+      return if output && output.selected_content_action_id
+      update_machine_output
     end
   end
 end
-