dato-rails 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 02c359d5fbd1d6c3ec6aeb523e4e6cd363d76eeeec4045a195af8d89f62f59f8
+  data.tar.gz: 3a81c86545557254a92fe7b323bc241cac6b33051d619847d5e911f286cbb0ab
+SHA512:
+  metadata.gz: 49b7857ed9358db19ea94a5c984250ec50b389bc806af3c6df8a7919504c8dbd6aa837c167bffed60f69c8cbd599ed86e03bbedbe721e39adf1b80a758a42adc
+  data.tar.gz: bcc954ba7e8606a5c807d0d3f1be11b1a82d0a3b065cfef77e051b7b481e3fe8b0f4f424738216ab0602a009446709c14b5d4133eef576e4960fa194fd1f4b4e

data/README.md

@@ -0,0 +1,170 @@
+# Dato::Rails
+
+Use [DatoCMS](https://www.datocms.com/) in your Rails application.
+
+This gem allows you to fetch data using Dato GraphQL APIs and render the content in your Rails app.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dato-rails', require: 'dato'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install dato-rails
+
+The gem is made of two parts:
+
+## GraphQL client
+
+The GraphQL client based on [GQLi](https://github.com/contentful-labs/gqli.rb) allows to perform 
+queries to the GraphQL endpoint.
+Look at GQLi documentation for more information about the syntax of queries.
+You can also find some examples in specs of this library.
+
+Set your api token as `DATO_API_TOKEN` environment variable.
+
+```ruby
+client = Dato::Client.new # you can also pass the api token here.
+query = GQLi::DSL.query {
+  homepage {
+    id
+  }
+}
+response = client.execute(query)
+
+puts response.data.homepage.id
+```
+
+We provide a fragment to extract a Responsive Image.
+
+```ruby
+GQLi::DSL.query {
+  homepage {
+    id
+    content {
+      value
+      blocks {
+        __typename
+        id
+        image {
+          responsiveImage(imgixParams: {fm: __enum("png")}) {
+            ___ Dato::Fragments::ResponsiveImage
+          }
+        }
+      }
+    }
+  }
+}
+```
+
+## View rendering
+
+The library is also a Rails Engine and provides a whole set of ViewComponents to render your content.
+The library aims to provide the most basic components and make it easy to create new one.
+
+Once you fetched the response of a query, you can use the Dato ViewComponents to render the content.
+
+If you have a StructuredText component, you can render it with:
+
+```ruby
+render Dato::StructuredText.new(response.data.homepage.content)
+```
+
+If you have a responsive image, you can render it with:
+
+```ruby
+render Dato::ResponsiveImage.new(node.image.responsiveImage)
+```
+
+To define a custom node, you can create a new `Dato::CustomNode` view component in your application and it will be automatically used.
+
+You can also customize how each node type is rendered by specifying the mapping on the single render:
+
+```ruby
+render Dato::StructuredText.new(response.data.homepage.content, overrides: { link: Dato::NotRendered })
+```
+
+or globally:
+
+```
+# config/initializers/dato.rb
+
+Dato::Config.overrides = {
+  link: 'Dato::NotRendered'
+}.with_indifferent_access
+```
+
+# Preview and live
+
+The `Dato::Client` supports both [preview](https://www.datocms.com/docs/pro-tips/how-to-manage-a-live-and-a-preview-site) and [live updates](https://www.datocms.com/docs/real-time-updates-api) features from Dato CMS.
+
+```ruby
+Dato::Client.new(preview: true) # to fetch draft versions
+
+client = Dato::Client.new(live: true) # => to fetch a live straming URL 
+client.live!(your_query)
+# => { url: 'https://your_event_source_url' }
+```
+
+A `ViewComponent` is provided to use both these features very easily!
+
+Given that you have a `ViewComponent` that takes in input only the result of a dato query,
+you probably have the following:
+
+```ruby
+result = Dato::Client.new.execute!(my_query)
+render(MyComponent.new(result))
+```
+
+you can now wrap everything in a `Dato::Live` component like this:
+
+```ruby
+render(Dato::Live.new(MyComponent, my_query, preview: true, live: true))
+```
+
+and your component will come to life with live updates 🎉 (requires turbo).
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. 
+
+You can now clone the dato-rails project
+
+[![Clone DatoCMS project](https://dashboard.datocms.com/clone/button.svg)](https://dashboard.datocms.com/clone?projectId=57262&name=dato-rails
+)
+
+
+You then need to set a `DATO_API_TOKEN=abcd123x` in the `.env` file on the root of your project
+to consume data from your project.
+
+Then, run `bundle exec rspec` 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/renuo/dato-rails. 
+This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to 
+adhere to the [code of conduct](https://github.com/renuo/dato-rails/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Dato::Rails project's codebases, issue trackers, chat rooms and mailing lists is 
+expected to follow the [code of conduct](https://github.com/renuo/dato-rails/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,17 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = false
+end
+
+task default: :test

data/app/components/dato/block.html.erb

@@ -0,0 +1,13 @@
+<% block = blocks.find { |b| b.id == @node.item } %>
+<% if block.__typename.nil? %>
+  In order to render a block, you need to return its <code>__typename</code>.<br>
+  In your GraphQL query, add <code>__typename</code> to the list of fields returned for the blocks.<br>
+  For example:<br><br>
+  <code>
+    blocks {
+      __typename
+    }
+  </code>
+<% else %>
+  <%=render class_for_block(block).new(block, root) %>
+<% end  %>

data/app/components/dato/block.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Dato::Block < Dato::DastNode
+  def initialize(node, root)
+    super(node, "block", root)
+  end
+end

data/app/components/dato/blockquote.html.erb

@@ -0,0 +1,9 @@
+<%= content_tag generated_tag, class: "dato-cms-#{@node.type}" do %>
+  <% @node.children&.each do |node| %>
+    <%= render_node(node) %>
+  <% end %>
+<% end %>
+
+<p class="dato-cms-attribution">
+  <%= @node.attribution %>
+</p>

data/app/components/dato/blockquote.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+class Dato::Blockquote < Dato::DastNode
+  def initialize(node, root)
+    super(node, "blockquote", root)
+  end
+end

data/app/components/dato/code.html.erb

@@ -0,0 +1 @@
+<%= content_tag generated_tag, class: "dato-cms-#{@node.type}" do %><%= @node.code %><% end %>

data/app/components/dato/code.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Dato::Code < Dato::DastNode
+  def initialize(node, root)
+    super(node, "code", root)
+  end
+
+  def generated_tag
+    "pre"
+  end
+end

data/app/components/dato/dast_node.html.erb

@@ -0,0 +1,6 @@
+<%= content_tag generated_tag, class: "dato-cms-#{@node.type}" do %>
+  <%= @node.value %>
+  <% @node.children&.each do |node| %>
+    <%= render_node(node) %>
+  <% end %>
+<% end %>

data/app/components/dato/dast_node.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Dato
+  class DastNode < Node
+    def initialize(node, type, root = nil)
+      super(node, root)
+      unless node.type == type
+        raise ArgumentError.new("The node type is '#{node.type}' instead of '#{type}'")
+      end
+      @type = type
+    end
+
+    def generated_tag
+      @type
+    end
+  end
+end

data/app/components/dato/heading.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Dato::Heading < Dato::DastNode
+  def initialize(node, root)
+    super(node, "heading", root)
+  end
+
+  def generated_tag
+    "h#{@node.level}"
+  end
+end

data/app/components/dato/link.html.erb

@@ -0,0 +1,5 @@
+<a href="<%=@node.url %>" class="dato-cms-<%=@node.type %>">
+  <% @node.children&.each do |node| %>
+    <%= render_node(node) %>
+  <% end %>
+</a>

data/app/components/dato/link.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Dato::Link < Dato::DastNode
+  def initialize(node, root)
+    super(node, "link", root)
+  end
+
+  def generated_tag
+    "a"
+  end
+end

data/app/components/dato/list.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Dato::List < Dato::DastNode
+  def initialize(node, root)
+    super(node, "list", root)
+  end
+
+  def generated_tag
+    @node.style == "bulleted" ? "ul" : "ol"
+  end
+end

data/app/components/dato/list_item.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Dato::ListItem < Dato::DastNode
+  def initialize(node, root)
+    super(node, "listItem", root)
+  end
+
+  def generated_tag
+    "li"
+  end
+end

data/app/components/dato/live.html.erb

@@ -0,0 +1,20 @@
+<% if @live %>
+  <script type="text/javascript">
+    const eventSourceUrl = '<%=@data.url %>';
+    const componentKlass = '<%=@component_klass%>';
+    const frameId = '<%=@frame_id%>';
+    const eventSource = new EventSource(eventSourceUrl);
+    eventSource.addEventListener("update", (event) => {
+      const params = new URLSearchParams({
+        component: componentKlass,
+        data: event.data,
+        frame_id: frameId
+      });
+      document.getElementById(frameId).src = `/dato/live?${params.toString()}`;
+    });
+  </script>
+
+  <%= turbo_frame_tag @frame_id %>
+<% else %>
+  <%= render(@component_klass.new(@data)) %>
+<% end %>

data/app/components/dato/live.rb

@@ -0,0 +1,25 @@
+# This component can bring to life your dato components allowing peviews and live updates.
+# Given that you have a component MyComponent that renders your page, you can would render your page with:
+# render(MyComponent.new(@data_result_from_dato_query))
+# you can now use this wrapper component to do:
+# render(Dato::Live.new(MyComponent, query, preview: true, live: true)
+module Dato
+  class Live < ViewComponent::Base
+    delegate :turbo_frame_tag, to: :helpers
+
+    def initialize(component_klass, query, preview: false, live: false)
+      @data = dato_fetch(query, preview: preview, live: live)
+      @component_klass = component_klass
+      @live = live
+      @frame_id = SecureRandom.hex(10)
+    end
+
+    private
+
+    def dato_fetch(query, preview: false, live: false)
+      client = Dato::Client.new(preview: preview, live: live)
+      response = live ? client.live!(query) : client.execute!(query)
+      response.data
+    end
+  end
+end

data/app/components/dato/node.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Dato
+  class Node < ViewComponent::Base
+    attr_reader :root
+
+    def initialize(node, root = nil)
+      @node = node
+      @root = root
+    end
+
+    def render_node(node)
+      render class_for_node(node).new(node, root)
+    end
+
+    def blocks
+      root.blocks
+    end
+
+    def overrides
+      root.overrides
+    end
+
+    def debug_node
+      content_tag("pre", JSON.pretty_generate(@node))
+    end
+
+    private
+
+    def class_for_block(block)
+      class_name = (overrides[block.__typename] || Dato::Config.overrides[block.__typename])
+      if class_name.is_a?(String)
+        class_name = class_name.constantize
+      end
+      begin
+        class_name || class_by_type(block.__typename).constantize
+      rescue
+        Dato::UnknownBlock
+      end
+    end
+
+    def class_for_node(node)
+      class_name = (overrides[node.type] || Dato::Config.overrides[node.type])
+      if class_name.is_a?(String)
+        class_name = class_name.constantize
+      end
+      begin
+        class_name || class_by_type(node.type).constantize
+      rescue
+        Dato::UnknownNode
+      end
+    end
+
+    def class_by_type(type)
+      "Dato::#{type.classify}"
+    end
+  end
+end

data/app/components/dato/not_rendered.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Dato
+  class NotRendered < DastNode
+    def initialize(node, root)
+      super(node, node.type, root)
+    end
+
+    def render?
+      false
+    end
+  end
+end

data/app/components/dato/paragraph.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Dato::Paragraph < Dato::DastNode
+  def initialize(node, root)
+    super(node, "paragraph", root)
+  end
+
+  def generated_tag
+    "p"
+  end
+end

data/app/components/dato/responsive_image.html.erb

@@ -0,0 +1,10 @@
+<div class="dato-responsive-image <%= @custom_css_classes %>"
+     style="position: relative; background-image: url(<%= @node.base64 %>); background-size: cover;">
+  <div style="padding-top: <%= 100.0 / @node.aspectRatio %>%;">
+    <picture style="position: absolute; left: 0; top: 0; width: 100%">
+      <source srcset="<%= @node.webpSrcSet %>" type="image/webp">
+      <source srcset="<%= @node.srcSet %>">
+      <img src="<%= @node.src %>" alt="<%= @node.alt %>" title="<%= @node.title %>" loading="lazy" width="100%">
+    </picture>
+  </div>
+</div>

data/app/components/dato/responsive_image.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+class Dato::ResponsiveImage < Dato::Node
+  def initialize(node, root = nil, custom_css_classes: [])
+    super(node, root)
+    @custom_css_classes = custom_css_classes
+  end
+end

data/app/components/dato/span.html.erb

@@ -0,0 +1,5 @@
+<%= conditional_tag 'code', code_span?, class: "dato-cms-span-wrapper" do %>
+  <%= content_tag 'span', class: "dato-cms-span", style: styles do %>
+    <%= @node.value %>
+  <% end %>
+<% end %>

data/app/components/dato/span.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class Dato::Span < Dato::DastNode
+  def initialize(node, root = nil)
+    super(node, "span", root)
+  end
+
+  def styles
+    return unless @node.marks.present?
+
+    mapping = {
+      emphasis: "font-style: italic",
+      strong: "font-weight: bold",
+      highlight: "background-color: #FFFF00"
+    }.with_indifferent_access
+
+    text_decoration_mappings = {
+      underline: "underline",
+      strikethrough: "line-through"
+    }.with_indifferent_access
+    styles = @node.marks.map { |m| mapping[m] }.compact
+    text_decorations = @node.marks.map { |m| text_decoration_mappings[m] }.compact
+    if text_decorations.any?
+      styles << "text-decoration: #{text_decorations.join(" ")}"
+    end
+
+    styles.join("; ")
+  end
+
+  def code_span?
+    @node.marks.present? && @node.marks.include?("code")
+  end
+
+  def conditional_tag(name, condition, options = nil, &block)
+    if condition
+      content_tag name, capture(&block), options
+    else
+      capture(&block)
+    end
+  end
+end

data/app/components/dato/structured_text.html.erb

@@ -0,0 +1,5 @@
+<div class="dato-cms-structured-text">
+  <% @structured_text_node.value.document.children.each do |node| %>
+    <%= render_node(node)  %>
+  <% end %>
+</div>

data/app/components/dato/structured_text.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Dato::StructuredText < Dato::Node
+  def initialize(structured_text_node, overrides: {})
+    unless structured_text_node.is_a?(Hashie::Mash)
+      raise ArgumentError.new("The parameter is not an instance of Hashie::Mash")
+    end
+
+    unless structured_text_node.value.schema == "dast"
+      raise ArgumentError.new("The node schema is '#{structured_text_node.value.schema}' instead of 'dast'")
+    end
+
+    @overrides = overrides.with_indifferent_access
+    @structured_text_node = structured_text_node
+    @blocks = structured_text_node.blocks
+  end
+
+  def root
+    self
+  end
+
+  attr_reader :blocks
+
+  attr_reader :overrides
+end

data/app/components/dato/thematic_break.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class Dato::ThematicBreak < Dato::DastNode
+  def initialize(node, root)
+    super(node, "thematicBreak", root)
+  end
+
+  def generated_tag
+    "hr"
+  end
+end

data/app/components/dato/unknown_block.html.erb

@@ -0,0 +1,17 @@
+<div style="border: 3px dotted limegreen; display: inline-block; padding: 5px;">
+  <b>
+    This is an unknown block. Here is the content:<br>
+    <pre><%= JSON.pretty_generate(@node)  %></pre>
+    In order to render it, you need to define a ViewComponent named <code><%=class_by_type(@node.__typename) %></code>.<br>
+    You can define this class in your <code>app/components/dato</code> folder. For example:<br><br>
+    <code>
+      class <%=class_by_type(@node.__typename) %> < Dato::DastNode<br>
+      ...<br>
+      end<br>
+    </code><br>
+    If you don't want to render this block you can:
+    * not return it in your GraphQL query
+    * the component when rendering the root <code>Dato::StructuredText</code> node.<br>
+    <code>Dato::StructuredText.new(content, overrides: { '<%=@node.__typename %>': Dato::NotRendered })</code>
+  </b>
+</div>

data/app/components/dato/unknown_block.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Dato
+  class UnknownBlock < Node
+    def initialize(block, root)
+      super(block, root)
+    end
+  end
+end

data/app/components/dato/unknown_node.html.erb

@@ -0,0 +1,15 @@
+<div style="border: 3px dotted limegreen; display: inline-block; padding: 5px;">
+  <b>
+    This is an unknown node of type <code><%=@type %></code>.<br>
+    In order to render it, you need to define a ViewComponent named <code><%=class_by_type(@node.type) %></code>.<br>
+    You can define this class in your <code>app/components/dato</code> folder. For example:<br><br>
+    <code>
+      class <%=class_by_type(@node.type) %> < Dato::DastNode<br>
+        ...<br>
+      end<br>
+    </code><br>
+    If you don't want to render this node, you can override the component when rendering the root <code>Dato::StructuredText</code> node.<br>
+    <code>Dato::StructuredText.new(content, overrides: { link: Dato::NotRendered })</code>
+  </b>
+  <%= debug_node %>
+</div>

data/app/components/dato/unknown_node.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Dato
+  class UnknownNode < DastNode
+    def initialize(node, root)
+      super(node, node.type, root)
+    end
+  end
+end

data/app/controllers/dato/live_controller.rb

@@ -0,0 +1,7 @@
+module Dato
+  class LiveController < ActionController::Base
+    def show
+      @data = Hashie::Mash.new(JSON.parse(params[:data], symbolize_names: true).dig(:response, :data))
+    end
+  end
+end

data/app/views/dato/live/show.html.erb

@@ -0,0 +1,3 @@
+<%= turbo_frame_tag params[:frame_id] do %>
+  <%= render params[:component].constantize.new(@data) %>
+<% end %>

data/config/routes.rb

@@ -0,0 +1,3 @@
+Dato::Engine.routes.draw do
+  get "live", to: "live#show"
+end

data/lib/dato/client.rb

@@ -0,0 +1,23 @@
+module Dato
+  class Client < GQLi::Client
+    def initialize(api_token = ENV["DATO_API_TOKEN"], validate_query: false, preview: false, live: false)
+      super(
+        "https://graphql#{"-listen" if live}.datocms.com/#{"preview" if preview}",
+        headers: {
+          "Authorization" => api_token
+        },
+        validate_query: validate_query && !live
+      )
+    end
+
+    def live!(query)
+      http_response = request.post(@url, params: @params, json: {query: query.to_gql})
+
+      fail "Error: #{http_response.reason}\nBody: #{http_response.body}" if http_response.status >= 300
+
+      parsed_response = JSON.parse(http_response.to_s)
+      errors = parsed_response["errors"]
+      GQLi::Response.new(parsed_response, errors, query)
+    end
+  end
+end

data/lib/dato/config.rb

@@ -0,0 +1,8 @@
+module Dato
+  class Config
+    include ActiveSupport::Configurable
+
+    config_accessor(:overrides) { {} }
+    config_accessor(:blocks) { {} }
+  end
+end

data/lib/dato/engine.rb

@@ -0,0 +1,5 @@
+module Dato
+  class Engine < ::Rails::Engine
+    isolate_namespace Dato
+  end
+end

data/lib/dato/fragments/responsive_image.rb

@@ -0,0 +1,13 @@
+Dato::Fragments::ResponsiveImage = GQLi::DSL.fragment("responsiveImageFragment", "ResponsiveImage") {
+  srcSet
+  webpSrcSet
+  sizes
+  src
+  width
+  height
+  aspectRatio
+  alt
+  title
+  bgColor
+  base64
+}

data/lib/dato/version.rb

@@ -0,0 +1,3 @@
+module Dato
+  VERSION = "0.3.0"
+end

data/lib/dato.rb

@@ -0,0 +1,7 @@
+require "gqli"
+require "view_component"
+require "zeitwerk"
+require "dato/engine"
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup

data/lib/tasks/dato/rails_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :dato_rails do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,214 @@
+--- !ruby/object:Gem::Specification
+name: dato-rails
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Alessandro Rodi
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-04-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: standard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  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: capybara
+  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: view_component
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: turbo-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: gqli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1'
+description: This gem allows you to fetch data using Dato GraphQL APIs and render
+  the content in your Rails app.
+email:
+- alessandro.rodi@renuo.ch
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- app/assets/config/dato_rails_manifest.js
+- app/components/dato/block.html.erb
+- app/components/dato/block.rb
+- app/components/dato/blockquote.html.erb
+- app/components/dato/blockquote.rb
+- app/components/dato/code.html.erb
+- app/components/dato/code.rb
+- app/components/dato/dast_node.html.erb
+- app/components/dato/dast_node.rb
+- app/components/dato/heading.rb
+- app/components/dato/link.html.erb
+- app/components/dato/link.rb
+- app/components/dato/list.rb
+- app/components/dato/list_item.rb
+- app/components/dato/live.html.erb
+- app/components/dato/live.rb
+- app/components/dato/node.rb
+- app/components/dato/not_rendered.rb
+- app/components/dato/paragraph.rb
+- app/components/dato/responsive_image.html.erb
+- app/components/dato/responsive_image.rb
+- app/components/dato/span.html.erb
+- app/components/dato/span.rb
+- app/components/dato/structured_text.html.erb
+- app/components/dato/structured_text.rb
+- app/components/dato/thematic_break.rb
+- app/components/dato/unknown_block.html.erb
+- app/components/dato/unknown_block.rb
+- app/components/dato/unknown_node.html.erb
+- app/components/dato/unknown_node.rb
+- app/controllers/dato/live_controller.rb
+- app/views/dato/live/show.html.erb
+- config/routes.rb
+- lib/dato.rb
+- lib/dato/client.rb
+- lib/dato/config.rb
+- lib/dato/engine.rb
+- lib/dato/fragments/responsive_image.rb
+- lib/dato/version.rb
+- lib/tasks/dato/rails_tasks.rake
+homepage: https://github.com/renuo/dato-rails
+licenses: []
+metadata:
+  homepage_uri: https://github.com/renuo/dato-rails
+  source_code_uri: https://github.com/renuo/dato-rails
+  changelog_uri: https://github.com/renuo/dato-rails/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.10
+signing_key:
+specification_version: 4
+summary: Use Dato CMS in your Rails application.
+test_files: []