card 1.18.6 → 1.19.0

data/mod/05_standard/set/type/toggle.rb

@@ -1,12 +0,0 @@
-
-view :core do |_args|
-  case card.raw_content.to_i
-  when 1 then 'yes'
-  when 0 then 'no'
-  else; '?'
-  end
-end
-
-view :editor do |_args|
-  check_box :content
-end

data/mod/05_standard/set/type/user.rb

@@ -1,81 +0,0 @@
-
-include Basic
-
-attr_accessor :email
-
-format :html do
-  view :setup, tags: :unknown_ok,
-               perms: ->(_r) { Auth.needs_setup? } do |args|
-    account = card.fetch trait: :account, new: {}
-    Auth.as_bot do
-      frame_and_form :create, args do
-        [
-          _render_name_formgroup(help: 'usually first and last name'),
-          subformat(account)._render(:content_formgroup, structure: true),
-          _render_button_formgroup(args)
-        ]
-      end
-    end
-  end
-
-  def default_setup_args args
-    args.merge!(
-      title: 'Welcome, Wagneer!',
-      optional_help: :show,
-      optional_menu: :never,
-      help_text: help_text,
-      buttons: setup_button,
-      hidden: {
-        success: "REDIRECT: #{Card.path_setting '/'}",
-        'card[type_id]' => Card.default_accounted_type_id,
-        'setup' => true
-      }
-    )
-  end
-
-  def help_text
-    text = '<h3>To get started, set up an account.</h3>'
-    if Card.config.action_mailer.perform_deliveries == false
-      text += <<-HTML
-        <br>WARNING: Email delivery is turned off.
-        Change settings in config/application.rb to send sign up notifications.'
-      HTML
-    end
-    text
-  end
-
-  def setup_button
-    submit_button text: 'Set up', disable_with: 'Setting up'
-  end
-end
-
-event :setup_as_bot, before: :check_permissions, on: :create,
-                     when: proc { Card::Env.params[:setup] } do
-  abort :failure unless Auth.needs_setup?
-  Auth.as_bot
-  # we need bot authority to set the initial administrator roles
-  # this is granted and inspected here as a separate event for
-  # flexibility and security when configuring initial setups
-end
-
-event :setup_first_user, :prepare_to_store, on: :create,
-                                            when: proc { Card::Env.params[:setup] } do
-  add_subcard 'signup alert email+*to', content: name
-  add_subfield :roles, content: Card[:administrator].name
-end
-
-event :signin_after_setup, :integrate, on: :create,
-                                       when: proc { Card::Env.params[:setup] } do
-  Auth.signin id
-end
-
-def follow follow_name, option='*always'
-  return unless
-    (card = Card.fetch follow_name) &&
-    (set_card = card.default_follow_set_card) &&
-    (follow_rule_name = set_card.follow_rule_name(name)) &&
-    (follow_rule = Card.fetch follow_rule_name, new: {})
-  follow_rule.drop_item '*never'
-  follow_rule.add_item option
-  follow_rule.save!
-end

data/mod/05_standard/spec/chunk/include_spec.rb

