bulma-phlex 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 66aad611632ef1e130fd898e589c7a5c6548673f3bad6efcc9c0fd3e3ee35931
+  data.tar.gz: 665413567403f62d159300df558a62f15aad11ef254e963a75904ea72b77ed67
+SHA512:
+  metadata.gz: f1e1684e053b1d1fc0fd3f2b0013f448f317ce764f544be465ab48e3b474f491cfe9080c45164262d0389657511429ec5d6396a0f4cb8b2887dad122a7b83ec0
+  data.tar.gz: 0a5ffbaf9f9a703b70b304f7d66b9b44789326ce270d84fdbca0da4739a3c29acd38c5f40eeb5647061d2d2854895cd9e3f6888a4160d69ac48e0bfafa19c97d

data/README.md

@@ -0,0 +1,176 @@
+[![Gem Version](https://badge.fury.io/rb/bulma-phlex.svg)](https://badge.fury.io/rb/bulma-phlex)
+[![Tests](https://github.com/RockSolt/bulma-phlex/actions/workflows/test.yml/badge.svg)](https://github.com/RockSolt/bulma-phlex/actions/workflows/test.yml)
+[![RuboCop](https://github.com/RockSolt/bulma-phlex/actions/workflows/rubocop.yml/badge.svg)](https://github.com/RockSolt/bulma-phlex/actions/workflows/rubocop.yml)
+
+# Bulma Components Built with Phlex
+
+This gem provides a set of ready-to-use components [Phlex](https://github.com/phlex-ruby/phlex) for common [Bulma](https://bulma.io/) components and elements, making it easy to build beautiful, responsive interfaces with a clean, Ruby-focused API.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "bulma-phlex"
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install bulma-phlex
+```
+
+### Dependencies
+
+This gem requires:
+
+- Ruby 3.4 or higher
+- Phlex 2.0.2 or higher
+- Bulma CSS (which you'll need to include in your application)
+
+### Required Setup
+
+1. Include Bulma CSS in your application. You can add it via npm/yarn, CDN, or the [bulma-rails](https://github.com/joshuajansen/bulma-rails) gem.
+
+2. Require the gem in your code:
+
+```ruby
+require "bulma-phlex"
+```
+
+
+## Usage
+
+Use the Phlex components in your Rails views or any Ruby application that supports Phlex components.
+
+### Card
+
+[Cards](https://bulma.io/documentation/components/card/) are flexible containers that can display various types of content including headers and content sections.
+
+```ruby
+render Components::Bulma::Card.new do |card|
+  card.head("Card Title")
+  card.content do
+    "This is some card content"
+  end
+end
+```
+
+### Level
+
+The [Level](https://bulma.io/documentation/layout/level/) component provides a flexible horizontal layout system with left and right alignment.
+
+```ruby
+render Components::Bulma::Level.new do |level|
+  level.left do
+    button(class: "button") { "Left" }
+  end
+
+  level.right do
+    button(class: "button") { "Right" }
+  end
+  level.right do
+    button(class: "button") { "Right 2" }
+  end
+end
+```
+
+### NavigationBar
+
+The [NavigationBar](https://bulma.io/documentation/components/navbar/) component provides a responsive navigation header with support for branding, navigation links, and dropdown menus.
+
+```ruby
+render Components::Bulma::NavigationBar.new do |navbar|
+  navbar.brand_item "My App", "/"
+  
+  navbar.left do |menu|
+    menu.item "Home", "/"
+    menu.item "Products", "/products"
+  end
+  
+  navbar.right do |menu|
+    menu.item "About", "/about"
+    menu.dropdown "Account" do |dropdown|
+      dropdown.header "User"
+      dropdown.item "Profile", "/profile"
+      dropdown.item "Settings", "/settings"
+      dropdown.divider
+      dropdown.item "Sign Out", "/logout"
+    end
+  end
+end
+```
+
+### Pagination
+
+The [Pagination](https://bulma.io/documentation/components/pagination/) component provides navigation controls for paginated content, including previous/next links, page number links, and a summary of items being displayed.
+
+```ruby
+# In a controller action:
+@products = Product.page(params[:page]).per(20)
+
+# In the view:
+render Components::Bulma::Pagination.new(@products, ->(page) { products_path(page: page) })
+```
+
+### Table
+
+The [Table](https://bulma.io/documentation/elements/table/) component provides a way to display data in rows and columns with customizable headers and formatting options.
+
+```ruby
+users = User.all
+
+render Components::Bulma::Table.new(users) do |table|
+  table.column "Name" do |user|
+    user.full_name
+  end
+  
+  table.column "Email" do |user|
+    user.email
+  end
+  
+  table.column "Actions" do |user|
+    link_to "Edit", edit_user_path(user), class: "button is-small"
+  end
+end
+```
+
+### Tabs
+
+The [Tabs](https://bulma.io/documentation/components/tabs/) component provides a way to toggle between different content sections using tabbed navigation, with support for icons and active state management.
+
+```ruby
+render Components::Bulma::Tabs.new do |tabs|
+  tabs.tab(id: "profile", title: "Profile", active: true) do
+    "Profile content goes here"
+  end
+  
+  tabs.tab(id: "settings", title: "Settings", icon: "fas fa-cog") do
+    "Settings content goes here"
+  end
+  
+  tabs.tab(id: "notifications", title: "Notifications", icon: "fas fa-bell") do
+    "Notifications content goes here"
+  end
+end
+```
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/RockSolt/bulma-phlex.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+Minitest::TestTask.create
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/lib/bulma-phlex.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "phlex"
+require "bulma_phlex/version"
+
+require "components/bulma"
+require "components/bulma/base"
+require "components/bulma/card"
+require "components/bulma/level"
+require "components/bulma/navigation_bar_dropdown"
+require "components/bulma/navigation_bar"
+require "components/bulma/pagination"
+require "components/bulma/table"
+require "components/bulma/tabs"

data/lib/bulma_phlex/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module BulmaPhlex
+  VERSION = "0.1.0"
+end

data/lib/components/bulma/base.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Components
+  module Bulma
+    # Base component for all Bulma components
+    #
+    # This is the parent class for all Bulma components in this library.
+    # It provides common utility methods and inherits from `Phlex::HTML`.
+    #
+    class Base < Phlex::HTML
+      private
+
+      def icon_span(icon, additional_classes = nil)
+        span(class: "icon #{additional_classes}".strip) do
+          i(class: icon)
+        end
+      end
+    end
+  end
+end

data/lib/components/bulma/card.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Components
+  module Bulma
+    # Card component for content display
+    #
+    # This component implements the [Bulma card](https://bulma.io/documentation/components/card/)
+    # interface. Cards are flexible containers that can display various types of content
+    # including headers, content sections, and more.
+    #
+    # ## Example
+    #
+    # ```ruby
+    # render Components::Bulma::Card.new do |card|
+    #   card.head("Card Title")
+    #   card.content do
+    #     "This is some card content"
+    #   end
+    # end
+    # ```
+    #
+    class Card < Components::Bulma::Base
+      def view_template(&)
+        div(class: "card", &)
+      end
+
+      def head(title, classes: nil)
+        header(class: "card-header #{classes}") do
+          p(class: "card-header-title") { plain title }
+        end
+      end
+
+      def content(&)
+        div(class: "card-content") do
+          div(class: "content", &)
+        end
+      end
+
+      if defined?(Phlex::Rails)
+        include Phlex::Rails::Helpers::TurboFrameTag
+
+        # this copies the signature of the turbo_frame_tag helper,
+        # with the addition of a pending_message attribute
+        def turbo_frame_content(*ids, src: nil, target: nil, **attributes)
+          pending_message = attributes.delete(:pending_message) || "Loading..."
+          pending_icon = attributes.delete(:pending_icon) || "fas fa-spinner fa-pulse"
+
+          content do
+            turbo_frame_tag ids, src: src, target: target, **attributes do
+              span(class: "icon") { i class: pending_icon }
+              span { plain pending_message }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/components/bulma/level.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Components
+  module Bulma
+    # Level component for responsive horizontal layouts
+    #
+    # This component implements the [Bulma level](https://bulma.io/documentation/layout/level/)
+    # interface, providing a flexible horizontal layout system with left and right alignment.
+    #
+    # ## Example:
+    #
+    # ```ruby
+    # render Components::Bulma::Level.new do |level|
+    #   level.left do
+    #     button(class: "button") { "Left" }
+    #   end
+    #
+    #   level.right do
+    #     button(class: "button") { "Right" }
+    #   end
+    #   level.right do
+    #     button(class: "button") { "Right 2" }
+    #   end
+    # end
+    # ```
+    #
+    class Level < Components::Bulma::Base
+      def initialize
+        @items = []
+        @left = []
+        @right = []
+      end
+
+      def view_template(&)
+        vanish(&)
+
+        div(class: "level") do
+          div(class: "level-left") do
+            @left.each { level_item(it) }
+          end
+
+          @items.each { level_item(it) }
+
+          div(class: "level-right") do
+            @right.each { level_item(it) }
+          end
+        end
+      end
+
+      def item(&content)
+        @items << content
+      end
+
+      def left(&content)
+        @left << content
+      end
+
+      def right(&content)
+        @right << content
+      end
+
+      private
+
+      def level_item(content)
+        div(class: "level-item") { content.call }
+      end
+    end
+  end
+end

data/lib/components/bulma/navigation_bar.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Components
+  module Bulma
+    # Navigation bar component for site navigation
+    #
+    # This component implements the [Bulma navbar](https://bulma.io/documentation/components/navbar/)
+    # interface. It provides a responsive navigation header with support for branding, navigation
+    # links, and dropdown menus, automatically collapsing on mobile devices.
+    #
+    # ## Example
+    #
+    # ```ruby
+    # render Components::Bulma::NavigationBar.new do |navbar|
+    #   navbar.brand do
+    #     a(href: "/", class: "navbar-item") { "My App" }
+    #   end
+    #
+    #   navbar.left do
+    #     a(href: "/", class: "navbar-item") { "Home" }
+    #     a(href: "/products", class: "navbar-item") { "Products" }
+    #   end
+    #
+    #   navbar.right do
+    #     a(href: "/about", class: "navbar-item") { "About" }
+    #
+    #     div(class: "navbar-item has-dropdown is-hoverable") do
+    #       a(class: "navbar-link") { "Account" }
+    #       render Components::Bulma::NavigationBarDropdown do |dropdown|
+    #         dropdown.item "Sign In", "/login"
+    #         dropdown.item "Register", "/register"
+    #       end
+    #     end
+    #   end
+    # end
+    # ```
+    #
+    class NavigationBar < Components::Bulma::Base
+      def initialize
+        @brand = []
+        @left = []
+        @right = []
+      end
+
+      def view_template(&)
+        vanish(&)
+
+        nav(class: "navbar is-light block",
+            role: "navigation",
+            aria_label: "main navigation",
+            data: { controller: "bulma--navigation-bar" }) do
+          div(class: "container") do
+            div(class: "navbar-brand") do
+              @brand.each(&:call)
+
+              a(class: "navbar-burger",
+                role: "button",
+                aria_label: "menu",
+                aria_expanded: "false",
+                data: {
+                  action: "bulma--navigation-bar#toggle",
+                  "bulma--navigation-bar-target": "burger"
+                }) do
+                4.times { span(aria_hidden: "true") }
+              end
+            end
+
+            div(class: "navbar-menu",
+                data: { "bulma--navigation-bar-target": "menu" }) do
+              div(class: "navbar-start") do
+                @left.each(&:call)
+              end
+
+              div(class: "navbar-end") do
+                @right.each(&:call)
+              end
+            end
+          end
+        end
+      end
+
+      def brand(&block)
+        @brand << block
+      end
+
+      def left(&block)
+        @left << block
+      end
+
+      def right(&block)
+        @right << block
+      end
+    end
+  end
+end

data/lib/components/bulma/navigation_bar_dropdown.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Components
+  module Bulma
+    # Dropdown component for the Bulma navigation bar
+    #
+    # This component implements the dropdown portion of the [Bulma navbar](https://bulma.io/documentation/components/navbar/#dropdown-menu).
+    # It provides a structured way to add dropdown menus to a navigation bar with headers, items, and dividers.
+    #
+    # ## Example
+    #
+    # ```ruby
+    # render Components::Bulma::NavigationBar.new do |navbar|
+    #   navbar.brand_item "My App", "/"
+    #
+    #   navbar.right do |menu|
+    #     menu.dropdown "Account" do |dropdown|
+    #       dropdown.header "User"
+    #       dropdown.item "Profile", "/profile"
+    #       dropdown.item "Settings", "/settings"
+    #       dropdown.divider
+    #       dropdown.item "Sign Out", "/logout"
+    #     end
+    #   end
+    # end
+    # ```
+    #
+    class NavigationBarDropdown < Components::Bulma::Base
+      def view_template(&)
+        div(class: "navbar-dropdown is-right", &)
+      end
+
+      def header(label)
+        div(class: "navbar-item header has-text-weight-medium") { label }
+      end
+
+      def item(label, path)
+        a(class: "navbar-item", href: path) { label }
+      end
+
+      def divider
+        hr(class: "navbar-divider")
+      end
+    end
+  end
+end

data/lib/components/bulma/pagination.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Components
+  module Bulma
+    # Pagination component for navigating through multi-page content
+    #
+    # This component implements the [Bulma pagination](https://bulma.io/documentation/components/pagination/)
+    # interface, providing navigation controls for paginated content. It shows:
+    # - Previous/next page links
+    # - First/last page links when appropriate
+    # - Current page indicator
+    # - Ellipses for skipped page ranges
+    # - Summary of items being displayed
+    #
+    # ## Example
+    #
+    # ```ruby
+    # # In a controller action:
+    # @products = Product.page(params[:page]).per(20)
+    #
+    # # In the view:
+    # render Components::Bulma::Pagination.new(@products, ->(page) { products_path(page: page) })
+    # ```
+    #
+    class Pagination < Components::Bulma::Base
+      attr_reader :pager, :path_builder
+
+      # Initializes the pagination component
+      #
+      # @param pager [Object] An object that responds to:
+      #   - `current_page` - Integer representing the current page number
+      #   - `total_pages` - Integer representing the total number of pages
+      #   - `per_page` - Integer representing the number of items per page
+      #   - `total_count` - Integer representing the total number of items
+      #   - `previous_page` - Integer or nil representing the previous page number
+      #   - `next_page` - Integer or nil representing the next page number
+      # @param path_builder [Proc] A callable that takes a page number and returns a URL string
+      def initialize(pager, path_builder)
+        @pager = pager
+        @path_builder = path_builder
+      end
+
+      def view_template
+        return unless pager.total_pages > 1
+
+        div(class: "pagination-container mt-5") do
+          nav(class: "pagination", role: "navigation", aria_label: "pagination") do
+            # Previous page link
+            if pager.previous_page
+              a(class: "pagination-previous", href: page_url(pager.previous_page)) { "Previous" }
+            else
+              a(class: "pagination-previous", disabled: true) { "Previous" }
+            end
+
+            # Next page link
+            if pager.next_page
+              a(class: "pagination-next", href: page_url(pager.next_page)) { "Next" }
+            else
+              a(class: "pagination-next", disabled: true) { "Next" }
+            end
+
+            # Page number links
+            ul(class: "pagination-list") do
+              # First page and ellipsis if needed
+              if pager.current_page > 3
+                render_page_item(1)
+                render_ellipsis if pager.current_page > 4
+              end
+
+              # Pages around current page
+              page_window.each do |page_number|
+                render_page_item(page_number)
+              end
+
+              # Ellipsis and last page if needed
+              if pager.current_page < pager.total_pages - 2
+                render_ellipsis if pager.current_page < pager.total_pages - 3
+                render_page_item(pager.total_pages)
+              end
+            end
+          end
+
+          div(class: "has-text-centered mt-2 is-size-7") do
+            start_item = ((pager.current_page - 1) * pager.per_page) + 1
+            end_item = [start_item + pager.per_page - 1, pager.total_count].min
+
+            plain "Showing #{start_item}-#{end_item} of #{pager.total_count} items"
+          end
+        end
+      end
+
+      private
+
+      def render_page_item(page_number)
+        li do
+          if page_number == pager.current_page
+            a(class: "pagination-link is-current",
+              aria_label: "Page #{page_number}",
+              aria_current: "page") { page_number.to_s }
+          else
+            a(class: "pagination-link",
+              href: page_url(page_number),
+              aria_label: "Go to page #{page_number}") { page_number.to_s }
+          end
+        end
+      end
+
+      def render_ellipsis
+        li { span(class: "pagination-ellipsis") { "…" } }
+      end
+
+      def page_window
+        start_page = [pager.current_page - 2, 1].max
+        end_page = [pager.current_page + 2, pager.total_pages].min
+        (start_page..end_page).to_a
+      end
+
+      def page_url(page_number)
+        @path_builder.call(page_number)
+      end
+    end
+  end
+end

data/lib/components/bulma/table.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+module Components
+  module Bulma
+    # Table component for data display
+    #
+    # This component implements the [Bulma table](https://bulma.io/documentation/elements/table/)
+    # interface, providing a way to display data in rows and columns with customizable
+    # headers and formatting options.
+    #
+    # ## Example
+    #
+    # ```ruby
+    # users = User.all
+    #
+    # render Components::Bulma::Table.new(users) do |table|
+    #   table.column "Name" do |user|
+    #     user.full_name
+    #   end
+    #
+    #   table.column "Email" do |user|
+    #     user.email
+    #   end
+    #
+    #   table.column "Actions" do |user|
+    #     link_to "Edit", edit_user_path(user), class: "button is-small"
+    #   end
+    # end
+    # ```
+    #
+    class Table < Components::Bulma::Base
+      def initialize(rows, id = nil)
+        @id = id || rows.first&.model_name&.plural
+        @rows = rows
+        @columns = []
+      end
+
+      def view_template(&)
+        vanish(&)
+
+        table(id: @id, class: "table is-fullwidth") do
+          thead do
+            @columns.each do |column|
+              table_header(column)
+            end
+          end
+
+          tbody do
+            @rows.each do |row|
+              tr do
+                @columns.each do |column|
+                  td(**column[:html_attributes]) { column[:content].call(row) }
+                end
+              end
+            end
+          end
+
+          pagination
+        end
+      end
+
+      def column(header, **html_attributes, &content)
+        @columns << { header:, html_attributes:, content: }
+      end
+
+      def paginate(&path_builder)
+        @path_builder = path_builder
+      end
+
+      private
+
+      # this derives a th class from the column html attributes
+      # perhaps a better way would be pre-defined pairs?
+      def table_header(column)
+        attributes = {}
+        attributes[:class] = header_alignment(column[:html_attributes])
+        th(**attributes) { column[:header] }
+      end
+
+      def header_alignment(html_attributes)
+        classes = html_attributes[:class]
+        return if classes.nil?
+
+        if classes&.include?("has-text-right") || classes&.include?("amount-display")
+          "has-text-right"
+        elsif classes&.include?("has-text-centered")
+          "has-text-centered"
+        end
+      end
+
+      def pagination
+        return unless @path_builder
+
+        tfoot do
+          tr do
+            td(class: "py-0", colspan: @columns.size) do
+              Pagination(@rows, @path_builder)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/components/bulma/tabs.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Components
+  module Bulma
+    # Tabs component for toggling between different content sections
+    #
+    # This component implements the [Bulma tabs](https://bulma.io/documentation/components/tabs/)
+    # interface, providing a way to toggle between different content sections using
+    # tabbed navigation. Includes support for icons and active state management.
+    #
+    # ## Example
+    #
+    # ```ruby
+    # render Components::Bulma::Tabs.new do |tabs|
+    #   tabs.tab(id: "profile", title: "Profile", active: true) do
+    #     "Profile content goes here"
+    #   end
+    #
+    #   tabs.tab(id: "settings", title: "Settings", icon: "fas fa-cog") do
+    #     "Settings content goes here"
+    #   end
+    #
+    #   tabs.tab(id: "notifications", title: "Notifications", icon: "fas fa-bell") do
+    #     "Notifications content goes here"
+    #   end
+    # end
+    # ```
+    #
+    class Tabs < Components::Bulma::Base
+      Tab = Data.define(:id, :title, :icon, :active)
+      Content = Data.define(:id, :block, :active)
+
+      def initialize
+        @tabs = []
+        @contents = []
+      end
+
+      def tab(id:, title:, icon: nil, active: false, &block)
+        @tabs << Tab.new(id:, title:, icon:, active:)
+        @contents << Content.new(id:, block:, active:)
+      end
+
+      def view_template(&)
+        vanish(&)
+
+        div(data: { controller: "tabs" }) do
+          div(class: "tabs is-boxed") do
+            ul do
+              @tabs.each do |tab|
+                li(
+                  data: {
+                    tabs_target: "tab",
+                    tab_content: tab.id,
+                    action: "click->tabs#showTabContent"
+                  },
+                  class: tab.active ? "is-active" : ""
+                ) do
+                  a do
+                    icon_span(tab.icon, "mr-1") if tab.icon
+                    span { tab.title }
+                  end
+                end
+              end
+            end
+          end
+
+          @contents.each do |content|
+            div(id: content.id,
+                class: content.active ? "" : "hidden",
+                data: { tabs_target: "content" }) do
+              content.block.call
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/components/bulma.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# A collection of Bulma components built with Phlex
+#
+# This module provides a set of components that implement the [Bulma CSS framework](https://bulma.io/)
+# using the Phlex view component library. These components make it easy to build
+# Bulma-styled applications with a Ruby-focused component API.
+#
+module Components
+  module Bulma
+    extend Phlex::Kit
+  end
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: bulma-phlex
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Todd Kummer
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: phlex
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.2
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-difftastic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Add Bulma components including Card, Level, NavigationBar, Pagination,
+  Table, and Tabs to your Phlex application.
+email:
+- todd@rockridgesolutions.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/bulma-phlex.rb
+- lib/bulma_phlex/version.rb
+- lib/components/bulma.rb
+- lib/components/bulma/base.rb
+- lib/components/bulma/card.rb
+- lib/components/bulma/level.rb
+- lib/components/bulma/navigation_bar.rb
+- lib/components/bulma/navigation_bar_dropdown.rb
+- lib/components/bulma/pagination.rb
+- lib/components/bulma/table.rb
+- lib/components/bulma/tabs.rb
+homepage: https://github.com/RockSolt/bulma-phlex
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Build Bulma components with Phlex.
+test_files: []