card 1.18.6 → 1.19.0

data/mod/settings/spec/set/right/comment_spec.rb

@@ -0,0 +1,41 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Set::Right::Comment do
+  context "record appender" do
+    before do
+      #      @r = Card.where(type_id: Card::RoleID).first
+      @rule = Card.new name: "A+*self+*comment",
+                       type_id: Card::PointerID,
+                       content: "[[Anyone Signed In]]"
+    end
+
+    it "should have appender immediately" do
+      expect(Card["a"].ok?(:comment)).not_to be_truthy
+      Card::Auth.as_bot do
+        @rule.save!
+      end
+      expect(Card["a"].ok?(:comment)).to be_truthy
+    end
+
+    it "should have appender immediately" do
+      Card::Auth.as_bot do
+        expect(Card["a"].ok?(:comment)).not_to be_truthy
+        @rule.save!
+        expect(Card["a"].ok?(:comment)).to be_truthy
+      end
+    end
+  end
+
+  context "comment addition" do
+    it "should combine content after save" do
+      Card::Auth.as_bot do
+        Card.create name: "basicname+*self+*comment",
+                    content: "[[Anyone Signed In]]"
+        @c = Card.fetch "basicname"
+        @c.comment = " and more\n  \nsome lines\n\n"
+        @c.save!
+      end
+      expect(Card["basicname"].content).to match(%r{\<p\>some lines\</p\>})
+    end
+  end
+end

data/mod/settings/spec/set/right/create_spec.rb

@@ -0,0 +1,10 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Set::Right::Create do
+  it "should render the perm editor" do
+    Card::Auth.as_bot do
+      card = Card.new name: "A+B+*self+*create"
+      assert_view_select card.format._render_editor, "div[class=perm-editor]"
+    end
+  end
+end

data/mod/settings/spec/set/right/script_spec.rb

@@ -0,0 +1,35 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Set::Right::Script do
+  let(:js)                    { 'alert( "Hi" );'    }
+  let(:compressed_js)         { 'alert("Hi");'      }
+  let(:changed_js)            { 'alert( "Hello" );' }
+  let(:compressed_changed_js) { 'alert("Hello");'   }
+  let(:new_js)                { 'alert( "Hey" );'   }
+  let(:compressed_new_js)     { 'alert("Hey");'   }
+
+  it_should_behave_like "pointer machine", that_produces_js do
+    let(:input_name) { "test js" }
+    let(:machine_card) do
+      Card.gimme! "test my style+*script", type: :pointer, content: ""
+    end
+    let(:machine_input_card) do
+      Card.gimme! "test js",  type: Card::JavaScriptID, content: js
+    end
+    let(:another_machine_input_card) do
+      Card.gimme! "more js",  type: Card::JavaScriptID, content: new_js
+    end
+    let(:expected_input_items) { nil }
+    let(:input_type) { :java_script }
+    let(:card_content) do
+      {
+        in:          js,
+        out:         "//test js\n#{compressed_js}",
+        changed_in:  changed_js,
+        changed_out: "//test js\n#{compressed_changed_js}",
+        new_in:      new_js,
+        new_out:     "//more js\n#{compressed_new_js}"
+      }
+    end
+  end
+end

data/mod/settings/spec/set/right/structure_spec.rb

@@ -0,0 +1,25 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Set::Right::Structure do
+  it "closed_content is rendered as type + raw" do
+    template = Card.new name: "A+*right+*structure",
+                        content: "[[link]] {{nest}}"
+    expect(template.format._render(:closed_content)).to eq(
+      '<a class="cardtype known-card" href="/Basic">Basic</a>' \
+      " : [[link]] {{nest}}"
+    )
+  end
+
+  it "closed_content is rendered as type + raw" do
+    template = Card.new name: "A+*right+*structure", type: "Html",
+                        content: "[[link]] {{nest}}"
+    expect(template.format._render(:closed_content)).to eq(
+      '<a class="cardtype known-card" href="/HTML">HTML</a> : [[link]] {{nest}}'
+    )
+  end
+
+  # it 'renders core as raw' do
+  #     trs = Card.fetch('*type+*right+*structure').format.render_core
+  #     expect(trs).to eq '{"type":"_left"}'
+  # end
+end

data/mod/settings/spec/set/right/style_spec.rb

