card 1.18.6 → 1.19.0

data/mod/06_bootstrap/set/all/bootstrap/table.rb

@@ -1,55 +0,0 @@
-format :html do
-  # @param [Array<Array,String>] content the content for the table. Accepts
-  # strings or arrays for each row.
-  # @param [Hash] opts
-  # @option opts [String, Array] :header use first row of content as header or
-  # value of this option if it is a string
-  # @return [HTML] bootstrap table
-  def table content, opts={}
-    add_class opts, 'table'
-    if opts[:header]
-      header = opts[:header].is_a?(Array) ? opts[:header] : content.shift
-    end
-    wrap_with :table, class: opts[:class] do
-      [
-        (table_header(header) if header),
-        table_body(content)
-      ]
-    end
-  end
-
-  def table_header entries
-    content_tag :thead do
-      content_tag :tr do
-        entries.map do |item|
-          content_tag :th, item
-        end.join "\n"
-      end
-    end
-  end
-
-  def table_body rows
-    content_tag :tbody do
-      rows.map do |row|
-        table_row row
-      end.join "\n"
-    end
-  end
-
-  def table_row row
-    row_content =
-      if row.is_a? Array
-        row.map do |item|
-          if item.is_a? Hash
-            content_tag :td, item.delete(:content), item
-          else
-            content_tag :td, item
-          end
-        end.join "\n"
-      else
-        row
-      end
-
-    content_tag :tr, row_content.html_safe
-  end
-end

data/mod/06_bootstrap/set/all/bootstrap/tabs.rb

@@ -1,81 +0,0 @@
-format :html do
-  # @param tab_type [String] 'tabs' or 'pills'
-  # @param tabs [Hash] keys are the labels, values the content for the tabs
-  # @param active_name [String] label of the tab that should be active at the
-  # beginning (default is the first)
-  # @return [HTML] bootstrap tabs element with all content preloaded
-  def static_tabs tabs, active_name=nil,  tab_type='tabs'
-    tab_buttons = ''
-    tab_panes = ''
-    tabs.each do |tab_name, tab_content|
-      active_name ||= tab_name
-      active_tab = (tab_name == active_name)
-      id = "#{card.cardname.safe_key}-#{tab_name.to_name.safe_key}"
-      tab_buttons += tab_button("##{id}", tab_name, active_tab)
-      tab_panes += tab_pane(id, tab_content, active_tab)
-    end
-    tab_panel tab_buttons, tab_panes, tab_type
-  end
-
-  # @param [Hash] tabs keys are the labels for the tabs, values the urls to
-  # load the content from
-  # @param [String] active_name label of the tab that should be active at the
-  # beginning
-  # @param [String] active_content content of the active tab
-  # @param [Hash] args options
-  # @option args [String] :type ('tabs') use pills or tabs
-  # @option args [Hash] :panel_args html args used for the panel div
-  # @option args [Hash] :pane_args html args used for the pane div
-  # @return [HTML] bootstrap tabs element with content only for the active
-  # tab; other tabs get loaded via ajax when selected
-  def lazy_loading_tabs tabs, active_name, active_content, args={}
-    tab_buttons = ''
-    tab_panes = ''
-    tabs.each do |tab_name, url|
-      active_tab = (active_name == tab_name)
-      id = "#{card.cardname.safe_key}-#{tab_name.to_name.safe_key}"
-      tab_buttons += tab_button(
-        "##{id}", tab_name, active_tab,
-        'data-url' => url.html_safe,
-        class: (active_tab ? nil : 'load')
-      )
-      tab_content = active_tab ? active_content : ''
-      tab_panes += tab_pane(id, tab_content, active_tab, args[:pane_args])
-    end
-    tab_type = args.delete(:type) || 'tabs'
-    tab_panel tab_buttons, tab_panes, tab_type, args[:panel_args]
-  end
-
-  def tab_panel tab_buttons, tab_panes, tab_type='tabs', args=nil
-    args ||= {}
-    add_class args, 'tabbable'
-    args.reverse_merge! role: 'tabpanel'
-    wrap_with :div, args do
-      [
-        content_tag(:ul, tab_buttons.html_safe,
-                    class: "nav nav-#{tab_type}",
-                    role: 'tablist'),
-        content_tag(:div, tab_panes.html_safe, class: 'tab-content')
-      ]
-    end
-  end
-
-  def tab_button target, text, active=false, link_attr={}
-    link = link_to(
-      fancy_title(text),
-      target,
-      link_attr.merge('role' => 'tab', 'data-toggle' => 'tab'))
-    li_args = { role: :presentation }
-    li_args[:class] = 'active' if active
-    content_tag :li, link, li_args
-  end
-
-  def tab_pane id, content, active=false, args=nil
-    args ||= {}
-    args.reverse_merge! role: :tabpanel,
-                        id: id
-    add_class args, 'tab-pane'
-    add_class args, 'active' if active
-    content_tag :div, content.html_safe, args
-  end
-end

