dato_dast 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ec9fd6604eb5d6466b341c3071baec1ec8936426657459ef3631e1bd8100133
-  data.tar.gz: dbc4702832122215ba3d6f475b9d5a0ca21a5febdd21bbfc1698913217b80c9c
+  metadata.gz: 1b5e7ecc48727c561c2097696d4535dfa553172c06650e61bc0ce880213dc73c
+  data.tar.gz: f7b23ba06e1a0821747b2d8cbd284831edc8a4a9e529e14aab759f956d2526f3
 SHA512:
-  metadata.gz: eae2e50636e043db21e72bdd69f4a9d9c9473f107ba38e0c1e9498181c3d7012c13ad1500a00cc686e153d7429cdd7d56cf0800d32db23ed8c24b0c6afb9427c
-  data.tar.gz: b3f5667c3d741a975eea7fb56e08b12985dac0310bc5eec32cc48a5314d3706f320445d8a406543d85403699c7db88a45641d985c7397f50b5cfb0275d516cd4
+  metadata.gz: 9f99e282c32c80bd00d2ccab60aa54bc30fae81cef1d8a9589afb1aae0183989e03a246007b53800c833006af390297ba8303c241a7ee7e028203d8f5100e9d2
+  data.tar.gz: 7e11c2139df3f9b66e6abd2e850826c4d110d7e90e705a8e23c9849f761f54ba08af1b65975a69ab7f38c21223c096997657799e3ac1774642432b19e4869fa3

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## [0.1.0] - 2021-11-10
+
+Initial minor release
+- Full functionality now available with inline items
+- Block logic extracted into generic item logic to share with inline items
+- Rename errors to match items instead of blocks
+
 ## [0.0.1] - 2021-11-10
 
 - Initial release

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    dato_dast (0.0.1)
+    dato_dast (0.1.0)
       activesupport
 
 GEM

data/README.md

@@ -159,6 +159,14 @@ This would use the `<i>` tag instead of `<emphasis>` and wrap that `<i>` tag wit
 
 </details>
 
