card 1.20.4 → 1.21.0

data/mod/tinymce_editor/set/self/script_tinymce.rb

@@ -1,3 +1,4 @@
 include_set Abstract::CodeFile
 
 Self::ScriptMods.add_to_basket :item_codenames, :script_tinymce
+Self::InputOptions.add_to_basket :options, "tinymce editor"

data/mod/twitter/db/migrate_cards/20170305112346_add_twitter_cards.rb

@@ -17,7 +17,7 @@ class AddTwitterCards < Card::Migration
 
     Card::Cache.reset_all
 
-    ensure_card name: [:twitter_template, :type, :structure],
+    ensure_card name: %i[twitter_template type structure],
                 content: structure
   end
 

data/mod/twitter/set/type/twitter_template.rb

@@ -5,7 +5,7 @@ card_reader :access_secret
 
 card_reader :message
 
-require 'twitter'
+require "twitter"
 
 def deliver args={}
   client.update message_card.contextual_content(args[:context])

data/spec/lib/card/format_spec.rb

@@ -10,6 +10,7 @@ describe Card::Format do
         format.show_view?(:menu, default_viz)
       end
     end
+
     it "respects defaults" do
       expect(show_menu?({}, :show)).to be_truthy
       expect(show_menu?({}, :hide)).to be_falsey
@@ -42,9 +43,7 @@ describe Card::Format do
     let(:url_text1) do
       "with external free link http://localhost:2020/path?cgi=foo&bar=baz"
     end
-    let(:url_text2) do
-      "with external in link syntax: [[http://brain.org/Home|extra]]"
-    end
+    let(:url_text2) { "with external in link syntax: [[http://brain.org/Home|extra]]" }
     let(:url_text3) { "with internal lik [[A]]" }
     let(:url_text4) { "with internal lik [[Home|display text]]" }
     let(:url_text5) do
@@ -67,18 +66,18 @@ describe Card::Format do
     it "formats html links" do
       cobj = Card::Content.new url_text1, html_format
       expect(cobj.to_s).to eq(
-        'with external free link <a target="_blank" class="external-link" ' \
+                             'with external free link <a target="_blank" class="external-link" ' \
         'href="http://localhost:2020/path?cgi=foo&amp;bar=baz">' \
         "http://localhost:2020/path?cgi=foo&bar=baz</a>"
-      )
+                           )
       cobj = Card::Content.new url_text2 + url_text3 + url_text4, html_format
       expect(cobj.to_s).to eq url_text2 + url_text3 + url_text4
       cobj = Card::Content.new url_text5, html_format
       expect(cobj.to_s).to eq(
-        'external with port: <a target="_blank" class="external-link" ' \
+                             'external with port: <a target="_blank" class="external-link" ' \
         'href="http://localhost:2020/path?cgi=foo+bar=baz">' \
         "http://localhost:2020/path?cgi=foo+bar=baz</a> after "
-      )
+                           )
     end
 
     it "formats page_path" do
@@ -95,4 +94,24 @@ describe Card::Format do
         .to eq "http://test.host/#{card.name}"
     end
   end
+
+  describe "async view" do
+    let(:format) do
+      Card["A"].format_with do
+        view :lazy_view, async: true do
+          "content"
+        end
+      end
+    end
+
+    it "renders placeholder" do
+      expect(format.render(:lazy_view))
+        .to eq "<card-view-placeholder data-url=/A?view=lazy_view_async_content/>"
+    end
+
+    it "renders content in _async_content view" do
+      expect(format.render(:lazy_view_async_content))
+        .to eq "content"
+    end
+  end
 end

data/spec/lib/card/loader_spec.rb

@@ -1,37 +1,98 @@
 # -*- encoding : utf-8 -*-
 