data/mod/06_bootstrap/set/all/bootstrap/wrapper.rb

@@ -1,11 +0,0 @@
-format :html do
-  def frame args={}, &_block
-    args.reverse_merge!(
-      panel_class:  'panel panel-default',
-      header_class: 'panel-heading',
-      title_class:  'panel-title',
-      body_class:   'panel-body'
-    )
-    super args
-  end
-end

data/mod/06_bootstrap/set/all/rich_bootstrap.rb

@@ -1,6 +0,0 @@
-format :html do
-  view :closed do |args|
-    args[:body_class] = 'closed-content'
-    super args
-  end
-end

data/mod/06_bootstrap/set/self/bootstrap_js.rb

@@ -1,5 +0,0 @@
-include_set Abstract::CodeFile
-
-def source_files
-  %w( bootstrap.js bootstrap_modal_wagn.js )
-end

data/mod/06_bootstrap/set/self/bootswatch_shared.rb

@@ -1,40 +0,0 @@
-include_set Abstract::CodeFile
-
-view :raw do |_args|
-  bootstrap_path = File.join Cardio.gem_root, 'mod',
-                             card.file_content_mod_name, 'lib',
-                             'stylesheets', 'bootstrap'
-
-  # variables
-  content = File.read("#{bootstrap_path}/_variables.scss")
-  content += %(
-      $bootstrap-sass-asset-helper: false;
-      $icon-font-path: "#{card_path 'assets/fonts/'}";
-    )
-  # mixins
-  content += Dir.glob("#{bootstrap_path}/mixins/*.scss").map do |name|
-    File.read name
-  end.join("\n")
-  content += [
-    # Reset and dependencies
-    %w(normalize print glyphicons),
-    # Core CSS
-    %w(scaffolding type code grid tables forms buttons),
-    # Components
-    %w(component-animations dropdowns button-groups input-groups navs navbar
-       breadcrumbs pagination pager labels badges jumbotron thumbnails alerts
-       progress-bars media list-group panels responsive-embed wells close),
-    # Components w/ JavaScript
-    %w(modals tooltip popovers carousel),
-    # Utility classes
-    %w(utilities responsive-utilities)
-  ].map do |names|
-    names.map do |name|
-      path = File.join(bootstrap_path, "_#{name}.scss")
-      Rails.logger.info "reading file: #{path}"
-      File.read path
-    end.join "\n"
-  end.join "\n"
-
-  content
-end

data/mod/06_bootstrap/set/self/smartmenu_css.rb

@@ -1,5 +0,0 @@
-include_set Abstract::CodeFile
-
-def source_files
-  'startmenu.css'
-end

data/mod/06_bootstrap/set/self/smartmenu_js.rb

@@ -1,5 +0,0 @@
-include_set Abstract::CodeFile
-
-def source_files
-  'startmenu.js'
-end

data/mod/06_bootstrap/spec/set/all/bootstrap/form_spec.rb

@@ -1,13 +0,0 @@
-describe Card::Set::All::Bootstrap::Form  do
-  describe 'input' do
-    it 'has form-group css class' do
-      assert_view_select render_editor('Phrase'), 'input[type="text"][class~="form-control"]'
-    end
-  end
-
-  describe 'textarea' do
-    it 'has form-group css class' do
-      assert_view_select render_editor('Plain Text'), 'textarea[class~="form-control"]'
-    end
-  end
-end