@@ -0,0 +1,34 @@
+# -*- encoding : utf-8 -*-
+
+require File.expand_path("../../../../../machines/spec/lib/"\
+                         "shared_machine_examples.rb", __FILE__)
+
+describe Card::Set::Right::Style do
+  #  describe "#delet"
+  #  it "should delete tempfile"
+  let(:css)                    { "#box { display: block }"  }
+  let(:compressed_css)         { "#box{display:block}\n"    }
+  let(:changed_css)            { "#box { display: inline }" }
+  let(:compressed_changed_css) { "#box{display:inline}\n"   }
+  let(:new_css)                { "#box{ display: none}\n"   }
+  let(:compressed_new_css)     { "#box{display:none}\n"   }
+
+  it_should_behave_like "pointer machine", that_produces_css do
+    let(:machine_card) do
+      Card.gimme! "test my style+*style", type: :pointer, content: ""
+    end
+    let(:machine_input_card) do
+      Card.gimme! "test css", type: :css, content: css
+    end
+    let(:another_machine_input_card) do
+      Card.gimme! "more css", type: :css, content: new_css
+    end
+    let(:expected_input_items) { nil }
+    let(:input_type) { :css }
+    let(:card_content) do
+      { in:           css,         out:     compressed_css,
+        changed_in:   changed_css, changed_out: compressed_changed_css,
+        new_in:       new_css,     new_out:     compressed_new_css }
+    end
+  end
+end

data/mod/settings/spec/set/type/setting_spec.rb

@@ -0,0 +1,10 @@
+# -*- encoding : utf-8 -*-
+
+describe Card::Set::Type::Setting do
+  context "core view" do
+    it "should have a table" do
+      core = render_card :core, name: :help
+      assert_view_select core, "table"
+    end
+  end
+end

data/mod/solid_cache/db/migrate_cards/20160806112710_add_solid_cache_cards.rb

@@ -0,0 +1,10 @@
+# -*- encoding : utf-8 -*-
+
+class AddSolidCacheCards < Card::Migration
+  def up
+    ensure_card name: "*solid cache",
+                codename: "solid_cache"
+    ensure_card name: "*solid cache+*right+*read",
+                content: "_left"
+  end
+end

data/mod/solid_cache/set/abstract/solid_cache.rb

@@ -0,0 +1,99 @@
+# -*- encoding : utf-8 -*-
+
+# A card that includes Abstract::SolidCache caches its core view
+# in a '+*solid cache' card.
+# If that card exists the core view returns its content as rendered view.
+# If it doesn't exist the usual core view is rendered and saved in that card.
+#
+# The cache expiration can be controlled with the cache_update_trigger and
+# cache_expire_trigger methods.
+
+card_accessor :solid_cache, type: :html
+
+format :html do
+  def default_core_args args
+    args[:solid_cache] = true unless args.key?(:solid_cache)
+  end
+
+  view :core do |args|
+    return super(args) unless args[:solid_cache]
+
+    subformat(card.solid_cache_card)._render_core args
+  end
+end
+
+module ClassMethods
+  # If a card of the set given by 'set_of_changed_card' is updated
+  # the given block is executed. It is supposed to return an array of
+  # cards whose solid caches are expired because of the update.
+  # @param set_of_changed_card [set constant] a set of cards that triggers
+  #   a cache update
+  # @params args [Hash]
+  # @option args [Symbol, Array of symbols] :on the action(s)
+  #   (:create, :update, or :delete) on which the cache update
+  #   should be triggered. Default is all actions.
+  # @option args [Stage] :in_stage the stage when the update is executed.
+  #   Default is :integrate
+  # @yield return an array of cards with solid cache that need to be updated
+  def cache_update_trigger set_of_changed_card, args={}, &block
+    define_event_to_update_expired_cached_cards(
+      set_of_changed_card, args, :update_solid_cache, &block
+    )
+  end
+
+  # Same as 'cache_update_trigger' but expires instead of updates the
+  # outdated solid caches
+  def cache_expire_trigger set_of_changed_card, args={}, &block
+    define_event_to_update_expired_cached_cards(
+      set_of_changed_card, args, :expire_solid_cache, &block
+    )
+  end
+
+  def define_event_to_update_expired_cached_cards set_of_changed_card, args,
+                                                  method_name
+    args[:on] ||= [:create, :update, :delete]
+    name = event_name set_of_changed_card, args
+    stage = args[:in_stage] || :integrate
+    Card::Set.register_set set_of_changed_card
+    set_of_changed_card.event name, stage, args do
+      Array(yield(self)).compact.each do |expired_cache_card|
+        next unless expired_cache_card.solid_cache?
+        expired_cache_card.send method_name
+      end
+    end
+  end
+
+  def event_name set, args
+    changed_card_set = set.to_s.tr(":", "_").underscore
+    solid_cache_set = to_s.tr(":", "_").underscore
+    actions = Array.wrap(args[:on]).join("_")
+    "update_#{solid_cache_set}_solid_cache_changed_by_" \
+    "#{changed_card_set}_on_#{actions}".to_sym
+  end
+end
+
+def expire_solid_cache
+  return unless solid_cache?
+  Auth.as_bot do
+    solid_cache_card.delete!
+  end
+end
+
+def update_solid_cache
+  return unless solid_cache?
+  new_content = format(:html)._render_core(solid_cache: false)
+  return unless new_content
+  write_to_solid_cache new_content
+  new_content
+end
+
+def write_to_solid_cache new_content
+  Auth.as_bot do
+    if solid_cache_card.new_card?
+      solid_cache_card.update_attributes! content: new_content
+    elsif new_content != solid_cache_card.content
+      solid_cache_card.update_column :db_content, new_content
+      solid_cache_card.expire
+    end
+  end
+end

