fleetio_spark 0.2.48 → 1.0.0.rc.1

data/app/components/spark/nav/pills_component.rb

@@ -1,28 +0,0 @@
-class Nav::PillsComponent < SparkComponents::Component
-  base_class "spark-nav-pills"
-  root_attr role: "navigation"
-  attribute layout: :flush
-
-  aria_attr :label
-  validates :label, presence: true
-  validates_choice :layout, %i[padded flush]
-
-  element :item, multiple: true, component: "nav/item"
-
-  def before_render
-    add_class %(layout-#{layout})
-  end
-
-  def render
-    return if items.empty?
-    content_tag(:nav, tag_attrs) do
-      content_tag(:div, class: "nav-pills-wrapper") {
-        concat content_tag(:ul, class: "spark-nav-group") {
-          items.each { |item|
-            concat content_tag(:li, item, class: "nav-pill-wrapper #{item.active? ? "active" : nil}")
-          }
-        }
-      }
-    end
-  end
-end

data/app/components/spark/nav/sidebar_component.rb

@@ -1,59 +0,0 @@
-class Nav::SidebarComponent < SparkComponents::Component
-  aria_attr :label
-  validates :label, presence: true
-
-  base_class "spark-nav-sidebar"
-
-  element :header
-  element :footer
-  element :group, component: "nav/group", multiple: true do
-    attribute :title
-
-    def render
-      @view.capture do
-        concat content_tag(:h4, title, class: parent.join_class("title")) unless title.blank?
-        concat super
-      end
-    end
-  end
-
-  def before_render
-    data_attr nav_id: unique_id
-  end
-
-  def render
-    content_tag(:nav, tag_attrs) do
-      concat sidebar_toggle_tag
-      concat content_tag(:div, class: join_class("wrapper")) {
-        concat header_tag unless header.blank?
-        groups.each { |group| concat group }
-        concat footer_tag unless footer.blank?
-      }
-    end
-  end
-
-  private
-
-  def header_tag
-    content_tag(:div, header, class: join_class("header"))
-  end
-
-  def footer_tag
-    content_tag(:div, footer, class: join_class("footer"))
-  end
-  
-  def sidebar_toggle_tag
-    component("nav/toggle", target: selector(:data, :nav_id), class: join_class("toggle"), text: sidebar_button_text)
-  end
-
-  # Tries to find the text for the active nav item, otherwise shows sidebar label text
-  def sidebar_button_text
-    # Find any navs which have active items
-    active_nav = groups.find { |group|
-      group.active_item
-    }
-
-    # Use the active item text or the label for the sidebar
-    active_nav&.active_item&.text || label
-  end
-end

data/app/components/spark/nav/tab_panels/panel_component.rb

@@ -1,37 +0,0 @@
-class Nav::TabPanels::PanelComponent < SparkComponents::Component
-  attribute :href, :text, :icon
-
-  element :tab, component: "nav/tab_panels/tab"
-
-  def after_init
-    root_attr id: unique_id("panel"), role: "tabpanel"
-    aria_attr labeledby: tab_id
-  end
-
-  def active=(bool)
-    if bool
-      add_class 'active'
-    else
-      root_attr(hidden: true)
-    end
-  end
-
-  def tab_id
-    "tab-for-#{root_attr[:id]}"
-  end
-
-  def tab_wrapper_id
-    "wrapper-for-#{tab_id}"
-  end
-
-  def new_tab(active: false)
-    tab = Nav::TabPanels::TabComponent.new(@view, text: text, href: href, icon: icon, active: active)
-    tab.parent = self
-    tab.before_render
-    tab.render
-  end
-
-  def render
-    @yield
-  end
-end

data/app/components/spark/nav/tab_panels/tab_component.rb

@@ -1,13 +0,0 @@
-class Nav::TabPanels::TabComponent < Nav::ItemComponent
-  root_attr role: 'tab', href: "#"
-
-  def before_render
-    aria_attr controls: parent.tag_attrs[:id], selected: !!active
-    data_attr anchor: href, add_class: "active"
-    add_class "active" if active
-  end
-
-  def render
-    content_tag(:li, id: parent.tab_wrapper_id, class: "nav-tab-wrapper #{active ? "active" : nil}") { super }
-  end
-end

data/app/components/spark/nav/tab_panels_component.rb

@@ -1,28 +0,0 @@
-class Nav::TabPanelsComponent < Nav::TabsComponent
-  element :panel, multiple: true, component: "nav/tab_panels/panel"
-
-  def render
-    panels.each_with_index { |panel, index|
-      items << panel.new_tab(active: index == 0)
-    }
-
-    content_tag(:div, class: "nav-tab-panels") do
-      concat super
-      panels.each_with_index { |panel, index| 
-        panel.active = index == 0
-        concat content_tag(:div, panel.yield, panel.tag_attrs)
-      }
-    end
-  end
-
-  def active_item_text
-    panels.first.text
-  end
-
-  private
-
-  def tab_group(options={}, &block)
-    options.merge!({ role: "tablist" })
-    super(options, &block)
-  end
-end

data/app/components/spark/nav/tabs_component.rb

@@ -1,59 +0,0 @@
-class Nav::TabsComponent < SparkComponents::Component
-  LAYOUT = %i[flush padded]
-
-  base_class "spark-nav-tabs"
-  root_attr role: "navigation"
-  attribute layout: :flush
-
-  aria_attr :label
-  validates :label, presence: true
-  validates_choice :layout, LAYOUT
-
-  element :item, multiple: true, component: "nav/item" do
-    def render
-      content_tag(:li, class: "nav-tab-wrapper") { super }
-    end
-  end
-
-  def before_render
-    add_class %(layout-#{layout})
-    data_attr nav_id: unique_id
-  end
-
-  def render
-    return if items.empty?
-
-    content_tag(:nav, tag_attrs) do
-      concat toggle_button
-      concat content_tag(:div, class: "nav-tabs-wrapper") {
-        concat tab_group {
-          items.each { |item| concat item }
-        }
-      }
-    end
-  end
-
-  private
-
-  def toggle_button
-    component("nav/toggle", target: selector(:data, :nav_id), class: join_class("toggle"), text: active_item_text)
-  end
-
-  def active_item_text
-    if active_item = items.find(&:active?)
-      active_item.text
-    else
-      "Menu"
-    end
-  end
-
-  def tab_wrapper(options={}, &block)
-    options[:class] = "nav-tab-wrapper #{options[:class]}"
-    content_tag(:li, options, &block)
-  end
-
-  def tab_group(options={}, &block)
-    options[:class] = "spark-nav-group #{options[:class]}"
-    content_tag(:ul, options, &block)
-  end
-end

data/app/components/spark/nav/toggle_component.rb

@@ -1,28 +0,0 @@
-class Nav::ToggleComponent < SparkComponents::Component
-  base_class "nav-toggle"
-  
-  attribute :target, :text, :id, :menu_icon, icon: 'chevron-down' 
-  validates :target, presence: true
-
-  def render
-    root_attr type: "button", id: @id || unique_id
-    aria_attr hidden: true
-
-    # When toggled on, adds an active class to itself and `nav-active` to `target` selector.
-    data_attr nav_toggle: "#{target}"
-
-    content_tag(:button, tag_attrs) do
-      concat content_tag(:span, text, class: join_class("text")) if text
-      if icon == 'nav-menu'
-        concat content_tag(:span, class: join_class("icon-wrapper")) {
-          content_tag(:span, nil, class: join_class("menu-icon"))
-        }
-      else
-        concat content_tag(:span, class: join_class("icon")) {
-          @view.use_svg(icon, width: '12px', class: join_class("svg")) if icon
-        }
-      end
-    end
-  end
-end
-

data/app/components/spark/nav/tree/group_component.rb

@@ -1,35 +0,0 @@
-class Nav::Tree::GroupComponent < Nav::GroupComponent
-  attribute :icon, :text, expanded: false
-  attribute :group_icon_size
-  base_class "nav-item-wrapper"
-
-  def before_render
-    super
-    add_class "tree-node"
-    data_attr(node: node)
-    aria_attr(expanded: expanded?)
-    @item_role = item.respond_to?(:href) ? "none" : "treeitem"
-  end
-
-  def render
-    unless items.empty?
-      root_attr role: "treeitem"
-      content_tag(:li, tag_attrs) do
-        concat component("nav/item", text: text, icon: icon, icon_size: group_icon_size, class: "tree-trigger", tabindex: 0, href: "#") { expand_icon }
-        concat super
-      end
-    end
-  end
-
-  def expand_icon
-    @view.use_svg( 'chevron-down', class: "expand-icon", width: "9px" )
-  end
-
-  def node
-    @node ||= text.strip.downcase.gsub(/[\W,-]+/, '_')
-  end
-
-  def expanded?
-    @expanded || active?
-  end
-end

data/app/components/spark/nav/tree_component.rb

@@ -1,56 +0,0 @@
-class Nav::TreeComponent < SparkComponents::Component
-  base_class "nav-tree"
-  root_attr :id, role: "tree"
-  aria_attr :label
-  attribute root_icon_size: :small
-
-  def before_render
-    data_attr tree: id
-  end
-
-  element :item, multiple: true, component: "nav/item" do
-    add_class "tree-node"
-
-    def before_render
-      @icon_size = parent.root_icon_size
-      super
-    end
-  end
-
-  element :group, component: "nav/tree/group" do
-
-    def before_render
-      @group_icon_size = parent.root_icon_size
-      add_class "active" if active?
-      super
-    end
-
-    def render
-      parent.items << super unless items.empty?
-    end
-
-    def expanded?
-      parent.group_expanded?(node) || active? || expanded
-    end
-  end
-
-  def render
-    content_tag(:ul, tag_attrs) do
-      items.each { |item|
-        # Wrap links in `<li>`s if it's a link
-        item = content_tag(:li, item, class: "nav-item-wrapper", role: "none") if item.respond_to?(:href)
-        concat item
-      }
-    end
-  end
-
-  def group_expanded?(node)
-    @_cookie ||= begin
-      @view.parse_cookie( id )
-    rescue
-      nil
-    end
-
-    @_cookie && !!@_cookie[ node ]
-  end
-end

data/app/components/spark/page/layout_component.rb

@@ -1,32 +0,0 @@
-class Page::LayoutComponent < SparkComponents::Component
-  base_class "spark-page"
-  element :nav
-  element :title
-  element :header
-  element :body
-  element :footer
-  element :main, component: "page/main"
-  element :action, multiple: true
-
-  def render
-    @view.capture do
-      if title || nav || header
-        concat content_tag(:div, class: join_class("header")) {
-          concat if_content_tag(:div, nav, join_class: "header-nav")
-          concat(component("layout/header", title: title) { |h|
-            actions.each { |a| h.action { a.yield }}
-          })
-          concat if_content_tag(:div, header, join_class: "header-body")
-        }
-      end
-      concat if_content_tag(:div, main, join_class: "main-wrapper")
-      concat if_content_tag(:div, body, join_class: "body")
-      concat if_content_tag(:div, footer, join_class: "footer")
-      concat content_for(:modal)
-    end
-  end
-  
-  def modal(&block)
-    content_for(:modals, &block)
-  end
-end

data/app/components/spark/page/main_component.rb

@@ -1,39 +0,0 @@
-class Page::MainComponent < SparkComponents::Component
-  base_class "spark-page-main"
-  element :nav
-  element :header
-  element :sidebar
-  element :column, multiple: true
-  element :body
-  element :footer
-
-  def render
-    add_class("with-sidebar") unless sidebar.blank?
-
-    content_tag(:div, tag_attrs) do
-      unless sidebar.blank?
-        concat content_tag(:div, class: join_class("sidebar")) {
-          concat sidebar
-        }
-      end
-      concat content_tag(:div, class: join_class("content")) {
-        concat element_template("nav", nav)
-        concat element_template("header", header)
-
-        unless columns.empty?
-          concat content_tag(:div, class: join_class("columns")) {
-            columns.each { |column| concat element_template("column", column) }
-          }
-        end
-
-        concat content_tag(:div, body, class: join_class("body")) unless body.blank?
-        concat element_template("footer", footer)
-      }
-    end
-  end
-
-  # Simplify wrapping elements in divs with modular classnames if content is passed
-  def element_template(name, content)
-    content_tag(:div, content, class: join_class(name)) unless content.blank?
-  end
-end

data/app/components/spark/ui/card_component.rb

@@ -1,16 +0,0 @@
-class Ui::CardComponent < SparkComponents::Component
-  base_class "spark-card"
-
-  element :header, component: "layout/header" do
-    add_class "spark-card-header"
-  end
-
-  element :body
-
-  def render
-    content_tag(:div, tag_attrs) do
-      concat header
-      concat if_content_tag(:div, body, join_class: 'content')
-    end
-  end
-end