data/tmpsets/README.md

@@ -1,2 +0,0 @@
-# decko-tmpsets
-default processed tmp/set and tmp/set_pattern directories for use in wagn/decko documentation

data/tmpsets/set/mod001-01_core/all/active_card.rb

@@ -1,41 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; module All; module ActiveCard; extend Card::Set
-# ~~~~~~~~~~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/01_core/set/all/active_card.rb ~~~~~~~~~~~
-=begin
-
-# following may be useful, but is neither tested nor in use
-
-def card_attributes
-  if Card::Set.traits
-    set_modules.each do |mod|
-      if mod_traits = Card::Set.traits[mod]
-        return mod_traits
-      end
-    end
-  end
-  nil
-end
-
-def trait_var? var_name
-  !instance_variable_get( var_name ).nil?
-end
-
-=end
-
-def trait_var var_name, &block
-  # FIXME - following optimization attempt needs to handle cache clearing!
-#  instance_variable_get var_name or begin
-#    instance_variable_set var_name, block_given? ? yield : raise("no block?")
-#  end
-  yield
-end
-
-#fixme -this needs a better home!
-def format opts={}
-  opts = { format: opts.to_sym } if [Symbol, String].member? opts.class
-
-  Card::Format.new self, opts
-end
-
-# ~~~~~~~~~~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/01_core/set/all/active_card.rb ~~~~~~~~~~~
-end;end;end;end;

data/tmpsets/set/mod001-01_core/all/collection.rb