-# describe Card::Mod::Loader do
-#   # let(:card_double) { double "Card" }
-#   # let(:pat_all_double) { proxy Card::Set::All }
-#   # let(:format_double) { proxy Card::Format }
-#   # let(:html_format_double) { proxy Card::Format::HtmlFormat }
-#   # it "autos-load Card class methods from lib/card and mods" do
-#   #   #xpect(Card).to receive(:load_mods)
-#   #   #
-#   #   card = Card[:all]
-#   #   expect(card_double).to receive(:load_formats)
-#   #   #expect(Card).to receive(:load_sets)
-#   #   #expect(Card).to receive(:tracks).with(:any_args) # so Card still loads without core in failure testing
-#   #   Card[:all]
-#   #   #expect(Card.instance_method(:version)).to be
-#   #   # allow(Card).to receive(:version)
-#   #   # expect(Card.instance_method(:type_card)).to be
-#   #   # allow(Card).to receive(:file_path_sdfs)
-#   #   #expect(Card.instance_method(:file_path)).to be
-#   # end
-#   # it "defines Card methods from modules" do
-#   #   expect(Card.instance_method(:set_modules)).to be
-#   # end
-#   # it "defines Formatter methods from modules" do
-#   #   #expect(Card.instance_method(:render_core)).to be
-#   #   expect(Card.instance_method(:_render_raw)).to be
-#   #   expect(Card.instance_method(:render_core)).to be
-#   #   expect(Card.instance_method(:_render_raw)).to be
-#   # end
-#   # it "defines Formatter methods from modules" do
-#   #   expect(html_format_double.method(:render_core)).to be
-#   #   expect(html_format_double.method(:_render_raw)).to be
-#   #   expect(html_format_double.method(:render_core)).to be
-#   #   expect(html_format_double.method(:_render_raw)).to be
-#   # end
-# end
+describe Card::Mod::Loader do
+  # let(:card_double) { double "Card" }
+  # let(:pat_all_double) { proxy Card::Set::All }
+  # let(:format_double) { proxy Card::Format }
+  # let(:html_format_double) { proxy Card::Format::HtmlFormat }
+  # it "autos-load Card class methods from lib/card and mods" do
+  #   #xpect(Card).to receive(:load_mods)
+  #   #
+  #   allow(Card::Mod::Loader).to receive(:load_mods)
+  #   #card = Card[:all]
+  #   #expect(card_double).to receive(:load_formats)
+  #   #expect(Card).to receive(:load_sets)
+  #   #expect(Card).to receive(:tracks).with(:any_args) # so Card still loads without core in failure testing
+  #   Card[:all]
+  #   expect(Card::Mod::Loader).to have_received(:load_mods)
+  #   #expect(Card.instance_method(:version)).to be
+  #   # allow(Card).to receive(:version)
+  #   # expect(Card.instance_method(:type_card)).to be
+  #   # allow(Card).to receive(:file_path_sdfs)
+  #   #expect(Card.instance_method(:file_path)).to be
+  # end
+  # it "defines Card methods from modules" do
+  #   expect(Card.instance_method(:set_modules)).to be
+  # end
+  # it "defines Formatter methods from modules" do
+  #   #expect(Card.instance_method(:render_core)).to be
+  #   expect(Card.instance_method(:_render_raw)).to be
+  #   expect(Card.instance_method(:render_core)).to be
+  #   expect(Card.instance_method(:_render_raw)).to be
+  # end
+  # it "defines Formatter methods from modules" do
+  #   expect(html_format_double.method(:render_core)).to be
+  #   expect(html_format_double.method(:_render_raw)).to be
+  #   expect(html_format_double.method(:render_core)).to be
+  #   expect(html_format_double.method(:_render_raw)).to be
+  # end
+
+  it "loads self set" do
+    create_card "set test load", codename: "set_test_load"
+    Card::Cache.reset_all
+    class ::Card::Set::Self
+      module SetTestLoad
+        extend Card::Set
+        def hello
+          "hello"
+        end
+      end
+    end
+
+    expect(Card["set_test_load"]).to respond_to :hello
+  end
+
+  it "loads self set for junction card" do
+    create_card "set+test+load", codename: "set_test_load"
+    Card::Cache.reset_all
+    class ::Card::Set::Self
+      module SetTestLoad
+        extend Card::Set
+        def hello
+          "hello"
+        end
+      end
+    end
+
+    expect(Card["set+test+load"]).to respond_to :hello
+  end
+
+  it "loads type set" do
+    create_card "set test load", codename: "set_test_load", type_id: Card::CardtypeID
+    Card::Cache.reset_all
+    class ::Card::Set::Type
+      module SetTestLoad
+        extend Card::Set
+        def hello
+          "hello"
+        end
+      end
+    end
+    expect(Card.new(name: "test load", type: "set test load")).to respond_to :hello
+  end
+
+  it "loads type set for a junction cardtyp" do
+    create_card "set+test load", codename: "set_test_load", type_id: Card::CardtypeID
+    Card::Cache.reset_all
+    class ::Card::Set::Type
+      module SetTestLoad
+        extend Card::Set
+        def hi
+          "hello"
+        end
+      end
+    end
+    expect(Card.new(name: "test load", type: "set+test load")).to respond_to :hi
+  end
+
+end