@@ -1,203 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::Content::Chunk::Include, 'Inclusion' do
-  context 'syntax parsing' do
-    before do
-      @class = Card::Content::Chunk::Include
-    end
-
-    let :instance do
-      @class.new(@class.full_match(@chunk), nil)
-    end
-    let(:options) { instance.options }
-    let(:name) { instance.name }
-    it 'ignores invisible comments' do
-      expect(render_content('{{## now you see nothing}}')).to eq('')
-    end
-
-    it 'handles visible comments' do
-      expect(render_content('{{# now you see me}}'))
-        .to eq('<!-- # now you see me -->')
-      expect(render_content('{{# -->}}')).to eq('<!-- # --&gt; -->')
-    end
-
-    it 'handles empty nests' do
-      @chunk = '{{ }}'
-      expect(name).to eq('')
-      expect(options[:inc_syntax]).to eq(' ')
-    end
-
-    it 'handles empty nests with pipe' do
-      @chunk = '{{|}}'
-      expect(name).to eq('')
-      expect(options[:inc_syntax]).to eq('|')
-    end
-
-    it 'handles no pipes' do
-      @chunk = '{{toy}}'
-      expect(name).to eq('toy')
-      expect(options[:inc_name]).to eq('toy')
-      expect(options.key?(:view)).to eq(false)
-    end
-
-    it 'strips the name' do
-      @chunk = '{{ toy }}'
-      expect(name).to eq('toy')
-    end
-
-    it 'strips html tags' do
-      @chunk = '{{ <span>toy</span> }}'
-      expect(name).to eq('toy')
-    end
-
-    it 'strips html tags with pipe' do
-      @chunk = '{{ <span>toy|open</span> }}'
-      expect(name).to eq('toy')
-      expect(options[:view]).to eq('open')
-    end
-
-    it 'handles single pipe' do
-      @chunk = '{{toy|view:link;hide:me}}'
-      expect(options[:inc_name]).to eq('toy')
-      expect(options[:view]).to eq('link')
-      expect(options[:hide]).to eq('me')
-      expect(options.key?(:items)).to eq(false)
-    end
-
-    it 'handles multiple pipes' do
-      @chunk = '{{box|open|closed}}'
-      expect(options[:inc_name]).to eq('box')
-      expect(options[:view]).to eq('open')
-      expect(options[:items][:view]).to eq('closed')
-      expect(options[:items].key?(:items)).to eq(false)
-    end
-
-    it 'handles multiple pipes with blank lists' do
-      @chunk = '{{box||closed}}'
-      expect(options[:inc_name]).to eq('box')
-      expect(options[:view]).to eq(nil)
-      expect(options[:items][:view]).to eq('closed')
-    end
-
-    it 'treats :item as view of next level' do
-      @chunk = '{{toy|link;item:name}}'
-      expect(options[:inc_name]).to eq('toy')
-      expect(options[:view]).to eq('link')
-      expect(options[:items][:view]).to eq('name')
-    end
-
-    it '#each_option should work' do
-      @chunk = '{{}}'
-      expect { |b| instance.send(:each_option, '', &b) }.not_to yield_control
-      expect { |b| instance.send(:each_option, nil, &b) }.not_to yield_control
-      expect { |b| instance.send(:each_option, 'a:b;c:4', &b) }
-        .to yield_successive_args(%w(a b), %w(c 4))
-      expect { |b| instance.send(:each_option, 'd:b;e:4; ', &b) }
-        .to yield_successive_args(%w(d b), %w(e 4))
-    end
-  end
-
-  context 'rendering' do
-    it 'handles absolute names' do
-      create! 'Alpha', 'Pooey'
-      beta = create! 'Beta', '{{Alpha}}'
-      result = beta.format.render_core
-      assert_view_select result, 'div[class~="card-content"]', 'Pooey'
-    end
-
-    it 'handles simple relative names' do
-      alpha = create! 'Alpha', "{{#{Card::Name.joint}Beta}}"
-      create! 'Beta'
-      create! "#{alpha.name}#{Card::Name.joint}Beta", 'Woot'
-      assert_view_select alpha.format.render_core, 'div[class~=card-content]',
-                         'Woot'
-    end
-
-    it 'handles complex relative names' do
-      bob_city = create! 'bob+city', 'Sparta'
-      Card::Auth.as_bot do
-        create! 'address+*right+*structure', '{{_left+city}}'
-      end
-      bob_address = create! 'bob+address'
-
-      r = bob_address.reload.format.render_core
-      assert_view_select r, 'div[class~=card-content]', 'Sparta'
-      expect(Card.fetch('bob+address').includees.map(&:name))
-        .to eq([bob_city.name])
-    end
-
-    it 'handles nesting' do
-      alpha = create! 'Alpha', '{{Beta}}'
-      create! 'Beta', '{{Delta}}'
-      create! 'Delta', 'Booya'
-      r = alpha.format.render_core
-      assert_view_select r, 'div[class~=card-content]'
-      expect(r).to match(/Booya/)
-    end
-
-    it 'handles options when nesting' do
-      Card.create! type: 'Pointer', name: 'Livable', content: '[[Earth]]'
-      create! 'Earth'
-
-      expect(render_content('{{Livable|core;item:link}}'))
-        .to eq(render_content('{{Livable|core|link}}'))
-      expect(render_content('{{Livable|core;item:name}}'))
-        .to eq(render_content('{{Livable|core|name}}'))
-    end
-
-    it 'prevents recursion' do
-      create! 'Oak', '{{Quentin}}'
-      create! 'Quentin', '{{Admin}}'
-      adm = Card['Quentin']
-      adm.update_attributes content: '{{Oak}}'
-      result = adm.format.render_core
-      expect(result).to match('too deep')
-    end
-
-    it 'handles missing cards' do
-      @a = create! 'boo', 'hey {{+there}}'
-      r = @a.format.render_core
-      assert_view_select(
-        r, 'div[data-card-name="boo+there"][class~="missing-view"]'
-      )
-    end
-
-    it 'handles structured cards' do
-      create!('age')
-      Card['*template']
-      specialtype = Card.create type_code: 'Cardtype', name: 'SpecialType'
-      specialtype_template = specialtype.fetch(trait: :type, new: {})
-                                        .fetch(trait: :structure, new: {})
-      specialtype_template.content = "{{#{Card::Name.joint}age}}"
-      Card::Auth.as_bot { specialtype_template.save! }
-      assert_equal "{{#{Card::Name.joint}age}}",
-                   specialtype_template.format.render_raw
-
-      wooga = Card.create! name: 'Wooga', type: 'SpecialType'
-      wooga_age = create! "#{wooga.name}#{Card::Name.joint}age", '39'
-      expect(wooga_age.format.render_core).to eq('39')
-      expect(wooga_age.includers.map(&:name)).to eq(['Wooga'])
-    end
-
-    it 'handles shading' do
-      create! 'Alpha', 'Pooey'
-      create! 'Beta', '{{Alpha|shade:off}}'
-      r = create!('Bee', '{{Alpha|shade:off}}').format.render_core
-      assert_view_select r, 'div[style~="shade:off;"]' do
-        assert_select 'div[class~=card-content]', 'Pooey'
-      end
-      r = create!('Cee', '{{Alpha| shade: off }}').format.render_core
-      assert_view_select r, 'div[style~="shade:off;"]' do
-        assert_select 'div[class~=card-content]', 'Pooey'
-      end
-      r = create!('Dee', '{{Alpha| shade:off }}').format.render_core
-      assert_view_select r, 'div[style~="shade:off;"]' do
-        assert_select 'div[class~="card-content"]', 'Pooey'
-      end
-      r = create!('Eee', '{{Alpha| shade:on }}').format.render_core
-      assert_view_select r, 'div[style~="shade:on;"]' do
-        assert_select 'div[class~="card-content"]', 'Pooey'
-      end
-    end
-  end
-end