@@ -1,348 +0,0 @@
-# -*- encoding : utf-8 -*-
-class Card; module Set; module All; module Collection; extend Card::Set
-# ~~~~~~~~~~~ above autogenerated; below pulled from /Users/ethan/dev/wagn/gem/card/mod/01_core/set/all/collection.rb ~~~~~~~~~~~
-
-module ClassMethods
-  def search spec, comment=nil
-    results = ::Card::Query.run(spec, comment)
-    if block_given? && results.is_a?(Array)
-      results.each { |result| yield result }
-    end
-    results
-  end
-
-  def count_by_wql spec
-    spec = spec.clone
-    spec.delete(:offset)
-    search spec.merge(return: 'count')
-  end
-
-  def find_each options={}
-    # this is a copy from rails (3.2.16) and is needed because this
-    # is performed by a relation (ActiveRecord::Relation)
-    find_in_batches(options) do |records|
-      records.each { |record| yield record }
-    end
-  end
-
-  def find_in_batches options={}
-    if block_given?
-      super(options) do |records|
-        yield(records)
-        Card::Cache.reset_all
-      end
-    else
-      super(options)
-    end
-  end
-end
-
-def item_names _args={}
-  format._render_raw.split /[,\n]/
-end
-
-def item_cards _args={} # FIXME: this is inconsistent with item_names
-  [self]
-end
-
-def item_type
-  nil
-end
-
-def item_keys args={}
-  item_names(args).map do |item|
-    item.to_name.key
-  end
-end
-
-def include_item? item
-  key = item.is_a?(Card) ? item.cardname.key : item.to_name.key
-  item_names.map { |name| name.to_name.key }.member? key
-end
-
-def add_item item
-  return if include_item? item
-  self.content = "#{content}\n#{name}"
-end
-
-def drop_item item
-  return unless include_item? item
-  new_names = item_names.reject { |i| i == item }
-  self.content = new_names.empty? ? '' : new_names.join("\n")
-end
-
-def insert_item index, name
-  new_names = item_names
-  new_names.delete name
-  new_names.insert index, name
-  self.content = new_names.join "\n"
-end
-
-def extended_item_cards context = nil
-  context = (context ? context.cardname : cardname)
-  args = { limit: '' }
-  items = item_cards(args.merge(context: context))
-  extended_list = []
-  already_extended = ::Set.new # avoid loops
-
-  while items.size > 0
-    item = items.shift
-    if already_extended.include? item
-      next
-    elsif item.item_cards == [item]  # no further level of items
-      extended_list << item
-      already_extended << item
-    else
-      items.unshift(*item.item_cards) # keep items in order
-      already_extended << item
-    end
-  end
-  extended_list
-end
-
-def extended_item_contents context=nil
-  extended_item_cards(context).map(&:item_names).flatten
-end
-
-def extended_list context=nil
-  context = (context ? context.cardname : cardname)
-  args = { limit: '' }
-  item_cards(args.merge(context: context)).map do |x|
-    x.item_cards(args)
-  end.flatten.map do |x|
-    x.item_cards(args)
-  end.flatten.map do |y|
-    y.item_names(args)
-  end.flatten
-  # this could go on and on.  more elegant to recurse until you don't have
-  # a collection
-end
-
-def contextual_content context_card, format_args={}, view_args={}
-  context_card.format(format_args).process_content(
-    format(format_args)._render_raw(view_args), view_args
-  )
-end
-
-format do
-  def item_links _args={}
-    raw(render_core).split /[,\n]/
-  end
-
-  def item_view args
-    args[:item] ||
-      (@inclusion_opts && @inclusion_opts[:view]) ||
-      default_item_view
-  end
-
-  def item_args args
-    i_args = { view: item_view(args) }
-    if (type = card.item_type)
-      i_args[:type] = type
-    end
-    i_args
-  end
-
-  def search_params
-    @search_params ||= begin
-      p = default_search_params.clone
-
-      if focal?
-        p[:offset] = params[:offset] if params[:offset]
-        p[:limit]  = params[:limit]  if params[:limit]
-        p.merge! params[:wql]        if params[:wql]
-      end
-      p
-    end
-  end
-
-  def default_search_params # wahh?
-    set_default_search_params
-  end
-
-  def set_default_search_params overrides={}
-    @default_search_params ||= begin
-      p = { default_limit: 100 }.merge overrides
-      set_search_params_variables! p
-      p
-    end
-  end
-
-  def set_search_params_variables! hash
-    hash[:vars] = params[:vars] || {}
-    params.each do |key, val|
-      case key.to_s
-      when '_wql'      then hash.merge! val
-      when /^\_(\w+)$/ then hash[:vars][$1.to_sym] = val
-      end
-    end
-  end
-
-  def each_reference_with_args args={}
-    content_object = Card::Content.new _render_raw(args), card
-    content_object.find_chunks(Card::Chunk::Reference).each do |chunk|
-      yield chunk.referee_name.to_s, nest_args(args, chunk)
-    end
-  end
-
-  def each_nested_chunk args={}
-    content_object = Card::Content.new(_render_raw(args), card)
-    content_object.find_chunks(Card::Chunk::Include).each do |chunk|
-      yield(chunk) if chunk.referee_name # filter commented nests
-    end
-  end
-
-  def nested_fields args={}
-    result = []
-    each_nested_field(args) do |chunk|
-      result << chunk
-    end
-    result
-  end
-
-  def unique_chunks chunk, processed_set, &block
-    return if processed_set.include? chunk.referee_name.key
-    processed_set << chunk.referee_name.key
-    block.call(chunk)
-  end
-
-  def each_nested_field args, &block
-    processed_chunk_keys = ::Set.new([card.key])
-
-    each_nested_chunk(args) do |chunk|
-      # TODO: handle structures that are non-virtual
-      if chunk.referee_name.to_name.field_of? card.name
-        if chunk.referee_card &&
-           chunk.referee_card.virtual? &&
-           !processed_chunk_keys.include?(chunk.referee_name.key)
-
-          processed_chunk_keys << chunk.referee_name.key
-          subformat(chunk.referee_card).each_nested_field(args) do |sub_chunk|
-            unique_chunks sub_chunk, processed_chunk_keys, &block
-          end
-        else
-          unique_chunks chunk, processed_chunk_keys, &block
-        end
-      end
-    end
-  end
-
-  def map_references_with_args args={}, &block
-    result = []
-    each_reference_with_args args do |name, n_args|
-      result << block.call(name, n_args)
-    end
-    result
-  end
-
-  # process args for links and nests
-  def nest_args args, chunk=nil
-    r_args = item_args(args)
-    r_args.merge! @inclusion_opts.clone if @inclusion_opts
-
-    case chunk
-    when Card::Chunk::Include
-      r_args.merge!(chunk.options)
-    when Card::Chunk::Link
-      r_args.reverse_merge!(view: :link)
-      r_args.reverse_merge!(title: chunk.link_text) if chunk.link_text
-    end
-    r_args
-  end
-end
-
-format :html do
-  view :count do |args|
-    card.item_names(args).size
-  end
-
-  view :tabs do |args|
-    tab_buttons = ''
-    tab_panes = ''
-    active_tab = true
-    each_reference_with_args(item: :content) do |name, nest_args|
-      id         = "#{card.cardname.safe_key}-#{name.to_name.safe_key}"
-      url        = nest_path name, nest_args
-      tab_name   = nest_args[:title] || name
-      tab_buttons += tab_button(
-        "##{id}", tab_name, active_tab, 'data-url' => url.html_safe,
-                                        class: (active_tab ? nil : 'load'))
-
-      # only render the first active tab, other tabs get loaded via ajax
-      tab_content = active_tab ? nest(Card.fetch(name, new: {}), nest_args) : ''
-      tab_panes += tab_pane(id, tab_content, active_tab)
-      active_tab = false
-    end
-    tab_panel tab_buttons, tab_panes, args[:tab_type]
-  end
-  def default_tabs_args args
-    args[:tab_type] ||= 'tabs'
-  end
-
-  # create a path for a nest with respect ot the inclusion options
-  def nest_path name, nest_args
-    path_args = {}
-    path_args[:view] = nest_args[:view]
-    path_args[:slot] = nest_args.clone
-    path_args[:slot].delete(:view)
-    page_path(name, path_args)
-  end
-
-  view :pills, view: :tabs
-  def default_pills_args args
-    args[:tab_type] ||= 'pills'
-  end
-
-  view :tabs_static do |args|
-    tab_buttons = ''
-    tab_panes = ''
-    card.item_cards.each_with_index do |item, index|
-      id = "#{card.cardname.safe_key}-#{item.cardname.safe_key}"
-      tab_buttons += tab_button("##{id}", item.name, index == 0)
-      tab_content = nest item, item_args(args)
-      tab_panes += tab_pane(id, tab_content, index == 0)
-    end
-    tab_panel tab_buttons, tab_panes, args[:tab_type]
-  end
-  def default_tabs_static_args args
-    args[:tab_type] ||= 'tabs'
-  end
-
-  view :pills_static, view: :tabs_static
-  def default_tabs_static_args args
-    args[:tab_type] ||= 'pills'
-  end
-
-  def tab_panel tab_buttons, tab_panes, tab_type='tabs'
-    wrap_with :div, role: 'tabpanel' do
-      [
-        content_tag(:ul, tab_buttons.html_safe, class: "nav nav-#{tab_type}",
-                                                role: 'tablist'),
-        content_tag(:div, tab_panes.html_safe, class: 'tab-content')
-      ]
-    end
-  end
-
-  def tab_button target, text, active=false, link_attr={}
-    link = link_to(
-      fancy_title(text),
-      target,
-      link_attr.merge('role' => 'tab', 'data-toggle' => 'tab'))
-    li_args = { role: :presentation }
-    li_args[:class] = 'active' if active
-    content_tag :li, link, li_args
-  end
-
-  def tab_pane id, content, active=false
-    div_args = {
-      role: :tabpanel,
-      id: id,
-      class: "tab-pane #{'active' if active}"
-    }
-    content_tag :div, content.html_safe, div_args
-  end
-end
-
-
-# ~~~~~~~~~~~ below autogenerated; above pulled from /Users/ethan/dev/wagn/gem/card/mod/01_core/set/all/collection.rb ~~~~~~~~~~~
-end;end;end;end;