card 1.18.6 → 1.19.0

data/mod/02_basic_types/set/type/html.rb

@@ -1,23 +0,0 @@
-def clean_html?
-  false
-end
-
-def diff_args
-  { format: :raw }
-end
-
-format do
-  view :closed_content do |_args|
-    ''
-  end
-
-  def chunk_list
-    :references
-  end
-end
-
-format :html do
-  view :editor do |_args|
-    text_area :content, rows: 5, class: 'card-content ace-editor-textarea', 'data-card-type-code' => card.type_code
-  end
-end

data/mod/02_basic_types/set/type/plain_text.rb

@@ -1,12 +0,0 @@
-format :html do
-  view :editor do |_args|
-    text_area :content,
-              rows: 5,
-              class: 'card-content',
-              'data-card-type-code' => card.type_code
-  end
-
-  view :core do |_args|
-    process_content_object(CGI.escapeHTML _render_raw)
-  end
-end

data/mod/02_basic_types/set/type/pointer.rb

@@ -1,384 +0,0 @@
-
-event :add_and_drop_items, :prepare_to_validate, on: :save do
-  adds = Env.params['add_item']
-  drops = Env.params['drop_item']
-  Array.wrap(adds).each { |i| add_item i } if adds
-  Array.wrap(drops).each { |i| drop_item i } if drops
-end
-
-event :insert_item_event, :prepare_to_validate,
-      on: :save, when: proc { Env.params['insert_item'] } do
-  index = Env.params['item_index'] || 0
-  insert_item index.to_i, Env.params['insert_item']
-end
-
-stage_method :changed_item_names do
-  dropped_item_names + added_item_names
-end
-
-stage_method :dropped_item_names do
-  old_items = item_names content: db_content_was
-  old_items - item_names
-end
-
-stage_method :added_item_names do
-  old_items = item_names content: db_content_was
-  item_names - old_items
-end
-
-format do
-  def item_links args={}
-    card.item_cards(args).map do |item_card|
-      subformat(item_card).render_link
-    end
-  end
-
-  def wrap_item item, _args={}
-    item # no wrap in base
-  end
-
-  view :core do |args|
-    render_pointer_items args.merge(joint: ', ')
-  end
-
-  view :pointer_items, tags: :unknown_ok do |args|
-    i_args = item_args(args)
-    joint = args[:joint] || ' '
-    card.item_cards.map do |i_card|
-      wrap_item nest(i_card, i_args.clone), i_args
-    end.join joint
-  end
-end
-
-format :html do
-  view :core do |args|
-    %(<div class="pointer-list">#{render_pointer_items args}</div>)
-  end
-
-  view :closed_content do |args|
-    args[:item] =
-      if (args[:item] || nest_defaults(card)[:view]) == 'name'
-        'name'
-      else
-        'link'
-      end
-    args[:joint] ||= ', '
-    _render_core args
-  end
-
-  #  view :edit do |args|
-  #    super(args.merge(pointer_item_class: 'form-control'))
-  #  end
-
-  view :editor do |args|
-    part_view = (c = card.rule(:input)) ? c.gsub(/[\[\]]/, '') : :list
-    hidden_field(:content, class: 'card-content') +
-      raw(_render(part_view, args))
-    # .merge(pointer_item_class: 'form-control')))
-  end
-
-  def options_card_name
-    (oc = card.options_rule_card) ? oc.cardname.url_key : ':all'
-  end
-
-  view :list do |args|
-    args ||= {}
-    items = args[:item_list] || card.item_names(context: :raw)
-    items = [''] if items.empty?
-    extra_css_class = args[:extra_css_class] || 'pointer-list-ul'
-
-    <<-HTML
-      <ul class="pointer-list-editor #{extra_css_class}" data-options-card="#{options_card_name}">
-        #{items.map do |item|
-            _render_list_item args.merge(pointer_item: item)
-          end.join "\n"}
-      </ul>
-      #{add_item_button}
-    HTML
-  end
-
-  def add_item_button
-    content_tag :span, class: 'input-group' do
-      button_tag class: 'pointer-item-add' do
-        glyphicon('plus') + ' add another'
-      end
-    end
-  end
-
-  view :list_item do |args|
-    <<-HTML
-      <li class="pointer-li">
-        <span class="input-group">
-          <span class="input-group-addon handle">
-            #{glyphicon 'option-vertical left'}
-            #{glyphicon 'option-vertical right'}
-          </span>
-          #{text_field_tag 'pointer_item', args[:pointer_item],
-                           class: 'pointer-item-text form-control'}
-          <span class="input-group-btn">
-            <button class="pointer-item-delete btn btn-default" type="button">
-              #{glyphicon 'remove'}
-            </button>
-          </span>
-        </span>
-      </li>
-    HTML
-  end
-
-  view :checkbox do |_args|
-    options = card.option_names.map do |option_name|
-      checked = card.item_names.include?(option_name)
-      o_card = Card.fetch option_name
-      label = (o_card && o_card.label) || option_name
-      id = "pointer-checkbox-#{option_name.to_name.key}"
-      description = pointer_option_description option_name
-      <<-HTML
-        <div class="pointer-checkbox">
-          #{check_box_tag 'pointer_checkbox', option_name, checked, id: id, class: 'pointer-checkbox-button'}
-          <label for="#{id}">#{label}</label>
-          #{%(<div class="checkbox-option-description">#{description}</div>) if description}
-        </div>
-      HTML
-    end.join "\n"
-
-    %(<div class="pointer-checkbox-list">#{options}</div>)
-  end
-
-  view :multiselect do |_args|
-    select_tag(
-      'pointer_multiselect',
-      options_for_select(card.option_names, card.item_names),
-      multiple: true, class: 'pointer-multiselect form-control'
-    )
-  end
-
-  view :radio do |_args|
-    input_name = "pointer_radio_button-#{card.key}"
-    options = card.option_names.map do |option_name|
-      checked = (option_name == card.item_names.first)
-      id = "pointer-radio-#{option_name.to_name.key}"
-      label = ((o_card = Card.fetch(option_name)) && o_card.label) || option_name
-      description = pointer_option_description option_name
-      <<-HTML
-        <li class="pointer-radio radio">
-          #{radio_button_tag input_name, option_name, checked, id: id, class: 'pointer-radio-button'}
-          <label for="#{id}">#{label}</label>
-          #{%(<div class="radio-option-description">#{description}</div>) if description}
-        </li>
-      HTML
-    end.join("\n")
-
-    %(<ul class="pointer-radio-list">#{options}</ul>)
-  end
-
-  view :select do |_args|
-    options = [['-- Select --', '']] + card.option_names.map { |x| [x, x] }
-    select_tag('pointer_select',
-               options_for_select(options, card.item_names.first),
-               class: 'pointer-select form-control'
-              )
-  end
-
-  def pointer_option_description option
-    pod_name = card.rule(:options_label) || 'description'
-    dcard = Card["#{option}+#{pod_name}"]
-    if dcard && dcard.ok?(:read)
-      with_nest_mode :normal do
-        subformat(dcard).render_core
-      end
-    end
-  end
-
-  def wrap_item item, args
-    %(<div class="pointer-item item-#{args[:view]}">#{item}</div>)
-  end
-end
-
-format :css do
-  # generalize to all collections?
-  def default_item_view
-    params[:item] || :content
-  end
-
-  view :titled do |_args|
-    %(#{major_comment "STYLE GROUP: \"#{card.name}\"", '='}#{_render_core})
-  end
-
-  view :core do |args|
-    card.item_cards.map do |item|
-      nest item, view: item_view(args)
-    end.join "\n\n"
-  end
-
-  view :content, :core
-end
-
-format :js do
-  view :core do |args|
-    card.item_cards.map do |item|
-      nest item, view: (args[:item] || :core)
-    end.join "\n\n"
-  end
-end
-
-format :data do
-  view :core do |_args|
-    card.item_cards.map do |c|
-      nest c
-    end
-  end
-end
-
-format :rss do
-  def raw_feed_items _args
-    @raw_feed_items ||= begin
-      card.item_cards
-    end
-  end
-end
-
-# while a card's card type and content are updated in the same request,
-# the new module will override the old module's events and functions.
-# this event is only on pointer card. Other type cards do not have this event,
-# so it is not overridden and will be run while updating type and content in
-# the same request.
-event :standardize_items, :prepare_to_validate,
-      on: :save,
-      changed: :content,
-      when: proc { |c| c.type_id == Card::PointerID  } do
-  self.content = item_names(context: :raw).map do |name|
-    "[[#{name}]]"
-  end.join "\n"
-end
-
-def diff_args
-  { format: :pointer }
-end
-
-def item_cards args={}
-  if args[:complete]
-    query = args.reverse_merge referred_to_by: name
-    Card::Query.run query
-  elsif args[:known_only]
-    known_item_cards args
-  else
-    fetch_or_initialize_item_cards args
-  end
-end
-
-def known_item_cards args={}
-  item_names(args).map do |name|
-    Card.fetch name
-  end.compact
-end
-
-def fetch_or_initialize_item_cards args
-  itype = args[:type] || item_type
-  new_args = itype ? { type: itype } : {}
-  item_names(args).map do |name|
-    Card.fetch name, new: new_args
-  end
-end
-
-def item_names args={}
-  context = args[:context] || cardname
-  content = args[:content] || raw_content
-  content.to_s.split(/\n+/).map do |line|
-    item_name = line.gsub(/\[\[|\]\]/, '').strip
-    if context == :raw
-      item_name
-    else
-      item_name.to_name.to_absolute context
-    end
-  end
-end
-
-def item_ids args={}
-  item_names(args).map do |name|
-    Card.fetch_id name
-  end.compact
-end
-
-def item_type
-  opt = options_rule_card
-  if !opt || opt == self # fixme, need better recursion prevention
-    nil
-  else
-    opt.item_type
-  end
-end
-
-def items= array
-  self.content = ''
-  array.each { |i| self << i }
-  save!
-end
-
-def << item
-  newname =
-    case item
-    when Card    then item.name
-    when Integer then (c = Card[item]) && c.name
-    else              item
-    end
-  add_item newname
-end
-
-def add_item name
-  return if include_item? name
-  self.content = "[[#{(item_names << name).reject(&:blank?) * "]]\n[["}]]"
-end
-
-def add_item! name
-  add_item name
-  save!
-end
-
-def drop_item name
-  return unless include_item? name
-  key = name.to_name.key
-  new_names = item_names.reject { |n| n.to_name.key == key }
-  self.content = new_names.empty? ? '' : "[[#{new_names * "]]\n[["}]]"
-end
-
-def drop_item! name
-  drop_item name
-  save!
-end
-
-def insert_item index, name
-  new_names = item_names
-  new_names.delete name
-  new_names.insert index, name
-  self.content = new_names.map { |new_name| "[[#{new_name}]]" }.join "\n"
-end
-
-def insert_item! index, name
-  insert_item index, name
-  save!
-end
-
-def options_rule_card
-  rule_card :options
-end
-
-def option_names
-  result_names =
-    if (oc = options_rule_card)
-      oc.item_names default_limit: 50, context: name
-    else
-      Card.search({ sort: 'name', limit: 50, return: :name },
-                  "option names for pointer: #{name}")
-    end
-  if (selected_options = item_names)
-    result_names += selected_options
-    result_names.uniq!
-  end
-  result_names
-end
-
-def option_cards
-  option_names.map do |name|
-    Card.fetch name, new: {}
-  end
-end

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

@@ -1,10 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-describe Card::Set::All::AllCss do
-  it 'should render content view' do
-    content = '#box { display: block }'
-    rendered = render_card :content, { content: content }, format: :css
-    #    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,11 +0,0 @@
-# -*- encoding : utf-8 -*-
-
-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

@@ -1,89 +0,0 @@
-# -*- encoding : utf-8 -*-
-require 'rspec-html-matchers'
-
-describe Card::Set::All::Base do
-  describe 'handles view' do
-    describe 'name view' do
-      it('name') { expect(render_card(:name)).to eq('Tempo Rary') }
-      it 'pluralizes' do
-        name = render_content '{{Joe User|name; variant: plural}}'
-        expect(name).to eq('Joe Users')
-      end
-      it 'singularizes' do
-        name = render_content '{{Sunglasses|name; variant: singular}}'
-        expect(name).to eq('Sunglass')
-      end
-      it 'handles more than one variant' do
-        name = render_content(
-          '{{Sunglasses|name; variant: singular, upcase}}'
-        )
-        expect(name).to eq('SUNGLASS')
-      end
-    end
-
-    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://'
-      Card::Env[:host]     = 'eric.skippy.com'
-      expect(render_card(:url)).to eq('http://eric.skippy.com/Tempo_Rary')
-    end
-
-    it :raw do
-      @a = Card.new content: '{{A}}'
-      expect(@a.format._render(:raw)).to eq('{{A}}')
-    end
-
-    it 'core' do
-      expect(render_card(:core, name: 'A+B')).to eq('AlphaBeta')
-    end
-
-    it 'core for new card' do
-      expect(Card.new.format._render_core).to eq('')
-    end
-
-    describe 'array' 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"'
-        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"]))
-      end
-
-      it 'of pointer items' do
-        Card.create! name: 'n+a', type: 'Number', content: '10'
-        Card.create! name: 'n+b', type: 'Number', content: '20'
-        Card.create! name: 'n+c', type: 'Number', content: '30'
-        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"]))
-      end
-
-      it 'of basic items' do
-        expect(render_card(:array, content: 'yoing')).to eq(%(["yoing"]))
-      end
-    end
-    it 'renders template rule of embed cards based on set' do
-      Card::Auth.as_bot
-      content = '{{_left+test_another_card|content|content;'\
-                'structure:test_another_card_structure}}'
-      card = Card.create! name: 'test_card+*right+*structure',
-                          type_id: Card::HTMLID, content: content
-      Card.create! name: 'test_another_card+*right+*structure',
-                   type_id: Card::SearchTypeID,
-                   content: ' {"type":"basic","left":"_1"}'
-      html = card.format.render_open
-      href = '/test_another_card+*right?view=template_editor'
-      text = '_left+test_another_card|content|content;'\
-             'structure:test_another_card_structure'
-      expect(html).to have_tag('a', with: { class: 'slotter', href: href },
-                                    text: text)
-    end
-  end
-end