data/mod/05_standard/spec/chunk/link_spec.rb

@@ -1,98 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::Content::Chunk::Link do
-  def assert_link target, args
-    text = args.delete(:text)
-    format_args = args.delete(:format_args)
-    assert_args = ['a']
-    args.each_pair do |key, val|
-      assert_args[0] << "[#{key}=\"#{val}\"]"
-    end
-    assert_args << { text: text } if text
-    assert_view_select render_content(target, (format_args || {})), *assert_args
-  end
-
-  it 'handles unknown cards' do
-    assert_link '[[Nixon]]', class: 'wanted-card', href: '/Nixon', text: 'Nixon'
-  end
-
-  it 'handles known cards' do
-    assert_link '[[A]]', class: 'known-card', href: '/A', text: 'A'
-  end
-
-  it 'handles custom text' do
-    assert_link '[[Baines|Lyndon]]', class: 'wanted-card', href: '/Baines',
-                                     text: 'Lyndon'
-  end
-
-  it 'handles relative names' do
-    @card = Card.new name: 'Kennedy'
-    assert_link '[[+Monroe]]', class: 'wanted-card',
-                               href: '/Kennedy+Monroe',
-                               text: 'Kennedy+Monroe'
-    assert_link '[[_self+Exner]]', class: 'wanted-card',
-                                   href: '/Kennedy+Exner',
-                                   text: 'Kennedy+Exner'
-    assert_link '[[Onassis+]]', class: 'wanted-card',
-                                href: '/Onassis+Kennedy',
-                                text: 'Onassis+Kennedy'
-  end
-
-  it 'handles relative names in context' do
-    @card = Card.new name: 'Kennedy'
-    format_args = { context_names: ['Kennedy'.to_name] }
-    assert_link '[[+Monroe]]', format_args: format_args,
-                               class: 'wanted-card',
-                               href: '/Kennedy+Monroe',
-                               text: '+Monroe'
-    assert_link '[[_self+Exner]]', format_args: format_args,
-                                   class: 'wanted-card',
-                                   href: '/Kennedy+Exner',
-                                   text: '+Exner'
-    assert_link '[[Onassis+]]', format_args: format_args,
-                                class: 'wanted-card',
-                                href: '/Onassis+Kennedy',
-                                text: 'Onassis'
-  end
-
-  it 'handles relative urls' do
-    assert_link '[[/recent]]', class: 'internal-link',
-                               href: '/recent',
-                               text: '/recent'
-  end
-
-  it 'handles absolute urls' do
-    assert_link '[[http://google.com]]',
-                class: 'external-link', target: '_blank',
-                href: 'http://google.com', text: 'http://google.com'
-  end
-
-  it 'should escape spaces in cardnames with %20 (not +)' do
-    assert_link '[[Marie "Mad Dog" Deatherage|Marie]]',
-                class: 'wanted-card',
-                href: '/Marie_Mad_Dog_Deatherage' \
-                      '?card%5Bname%5D=Marie+%22Mad+Dog%22+Deatherage',
-                text: 'Marie'
-  end
-
-  it "doesn't escape content outside of link" do
-    content =
-      render_content 'wgw&nbsp; [[http://www.google.com|google]] &nbsp;  <br>'
-    expect(content).to eq(
-      'wgw&nbsp; <a target="_blank" class="external-link" ' \
-      'href="http://www.google.com">google</a> &nbsp;  <br>'
-    )
-  end
-
-  it 'handles nests in link text' do
-    assert_link '[[linkies|{{namies|name}}]]',
-                class: 'wanted-card', href: '/linkies', text: 'namies'
-  end
-
-  it 'handles dot (.) in missing cardlink' do
-    assert_link '[[Wagn 1.10.12]]',
-                class: 'wanted-card',
-                href: '/Wagn_1_10_12?card%5Bname%5D=Wagn+1.10.12',
-                text: 'Wagn 1.10.12'
-  end
-end