+### `config.blocks`
+
+The blocks configuration is a hash with a block `item_type` key and the block configuration. See the [Blocks And Inline Items](#blocks_and_inline_items) section for specific details on block configuration.
+
+### `config.inline_items`
+
+The inline items configuration is a hash with an inline_item `item_type` key and the inline_item configuration. See the [Blocks And Inline Items](#blocks_and_inline_items) section for specific details on block configuration.
+
 ### `config.types`
 
 <details>
@@ -173,13 +181,11 @@ TYPE_CONFIG = {
   "blockquote" => { "tag" => "blockquote", "node" => Nodes::AttributedQuote },
   "code" => { "tag" => "code", "node" => Nodes::Code, "wrappers" => ["pre"] },
   "generic" => { "node" => Nodes::Generic },
-  "heading" => { "tag" => "h#", "node" => Nodes::Heading },
+  "heading" => { "tag" => ->(node) { "h#{node.level}" }, "node" => Nodes::Heading },
+  "inlineItem" => { "node" => Nodes::InlineItem },
   "itemLink" => { "tag" => "a", "node" => Nodes::ItemLink, "url_key" => :slug },
   "link" => { "tag" => "a", "node" => Nodes::Link },
-  "list" => {
-    "bulleted" => { "tag" => "ul", "node" => Nodes::List },
-    "numbered" => { "tag" => "ol", "node" => Nodes::List },
-  },
+  "list" => { "tag" => ->(node) { node.style == "bulleted" ? "ul" : "ol" }, "node" => Nodes::List },
   "listItem" => { "tag" => "li", "node" => Nodes::ListItem },
   "paragraph" => { "tag" => "p", "node" => Nodes::Paragraph },
   "root" => { "tag" => "div", "node" => Nodes::Root },
@@ -192,7 +198,7 @@ Each type configuration takes the following keys:
 - `tag`: The default html tag to use. `nil` can be used to not use a key. Additionally you can provide a lambda that takes the Node object.
 - `node`: This represents the Node object used for rendering. See [Nodes](#nodes) for more details.
 - `css_class`: This is a string that is used in the `class=""` attribute of the tag. Additionally you can provide a lambda that takes the Node object.
-- [ ] `meta`: This is an array of hashes matching the dast meta structure. E.g. Found in the [`link`](https://www.datocms.com/docs/structured-text/dast#link) node. Additionally you can provide a lamdbda that takes the Node object.
+- `meta`: This is an array of hashes matching the dast meta structure. E.g. Found in the [`link`](https://www.datocms.com/docs/structured-text/dast#link) node. Additionally you can provide a lamdbda that takes the Node object.
   - The structure is `{ "id" => "data-value", "value" => "1"}` renders as `<div data-value="1">`
 - `wrappers`: This represents additional wrappers use to surrounded the given node type. See [Wrappers](#wrappers) for more details.
 
@@ -342,6 +348,16 @@ One note about the `Heading` node, is that it accepts a tag with a `#` symbol wh
 
 </details>
 
+### `inlineItem`
+
+<details>
+
+Represents the [DatoCMS `inlineItem`](https://www.datocms.com/docs/structured-text/dast#inlineItem) node.
+
+Inline items should be configured on a per-item basis. See the [Block and Inline Items](#blocks_and_inline_items) section on how to configure specific inline items.
+
+</details>
+
 ### `itemLink`
 
 <details>
@@ -643,7 +659,7 @@ This would be rendered using the `ThematicBreak` node, which would render as:
 
 ## Wrappers
 
-Marks, Types, and Blocks all supports configuring a `wrappers` field.
+Marks, Types, Inline Items, and Blocks all supports configuring a `wrappers` field.
 
 The wrappers are rendered from the outside in, so the first wrapper will wrap the following wrappers.
 
@@ -702,36 +718,54 @@ end
 
 As a result, the thematic break node can't be wrapped nor does it apply a specific tag.
 
-Additionally, the `block` type has a specific render method for the complex rendering that blocks entail.
+Additionally, the `block` and `inlineItem` types have a specific render method for the complex rendering that items entail.
 
 </details>
 
-## Blocks
+## Blocks and Inline Items
 
-Blocks are the most powerful parts of structured text. We can take objects and render them in a specific way.
+Blocks and Inline Items are the most powerful parts of structured text. We can take DatoCMS objects and render them in a specific way.
 
-Blocks can take the same values as nodes. One difference with blocks is that the block object is provided to the proc instead of the node when a Proc is provided.
+We refer to both blocks and inline items as "items". In the DatoCMS api, objects have an `item_type` and they are referred to instructured texts as `items` so the name seems a good fit.
 
-- `tag`
-- `css_class`
-- `meta`
+**Configuration**
 
-The block configuration takes `item_type` value and you must provide one of three methods for rendering:
+Blocks and Inline Items take the exact type of configuration, just under a different key:
 
-- `node`
-- `render_value`
-- `structure`
+```ruby
+config = {...}
+DatoDast.configure do |config|
+  config.block = config
+  config.inline_items = config
+end
+```
+
+This is a valid configuration setup. However, blocks are typically a DatoCMS block, while Inline Items are typically a model. Additionally, inline items are rendered...well...inline, so you may want to render something different when it's in block form vs inline.
+
+Items can take the same values as nodes. (One difference with items is that the item object is provided to the proc instead of the node when a Proc is provided.)
+
+- `tag`: The default html tag to use. `nil` can be used to not use a key. Additionally you can provide a lambda that takes the Node object.
+- `css_class`: This is a string that is used in the `class=""` attribute of the tag. Additionally you can provide a lambda that takes the Node object.
+- `meta`: This is an array of hashes matching the dast meta structure. E.g. Found in the [`link`](https://www.datocms.com/docs/structured-text/dast#link) node. Additionally you can provide a lamdbda that takes the Node object.
+  - The structure is `{ "id" => "data-value", "value" => "1"}` renders as `<div data-value="1">`
+- `wrappers`: This represents additional wrappers use to surrounded the given node type. See [Wrappers](#wrappers) for more details.
+
+The item configuration takes `item_type` value and you must provide one of three methods for rendering:
+
+- `node`: This represents the Node object used for rendering. See [Nodes](#nodes) for more details.
+- `render_value` : This represents a lambda that takes the item as an argument and returns the result of the lambda.
+- `structure`: This is a hash structure for rendering complex setups without needing to use nodes.
 
 ### `node`
 
-If you supply the `node` key, you must provide a class that takes the block hash as the only argument for `initialize` and has a `render` function.
+If you supply the `node` key, you must provide a class that takes the item hash as the only argument for `initialize` and has a `render` function.
 
 <details>
 
 For example:
 
 ```ruby
-# Let's say we have an (abbreviated) Photo block that has a dato cms image under ":image" and a ":caption" string
+# Let's say we have an (abbreviated) Photo item that has a dato cms image under ":image" and a ":caption" string
 # {
 #   :id=>"1",
 #   :item_type=>"photo",
@@ -786,12 +820,12 @@ This node would render the following html:
 
 ### `render_value`
 
-`render_value` is a simpler form where you can supply a lamba that takes the hash object and it will render the lambda by calling it with the block hash.
+`render_value` is a simpler form where you can supply a lamba that takes the hash object and it will render the lambda by calling it with the item hash.
 
 <details>
 
 ```ruby
-# Using the following block hash
+# Using the following item hash
 # {
 #   :id=>"1",
 #   :item_type=>"photo",
@@ -803,9 +837,9 @@ This node would render the following html:
 # }
 
 DatoDast.configure do |config|
-  config.blocks = {
+  config.inline_items = {
     "photo" => {
-      "render_value" => ->(block) { "<img src='#{block[:url]}' />" },
+      "render_value" => ->(item) { "<img src='#{item[:url]}' />" },
     }
   }
 end
@@ -821,16 +855,16 @@ This would render the following html:
 
 ### `structure`
 
-The most powerful part of `DatoDast` is the `structure` tools for rendering blocks.
+The most powerful part of `DatoDast` is the `structure` tools for rendering items.
 
-The `structure` configuration can be used on nested blocks or relationships to construct multiple tags.
+The `structure` configuration can be used on nested items or relationships to construct multiple tags.
 
 The `structure` format is an array of hashes each with a "type" field. The "type" can be one of four values:
 
 - `"field"`
 - `"value"`
-- `"block"`
-- `"blocks"`
+- `"item"`
+- `"items"`
 
 ### `field`
 
@@ -881,7 +915,7 @@ Would render the following html:
 
 <details>
 
-When the type is `"value"`, then you also must provide a `"render_value"` function that takes the block hash as an argument and returns a string.
+When the type is `"value"`, then you also must provide a `"render_value"` function that takes the item hash as an argument and returns a string.
 
 ```ruby
 # With the object
@@ -905,7 +939,7 @@ DatoDast.configure do |config|
           "type" => "value",
           "tag" => "span",
           "css_class" => "blue",
-          "render_value" => ->(block) { block[:caption] },
+          "render_value" => ->(item) { item[:caption] },
         },
       ],
     },
@@ -922,14 +956,14 @@ Would render the following html:
 ```
 </details>
 
-### `block`
+### `item`
 
 <details>
 
-When the type is `"block"`, then you also must provide a `"field"` value that specifies the field which contains another block. That block will the be rendered using the some block configuration.
+When the type is `"item"`, then you also must provide a `"field"` value that specifies the field which contains another item. That item will the be rendered using the same item configuration.
 
 ```ruby
-# Let's imagine a card object with photo block relationship and caption
+# Let's imagine a card object with photo item relationship and caption
 # {
 #   :id=>"2",
 #   :item_type => "card",
@@ -946,7 +980,7 @@ When the type is `"block"`, then you also must provide a `"field"` value that sp
 #   :caption=>"My Logo",
 # }
 DatoDast.configure do |config|
-  config.blocks = {
+  config.inline_items = {
     "card" => {
       "wrappers" => {
         "tag" => "div",
@@ -956,9 +990,9 @@ DatoDast.configure do |config|
           "value" => "1",
         }],
       },
-      "structure" => []
+      "structure" => [
         {
-          "type" => "block",
+          "type" => "item",
           "field" => "photo",
         },
         {
@@ -971,7 +1005,7 @@ DatoDast.configure do |config|
     "photo" => {
       "tag" => "div",
       "css_class" => "img",
-      "render_value" => ->(block) { "<img src='#{block[:url]}' />" }
+      "render_value" => ->(item) { "<img src='#{item[:url]}' />" }
     }
   }
 end
@@ -990,14 +1024,14 @@ Would render the following html:
 
 </details>
 
-### `blocks`
+### `items`
 
 <details>
 
-When the type is `"blocks"`, then you also must provide a `"field"` value that specifies the field which contains an array of blocks. That block will the be rendered using the some block configuration.
+When the type is `"items"`, then you also must provide a `"field"` value that specifies the field which contains an array of items. That item will the be rendered using the some item configuration.
 
 ```ruby
-# Let's imagine a card object with photo block relationship and caption
+# Let's imagine a card object with photo item relationship and caption
 # {
 #   :id=>"2",
 #   :item_type => "card",
@@ -1038,7 +1072,7 @@ DatoDast.configure do |config|
       },
       "structure" => []
         {
-          "type" => "block",
+          "type" => "items",
           "field" => "gallery",
           "tag" => "div",
           "css_class" => "gallery",
@@ -1053,7 +1087,7 @@ DatoDast.configure do |config|
     "photo" => {
       "tag" => "div",
       "css_class" => "img",
-      "render_value" => ->(block) { "<img src='#{block[:url]}' />" }
+      "render_value" => ->(item) { "<img src='#{item[:url]}' />" }
     }
   }
 end
@@ -1079,4 +1113,4 @@ Would render the following html:
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[dewyze]/dato_dast.
+Bug reports and pull requests are welcome on GitHub at https://github.com/dewyze/dato_dast.

data/lib/dato_dast/configuration.rb

@@ -8,6 +8,7 @@ module DatoDast
       Nodes::Code.type => { "tag" => "code", "node" => Nodes::Code, "wrappers" => ["pre"] },
       Nodes::Generic.type => { "node" => Nodes::Generic },
       Nodes::Heading.type => { "tag" => ->(node) { "h#{node.level}" }, "node" => Nodes::Heading },
+      Nodes::InlineItem.type => { "node" => Nodes::InlineItem },
       Nodes::ItemLink.type => { "tag" => "a", "node" => Nodes::ItemLink, "url_key" => :slug },
       Nodes::Link.type => { "tag" => "a", "node" => Nodes::Link },
       Nodes::List.type => { "tag" => ->(node) { node.style == "bulleted" ? "ul" : "ol" }, "node" => Nodes::List },
@@ -27,13 +28,14 @@ module DatoDast
       Marks::UNDERLINE => { "tag" => "u" },
     }.freeze
 
-    BLOCK_RENDER_KEYS = ["node", "render_value", "structure"].freeze
+    ITEM_RENDER_KEYS = ["node", "render_value", "structure"].freeze
 
-    attr_reader :blocks, :host, :marks, :types
+    attr_reader :blocks, :host, :inline_items, :marks, :types
     attr_accessor :highlight, :item_links, :smart_links
 
     def initialize
       @blocks = {}
+      @inline_items = {}
       @highlight = true
       @host = nil
       @item_links = {}
@@ -53,11 +55,17 @@ module DatoDast
     end
 
     def blocks=(new_blocks)
-      validate_blocks_configuration(new_blocks)
+      validate_items_configuration(new_blocks, "blocks")
 
       @blocks = new_blocks
     end
 
+    def inline_items=(new_inline_items)
+      validate_items_configuration(new_inline_items, "inline_items")
+
+      @inline_items = new_inline_items
+    end
+
     def marks=(new_marks)
       validate_marks_configuration(new_marks)
 
@@ -78,17 +86,17 @@ module DatoDast
 
     private
 
-    def validate_blocks_configuration(blocks_config)
-      invalid_blocks = []
+    def validate_items_configuration(items_config, type)
+      invalid_items = []
 
-      blocks_config.each do |block, block_config|
-        next if block_config.is_a?(Proc)
+      items_config.each do |item, item_config|
+        next if item_config.is_a?(Proc)
 
-        intersection = block_config.keys & BLOCK_RENDER_KEYS
-        invalid_blocks << block unless intersection.length == 1
+        intersection = item_config.keys & ITEM_RENDER_KEYS
+        invalid_items << "#{type}->#{item}" unless intersection.length == 1
       end
 
-      raise Errors::InvalidBlocksConfiguration.new(invalid_blocks) if invalid_blocks.present?
+      raise Errors::InvalidItemsConfiguration.new(invalid_items) if invalid_items.present?
     end
 
     def validate_types(types_config)

data/lib/dato_dast/errors/{block_field_missing.rb → field_missing.rb}

@@ -1,10 +1,10 @@
 module DatoDast
   module Errors
-    class BlockFieldMissing < StandardError
+    class FieldMissing < StandardError
       MESSAGE = <<~MSG.strip
         A structure type of 'field' requires the block to have the specified field.
 
-        The following block configuration is invalid:
+        The following configuration is invalid:
       MSG
 
       def initialize(item_type)

data/lib/dato_dast/errors/{invalid_blocks_configuration.rb → invalid_items_configuration.rb}

@@ -1,13 +1,13 @@
 module DatoDast
   module Errors
-    class InvalidBlocksConfiguration < StandardError
+    class InvalidItemsConfiguration < StandardError
       MESSAGE = <<~MSG.strip
-        A block configuration requires exactly one of the following keys:
+        An item configuration requires exactly one of the following keys:
         - "node"
         - "render_value"
         - "structure"
 
-        The following block configurations are invalid:
+        The following configurations are invalid:
       MSG
 
       def initialize(keys)

data/lib/dato_dast/errors/invalid_structure_type.rb

@@ -0,0 +1,6 @@
+module DatoDast
+  module Errors
+    class InvalidStructureType < StandardError
+    end
+  end
+end

data/lib/dato_dast/errors/missing_item_configuration.rb

@@ -0,0 +1,15 @@
+module DatoDast
+  module Errors
+    class MissingItemConfiguration < StandardError
+      MESSAGE = <<~MSG.strip
+        An configuration must be provided for every item type.
+
+        The configuration for the following item type is invalid:
+      MSG
+
+      def initialize(key)
+        super(MESSAGE + " " + key)
+      end
+    end
+  end
+end

data/lib/dato_dast/errors/missing_render_function.rb

@@ -0,0 +1,15 @@
+module DatoDast
+  module Errors
+    class MissingRenderFunction < StandardError
+      MESSAGE = <<~MSG.strip
+        A node class provided for an item must have a 'render' method.
+
+        The node object for the following item type is invalid:
+      MSG
+
+      def initialize(keys)
+        super(MESSAGE + " " + keys.join(", "))
+      end
+    end
+  end
+end

data/lib/dato_dast/errors/missing_render_value_function.rb

@@ -4,7 +4,7 @@ module DatoDast
       MESSAGE = <<~MSG.strip
         A structure type of 'value' requires a render value function.
 
-        The following block configuration is invalid:
+        The following configuration is invalid:
       MSG
 
       def initialize(item_type)

data/lib/dato_dast/errors.rb

@@ -1,8 +1,9 @@
-require "dato_dast/errors/block_field_missing"
-require "dato_dast/errors/block_node_missing_render_function"
-require "dato_dast/errors/invalid_block_structure_type"
-require "dato_dast/errors/invalid_blocks_configuration"
+require "dato_dast/errors/field_missing"
+require "dato_dast/errors/invalid_items_configuration"
 require "dato_dast/errors/invalid_marks_configuration"
 require "dato_dast/errors/invalid_nodes"
+require "dato_dast/errors/invalid_structure_type"
 require "dato_dast/errors/invalid_types_configuration"
+require "dato_dast/errors/missing_item_configuration"
+require "dato_dast/errors/missing_render_function"
 require "dato_dast/errors/missing_render_value_function"

data/lib/dato_dast/extensions/middleman.rb

@@ -6,6 +6,7 @@ module DatoDast
       option :blocks, {}, "Configuration hash for blocks"
       option :host, nil, "Host for your site, used in conjunction with 'smart_links' option"
       option :highlight, true, "Toggle whether to attempt to higlight code blocks"
+      option :inline_items, {}, "Configuration hash for inlineItems"
       option :item_links, {}, "Configuration hash item links types and the url field"
       option :marks, {}, "Configuration hash for a given mark"
       option :smart_links, true, "Open Link items in new windows and ItemLinks in the same window"
@@ -16,6 +17,7 @@ module DatoDast
           config.blocks = options[:blocks]
           config.highlight = options[:highlight]
           config.host = options[:host]
+          config.inline_items = options[:inline_items]
           config.item_links = options[:item_links]
           config.marks = options[:marks]
           config.smart_links = options[:smart_links]

data/lib/dato_dast/nodes/block.rb

@@ -1,124 +1,13 @@
 module DatoDast
   module Nodes
-    class Block < Base
-      def block_id
-        @node["item"]
-      end
-
-      def block
-        return @block if @block
-
-        @block ||= @blocks.find { |block| block[:id] == block_id }
-      end
-
-      def item_type
-        block[:item_type]
-      end
-
-      def node
-        node_config["node"]
+    class Block < Item
+      def item_repo
+        @blocks
       end
 
       def node_config
         config.blocks[item_type]
       end
-
-      def children
-        Array.wrap(structure).map do |child|
-          case child["type"]
-          when "field"
-            build_field(child)
-          when "value"
-            build_value(child)
-          when "block"
-            build_block(block[child["field"].to_sym])
-          when "blocks"
-            build_blocks(child)
-          else
-            raise Errors::InvalidBlockStructureType
-          end.merge(extract_tags(child)).compact
-        end.flatten
-      end
-
-      def render_value
-        if node_config["render_value"]
-          node_config["render_value"].call(block)
-        else
-          render_children
-        end
-      end
-
-      def render
-        return super unless node
-
-        begin
-          node.new(block).render
-        rescue NoMethodError => _e
-          raise Errors::BlockNodeMissingRenderFunction.new(["block->#{item_type}"])
-        end
-      end
-
-      private
-
-      def structure
-        node_config["structure"]
-      end
-
-      def extract_tags(child)
-        {
-          "tag" => child["tag"],
-          "css_class" => child["css_class"],
-          "meta" => child["meta"],
-          "wrappers" => child["wrappers"],
-        }.compact
-      end
-
-      def build_field(child)
-        raise Errors::BlockFieldMissing.new(item_type) unless child["field"]
-
-        field = child["field"].to_sym
-        value = block[field]
-
-        {
-          "type" => "span",
-          "value" => value,
-          "marks" => Array.wrap(child["marks"]),
-        }
-      end
-
-      def build_value(child)
-        raise Errors::MissingRenderValueFunction.new(item_type) unless child["render_value"]
-
-        value = child["render_value"].call(block)
-
-        {
-          "type" => "span",
-          "value" => value,
-          "marks" => Array.wrap(child["marks"]),
-        }
-      end
-
-      def build_block(child)
-        @blocks << child
-
-        {
-          "type" => "block",
-          "item" => child[:id],
-        }
-      end
-
-      def build_blocks(child)
-        field = child["field"].to_sym
-
-        parent = {
-          "type" => "generic",
-          "children" => Array.wrap(block[field]).map { |child_block| build_block(child_block) }
-        }
-      end
-
-      def proc_object
-        block
-      end
     end
   end
 end

data/lib/dato_dast/nodes/inline_item.rb

@@ -1,14 +1,13 @@
-# An inlineItem, similarly to itemLink, links the document to another record but does not specify any inner content (children).
-#
-# It can be used in situations where it is up to the frontend to decide how to present the record (ie. a widget, or an <a> tag pointing to the URL of the record with a text that is the title of the linked record).
-#
-# It does not allow children nodes.
-#
-# type  "inlineItem"  Required
-# item  string  Required
-# The DatoCMS record ID
-#
-# {
-#   "type": "inlineItem",
-#   "item": "74619345"
-# }
+module DatoDast
+  module Nodes
+    class InlineItem < Item
+      def item_repo
+        @links
+      end
+
+      def node_config
+        config.inline_items[item_type]
+      end
+    end
+  end
+end

data/lib/dato_dast/nodes/item.rb

@@ -0,0 +1,138 @@
+module DatoDast
+  module Nodes
+    class Item < Base
+      def item_id
+        @node["item"]
+      end
+
+      def item
+        return @item if @item
+
+        @item ||= item_repo.find { |item| item[:id] == item_id }
+      end
+
+      def item_type
+        item[:item_type]
+      end
+
+      def node
+        raise DatoDast::Errors::MissingItemConfiguration.new(error_label) unless node_config
+
+        node_config["node"]
+      end
+
+      def children
+        Array.wrap(structure).map do |child|
+          case child["type"]
+          when "field"
+            build_field(child)
+          when "value"
+            build_value(child)
+          when "item"
+            build_item(item[child["field"].to_sym])
+          when "items"
+            build_items(child)
+          else
+            raise DatoDast::Errors::InvalidStructureType.new(error_label)
+          end.merge(extract_tags(child)).compact
+        end.flatten
+      end
+
+      def render_value
+        if node_config["render_value"]
+          node_config["render_value"].call(item)
+        else
+          render_children
+        end
+      end
+
+      def render
+        return super unless node
+
+        begin
+          node.new(item).render
+        rescue NoMethodError => _e
+          raise DatoDast::Errors::MissingRenderFunction.new([error_label])
+        end
+      end
+
+      private
+
+      def label
+        @node["type"]
+      end
+
+      def error_label
+        "#{label}->#{item_type}"
+      end
+
+      def item_repo
+        raise NotImplementedError
+      end
+
+      def node_config
+        raise NotImplementedError
+      end
+
+      def structure
+        node_config["structure"]
+      end
+
+      def extract_tags(child)
+        {
+          "tag" => child["tag"],
+          "css_class" => child["css_class"],
+          "meta" => child["meta"],
+          "wrappers" => child["wrappers"],
+        }.compact
+      end
+
+      def build_field(child)
+        raise DatoDast::Errors::FieldMissing.new(error_label) unless child["field"]
+
+        field = child["field"].to_sym
+        value = item[field]
+
+        {
+          "type" => "span",
+          "value" => value,
+          "marks" => Array.wrap(child["marks"]),
+        }
+      end
+
+      def build_value(child)
+        raise Errors::MissingRenderValueFunction.new(error_label) unless child["render_value"]
+
+        value = child["render_value"].call(item)
+
+        {
+          "type" => "span",
+          "value" => value,
+          "marks" => Array.wrap(child["marks"]),
+        }
+      end
+
+      def build_item(child)
+        item_repo << child
+
+        {
+          "type" => label,
+          "item" => child[:id],
+        }
+      end
+
+      def build_items(child)
+        field = child["field"].to_sym
+
+        parent = {
+          "type" => "generic",
+          "children" => Array.wrap(item[field]).map { |child_item| build_item(child_item) }
+        }
+      end
+
+      def proc_object
+        item
+      end
+    end
+  end
+end

data/lib/dato_dast/nodes.rb

@@ -1,4 +1,5 @@
 require "dato_dast/nodes/base"
+require "dato_dast/nodes/item"
 require "dato_dast/nodes/span"
 require "dato_dast/nodes/generic"
 require "dato_dast/nodes/block"

data/lib/dato_dast/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dato_dast
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - John DeWyze
@@ -62,13 +62,14 @@ files:
 - lib/dato_dast.rb
 - lib/dato_dast/configuration.rb
 - lib/dato_dast/errors.rb
-- lib/dato_dast/errors/block_field_missing.rb
-- lib/dato_dast/errors/block_node_missing_render_function.rb
-- lib/dato_dast/errors/invalid_block_structure_type.rb
-- lib/dato_dast/errors/invalid_blocks_configuration.rb
+- lib/dato_dast/errors/field_missing.rb
+- lib/dato_dast/errors/invalid_items_configuration.rb
 - lib/dato_dast/errors/invalid_marks_configuration.rb
 - lib/dato_dast/errors/invalid_nodes.rb
+- lib/dato_dast/errors/invalid_structure_type.rb
 - lib/dato_dast/errors/invalid_types_configuration.rb
+- lib/dato_dast/errors/missing_item_configuration.rb
+- lib/dato_dast/errors/missing_render_function.rb
 - lib/dato_dast/errors/missing_render_value_function.rb
 - lib/dato_dast/extensions/middleman.rb
 - lib/dato_dast/html_tag.rb
@@ -82,6 +83,7 @@ files:
 - lib/dato_dast/nodes/generic.rb
 - lib/dato_dast/nodes/heading.rb
 - lib/dato_dast/nodes/inline_item.rb
+- lib/dato_dast/nodes/item.rb
 - lib/dato_dast/nodes/item_link.rb
 - lib/dato_dast/nodes/link.rb
 - lib/dato_dast/nodes/list.rb

data/lib/dato_dast/errors/block_node_missing_render_function.rb

@@ -1,15 +0,0 @@
-module DatoDast
-  module Errors
-    class BlockNodeMissingRenderFunction < StandardError
-      MESSAGE = <<~MSG.strip
-        A node class provided for a block must have a 'render' method.
-
-        The node object for the following block item type is invalid:
-      MSG
-
-      def initialize(keys)
-        super(MESSAGE + " " + keys.join(", "))
-      end
-    end
-  end
-end

data/lib/dato_dast/errors/invalid_block_structure_type.rb

@@ -1,6 +0,0 @@
-module DatoDast
-  module Errors
-    class InvalidBlockStructureType < StandardError
-    end
-  end
-end