data/spec/lib/card/query_spec.rb

@@ -1,6 +1,5 @@
 # -*- encoding : utf-8 -*-
 
-
 RSpec.describe Card::Query do
   A_JOINEES = %w(B C D E F).freeze
   CARDS_MATCHING_TWO = ["Joe User", "One+Two", "One+Two+Three",

data/spec/support/card_spec_loader.rb

@@ -71,6 +71,7 @@ class CardSpecLoader
       require File.expand_path "../card_spec_helper.rb", __FILE__
       RSpec::Core::ExampleGroup.send :include, Card::SpecHelper
       Card.send :include, Card::SpecHelper::CardHelper
+      Card.send :include, Card::SpecHelper::SetHelper
       Card.send :extend, Card::SpecHelper::CardHelper::ClassMethods
     end
 

data/spec/support/helper/card_helper.rb

@@ -53,42 +53,6 @@ class Card
         yield
       rescue NameError
       end
-
-      def with_set set
-        set = include_set_in_test_set(set) if set.abstract_set?
-        singleton_class.send :include, set
-        yield set if block_given?
-        self
-      end
-
-      def format_with_set set, format_type=:base
-        format = format format_type
-        with_set set do |extended_set|
-          format_class = set_format_class(extended_set, format_type)
-          format.singleton_class.send :include, format_class
-        end
-        block_given? ? yield(format) : format
-      end
-
-      def set_format_class set, format_type
-        format_class = Card::Format.format_class_name format_type
-        set.const_get format_class
-      end
-
-      def include_set_in_test_set set
-        # rubocop:disable Lint/Eval
-        ::Card::Set::Self.const_remove_if_defined :TestSet
-        eval <<-RUBY
-          class ::Card::Set::Self
-            module TestSet
-              extend Card::Set
-              include_set #{set}
-            end
-          end
-        RUBY
-        ::Card::Set::Self::TestSet
-        # rubocop:enable Lint/Eval
-      end
     end
   end
 end

data/spec/support/helper/set_helper.rb

@@ -0,0 +1,80 @@
+class Card
+  module SpecHelper
+    # To be included in Card.
+    # Defines helper to change card sets and formats
+    module SetHelper
+      # define dynamically views (or other things) on format objects
+      # @return format object
+      # @example add a view to a card's html format
+      # format =
+      #   Card["A"].attach_to_format(:html) do
+      #     view :my_test_view do
+      #       card.name
+      #     end
+      #   end
+      # format.render :my_test_view  # => "A"
+      def format_with format_type=:html, &block
+        dynamic_set =
+          create_dynamic_set do
+            format(format_type, &block)
+          end
+        format_with_set dynamic_set, format_type
+        #::Card::Set::Self::DynamicSet, :html
+      end
+
+      # define dynamically sets on card objects
+      # @return card object
+      def set_with &block
+        with_set create_dynamic_set(&block)
+      end
+
+      # load set into card object
+      def with_set set
+        set = include_set_in_test_set(set) if set.abstract_set?
+        singleton_class.send :include, set
+        yield set if block_given?
+        self
+      end
+
+      # load set into a card's format object
+      def format_with_set set, format_type=:base
+        format = format format_type
+        with_set set do |extended_set|
+          format_class = set_format_class(extended_set, format_type)
+          format.singleton_class.send :include, format_class
+        end
+        block_given? ? yield(format) : format
+      end
+
+      def set_format_class set, format_type
+        format_class = Card::Format.format_class_name format_type
+        set.const_get format_class
+      end
+
+      def include_set_in_test_set set
+        # rubocop:disable Lint/Eval
+        ::Card::Set::Self.const_remove_if_defined :TestSet
+        eval <<-RUBY
+          class ::Card::Set::Self
+            module TestSet
+              extend Card::Set
+              include_set #{set}
+            end
+          end
+        RUBY
+        ::Card::Set::Self::TestSet
+        # rubocop:enable Lint/Eval
+      end
+
+      private
+
+      def create_dynamic_set &block
+        ::Card::Set::Self.const_remove_if_defined :DynamicSet
+        ::Card::Set::Self.const_set :DynamicSet, Module.new
+        ::Card::Set::Self::DynamicSet.extend Card::Set
+        ::Card::Set::Self::DynamicSet.module_eval &block
+        ::Card::Set::Self::DynamicSet
+      end
+    end
+  end
+end

data/spec/support/matchers.rb

@@ -0,0 +1,74 @@
+RSpec::Matchers.define :be_valid do
+  match do |card|
+    value_match?(true, card.errors.empty?)
+  end
+end
+
+RSpec::Matchers.define :be_invalid do
+  match do |card|
+    # valid? clears errors
+    # For a new card we have to call valid? to create the errors.
+    # For a updated card we have to check errors because with valid? we would
+    # loose the errors.
+    @valid = card.errors.empty? && card.valid?
+    # card.errors returns an array, hence we need an extra include matcher
+    values_match?(false, @valid) &&
+      values_match?(include(@error_msg), card.errors[@error_key])
+  end
+
+  description do
+    "be invalid #{"because of #{@error_key} #{@error_msg}" if @error_key}"
+  end
+
+  chain(:because_of) do |reason|
+    @error_key, @error_msg = reason.to_a.first
+  end
+
+  failure_message do |actual|
+    super() + fail_reason(actual)
+  end
+
+  def fail_reason actual
+    if @valid
+      "but file is valid"
+    else
+      "but it is invalid because of #{actual.errors.messages}"
+    end
+  end
+end
+
+RSpec::Matchers.define :have_file do |trait|
+  match do |card|
+    trait ||= :file
+    (@file = card.fetch(trait: trait)) && file_size_matches
+  end
+
+  description do
+    "have a file attached #{"of size #{@size}" if @size}"
+  end
+
+  chain(:of_size) { |size| @size = size }
+
+  failure_message do |_actual|
+    if @size
+      "#{super()} but file size is #{@file.file.size}"
+    else
+      "#{super()} but found no file"
+    end
+  end
+
+  failure_message_when_negated do |_actual|
+    if @size
+      "#{super()} but file size is #{@file.file.size}"
+    else
+      "#{super()} but found a file"
+    end
+  end
+
+  private
+
+  def file_size_matches
+    return true unless @size
+    @size === @file.file.size
+  end
+end

data/tmpsets/set/mod001-core/all/actify.rb

@@ -52,12 +52,12 @@ def valid?(*)
   act { super }
 end
 
-def update_attributes *args
-  act(*args) { super }
+def update_attributes(*)
+  act { super }
 end
 
-def update_attributes! *args
-  act(*args) { super }
+def update_attributes!(*)
+  act { super }
 end
 
 def abortable
@@ -88,8 +88,7 @@ def with_transaction_returning_status
 end
 
 event :notable_exception_raised do
-  error = Card::Error.current
-  Rails.logger.debug "#{error.message}\n#{error.backtrace * "\n  "}"
+  Rails.logger.debug "BT:  #{Card::Error.current.backtrace * "\n  "}"
 end
 
 def success