data/mod/solid_cache/set/all/solid_cache.rb

@@ -0,0 +1,14 @@
+def solid_cache?
+  respond_to?(:solid_cache_card)
+end
+
+module ClassMethods
+  def clear_solid_cache
+    Auth.as_bot do
+      Card.search(right: { codename: "solid_cache" }).each do |card|
+        card.update_columns trash: true
+        card.expire
+      end
+    end
+  end
+end

data/mod/solid_cache/set/right/solid_cache.rb

@@ -0,0 +1,32 @@
+def followable?
+  false
+end
+
+def history?
+  false
+end
+
+def clean_html?
+  false
+end
+
+format :html do
+  view :core do |args|
+    return super(args) unless card.new_card?
+    _render_missing args.merge(denied_view: :core)
+  end
+
+  view :missing do |args|
+    if @card.new_card? &&
+       (l = @card.left) &&
+       l.solid_cache?
+      l.update_solid_cache
+      @card = Card.fetch(card.name)
+      render(args[:denied_view], args)
+    else
+      super(args)
+    end
+  end
+
+  view :new, :missing
+end

data/mod/solid_cache/spec/set/abstract/solid_cache_spec.rb

@@ -0,0 +1,98 @@
+
+describe Card::Set::Abstract::SolidCache do
+  context "render core view of a card" do
+    before do
+      @card = Card["A"]
+    end
+
+    let(:core_view) { 'Alpha <a class="known-card" href="/Z">Z</a>' }
+    context "with solid cache" do
+      it "saves core view in solid cache card" do
+        @card.format_with_set(Card::Set::Abstract::SolidCache, &:render_core)
+        Card::Auth.as_bot do
+          expect(Card["A", :solid_cache]).to be_instance_of(Card)
+          expect(Card["A", :solid_cache].content).to eq(core_view)
+        end
+      end
+
+      it "uses solid cache card content as core view" do
+        @card.format_with_set(Card::Set::Abstract::SolidCache) do |format|
+          Card::Auth.as_bot do
+            Card["A"].solid_cache_card.update_attributes! content: "cache"
+          end
+          expect(format._render_core).to eq "cache"
+        end
+      end
+    end
+    context "with solid cache disabled" do
+      it "ignores solid cache card content" do
+        @card.format_with_set(Card::Set::Abstract::SolidCache) do |format|
+          Card::Auth.as_bot do
+            Card["A"].solid_cache_card.update_attributes! content: "cache"
+          end
+          expect(format._render_core(solid_cache: false)).to eq core_view
+        end
+      end
+    end
+  end
+
+  # rubocop:disable ClassAndModuleChildren
+  # rubocop:disable Documentation
+  context "when cached content expired" do
+    before do
+      Card::Auth.as_bot do
+        Card.create! name: "volatile", codename: "volatile",
+                     content: "chopping"
+        Card.create! name: "cached", codename: "cached",
+                     content: "chopping and {{volatile|core}}"
+      end
+      Card::Codename.reset_cache
+    end
+    describe ".cache_update_trigger" do
+      before do
+        module Card::Set::Self::Cached
+          extend Card::Set
+          include_set Card::Set::Abstract::SolidCache
+
+          ensure_set { Card::Set::Self::Volatile }
+          cache_update_trigger Card::Set::Self::Volatile do
+            Card["cached"]
+          end
+        end
+      end
+
+      it "updates solid cache card" do
+        Card::Auth.as_bot do
+          Card["volatile"].update_attributes! content: "changing"
+        end
+        expect(Card["cached", :solid_cache].content)
+          .to eq "chopping and changing"
+      end
+    end
+
+    describe ".cache_expire_trigger" do
+      before do
+        module Card::Set::Self::Cached
+          extend Card::Set
+          include_set Card::Set::Abstract::SolidCache
+
+          ensure_set { Card::Set::Self::Volatile }
+          cache_expire_trigger Card::Set::Self::Volatile do
+            Card["cached"]
+          end
+        end
+      end
+
+      it "expires solid cache card" do
+        Card["cached"].format(:html)._render_core
+        expect(Card["cached", :solid_cache]).to be_instance_of Card
+        Card::Auth.as_bot do
+          Card["volatile"].update_attributes! content: "changing"
+        end
+        expect(Card["cached", :solid_cache]).to be_falsey
+      end
+    end
+  end
+  # rubocop:enable ClassAndModuleChildren
+  # rubocop:enable Documentation
+end