data/mod/05_standard/spec/chunk/query_reference_spec.rb

@@ -1,49 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::Content::Chunk::QueryReference, 'QueryReference' do
-  context 'syntax parsing' do
-    before do
-      @class = Card::Content::Chunk::QueryReference
-    end
-
-    let :query_refs do
-      content = Card::Content.new @content, Card.new(type: 'Search')
-      content.find_chunks(Card::Content::Chunk::QueryReference)
-    end
-
-    subject { query_refs.first.name }
-
-    it 'handles simple search' do
-      @content = '{"name":"Waldo"}'
-      is_expected.to eq 'Waldo'
-    end
-
-    it 'handles operators' do
-      @content = '{"name":["eq","Waldo"]}'
-      is_expected.to eq 'Waldo'
-    end
-
-    it 'handles multiple values for operators' do
-      @content = '{"name":["in","Where","Waldo"]}'
-      expect(query_refs[1].name).to eq 'Waldo'
-    end
-
-    it 'handles plus attributes' do
-      @content = '{"right_plus":["Waldo",{"content":"here"}]}'
-      is_expected.to eq 'Waldo'
-    end
-
-    it 'handles nested query structures' do
-      @content = '{"any":{"content":"Where", ' \
-                 '"right_plus":["is",{"name":"Waldo"}]}}'
-      expect(query_refs[0].name).to eq 'Where'
-      expect(query_refs[1].name).to eq 'is'
-      expect(query_refs[2].name).to eq 'Waldo'
-    end
-
-    it 'handles contextual names' do
-      @content = '{"name":"_+Waldo"}'
-      is_expected.to eq '_+Waldo'
-    end
-  end
-end

data/mod/05_standard/spec/format/css_format_spec.rb

@@ -1,5 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::CssFormat do
-  # SPECSTUB
-end