line-message-builder 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e34932b3afe2a1bbe05967e19991c2d1af583094e2b60be909efa9c773296fe
-  data.tar.gz: 2c7c94550e9b29a943b517aa5b19a9d03ec213a8779df05b1d0c55a886b8872b
+  metadata.gz: e0b31fce5c00d5f47ade90df479d30b79361f73e3e08852e10f4f90996de5bb9
+  data.tar.gz: 6a72a291942bd3f7448f5a294da49dd3321424d5dad057745590e4b96b1a1abb
 SHA512:
-  metadata.gz: c60b5ee94ee4e2f8dc658acace8538af12c9ee374f48b5fb5577c4baf43d93d661b2b47e18d8d09ee7f0e99f9fdbd0cdc3ce05e9bfd54c96ad36acd82b7b0cb6
-  data.tar.gz: afb292eec260c30163e79d8108471a7a5db4a722d6f44d54de7e25ae884375968addb2b6be9271240a6aae58023539acaca99109eeba95fc016e0e4aae94f0c8
+  metadata.gz: bb358c2a18903395e07bfc878d3befe2048ad23c5d68b4e5cd23e17e1914bb300f7a692858a68f9c71daa3630b1f30761ab5fc603887296c1d1cffd4964b7414
+  data.tar.gz: 342237372588844319052e9be35b1014024f5f93552f99699137f19a5abf7f341bd03eda306f4f2c5d181c50f257f47fdf5f0a7899cc2093312a91d4cd42667f

data/.document

@@ -0,0 +1,3 @@
+lib
+README.md
+LICENSE.txt

data/.release-please-manifest.json

@@ -1 +1 @@
-{".":"0.7.0"}
+{".":"0.9.0"}

data/.rubocop.yml

@@ -6,6 +6,8 @@ AllCops:
   TargetRubyVersion: 3.1
   NewCops: enable
   SuggestExtensions: false
+  Exclude:
+    - 'vendor/**/*'
 
 Style/StringLiterals:
   EnforcedStyle: double_quotes

data/CHANGELOG.md

@@ -1,5 +1,40 @@
 # Changelog
 
+## [0.9.0](https://github.com/elct9620/line-message-builder/compare/v0.8.0...v0.9.0) (2025-06-03)
+
+
+### Features
+
+* add flex separator matcher and tests for flex message components ([0d34bc9](https://github.com/elct9620/line-message-builder/commit/0d34bc9fcfeef9d2ca519548f4a83a3de046eb33))
+* add Flex::Span message builder for LINE messaging API ([a8377e9](https://github.com/elct9620/line-message-builder/commit/a8377e93861fa286e95a69d3cb3c9897c1992044))
+* add have_line_flex_span matcher and comprehensive tests for span component ([b9072cd](https://github.com/elct9620/line-message-builder/commit/b9072cd3e4c56c9346bb3d6cf98ee11374029807))
+* add Separator builder for Flex messages ([accb2aa](https://github.com/elct9620/line-message-builder/commit/accb2aa41f9a016445f377f97e93f085734764c4))
+* add separator method to Flex::Box for adding separator elements ([4125ae1](https://github.com/elct9620/line-message-builder/commit/4125ae15fd5666431ec864121cf40d3c4fb0f56f))
+* add Span component for styled text in Flex Messages ([a458d1d](https://github.com/elct9620/line-message-builder/commit/a458d1d2473e0859bc7e1c81254888a8c8fde9a7))
+* add span method to flex box builder and remove related specs ([af8dc8f](https://github.com/elct9620/line-message-builder/commit/af8dc8f9f4b8c8a7a12c15db23a50331dfc102cb))
+* add support for spans within flex text components ([90ab15d](https://github.com/elct9620/line-message-builder/commit/90ab15df7044d15308d23ef864a69f84d71e28e7))
+
+
+### Bug Fixes
+
+* add Flex::Separator component and require it in flex.rb ([4152c10](https://github.com/elct9620/line-message-builder/commit/4152c1024a7634b526f94fa4e76a518a6ff0787c))
+* ensure matcher finds flex separator in all nested containers ([d289ea1](https://github.com/elct9620/line-message-builder/commit/d289ea178e17d4ca00b796a9f666c527982d82f6))
+* remove duplicate Separator class definition in flex separator.rb ([2c6b6d0](https://github.com/elct9620/line-message-builder/commit/2c6b6d063a2da97a0781591a697cf3034cb135f6))
+
+## [0.8.0](https://github.com/elct9620/line-message-builder/compare/v0.7.0...v0.8.0) (2025-05-24)
+
+
+### Features
+
+* Add GitHub Action for RDoc generation and deployment ([dbb0f79](https://github.com/elct9620/line-message-builder/commit/dbb0f797ae6143bb9f463c8e6c111a5fe1f0a53f))
+* Add GitHub Action for RDoc generation and deployment ([#9](https://github.com/elct9620/line-message-builder/issues/9)) ([c1a9920](https://github.com/elct9620/line-message-builder/commit/c1a99203b3abef99d149ecc7a055367268f5c2f8))
+* add mode option to Line::Message::Builder for SDKv2 support ([f44f787](https://github.com/elct9620/line-message-builder/commit/f44f78758f5cac1dda6cf86f4c1945365c6c1018))
+
+
+### Bug Fixes
+
+* pass context to quick reply actions to resolve sdkv2 method error ([1bec753](https://github.com/elct9620/line-message-builder/commit/1bec7539421c0c11b10d2e906f9ee7f44a1c726f))
+
 ## [0.7.0](https://github.com/elct9620/line-message-builder/compare/v0.6.1...v0.7.0) (2025-05-21)
 
 

data/CONVENTIONS.md

@@ -16,6 +16,42 @@ This gem is designed to provide DSL (Domain Specific Language) for building LINE
 
 Only use comments for RDoc documentation. Do not use comments to explain anything in the code. The code should be self-explanatory. If you find yourself needing to write a comment to explain something, consider refactoring the code instead.
 
+## DSL
+
+When using the `Line::Message::Builder` DSL, following is recommended:
+
+```ruby
+Line::Message::Builder.with do
+  flex alt_text: "Hello, World!" do
+    bubble do
+      header do
+        text "Welcome to LINE Messaging API"
+      end
+      body do
+        text "This is a sample message."
+      end
+    end
+  end
+end
+```
+
+DO NOT use `do |container|` syntax as following:
+
+```ruby
+Line::Message::Builder.with do |builder|
+  builder.flex alt_text: "Hello, World!" do
+    builder.bubble do
+      builder.header do
+        builder.text "Welcome to LINE Messaging API"
+      end
+      builder.body do
+        builder.text "This is a sample message."
+      end
+    end
+  end
+end
+```
+
 ## RSpec
 
 - Write feature tests instead of unit tests, use `Line::Message::Builder` as test subject to verify the behavior of the DSL.

data/README.md

@@ -3,6 +3,7 @@
 [![.github/workflows/main.yml](https://github.com/elct9620/line-message-builder/actions/workflows/main.yml/badge.svg)](https://github.com/elct9620/line-message-builder/actions/workflows/main.yml)
 [![codecov](https://codecov.io/gh/elct9620/line-message-builder/graph/badge.svg?token=9TJTSRIL0X)](https://codecov.io/gh/elct9620/line-message-builder)
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/elct9620/line-message-builder)
+[![Documentation](https://img.shields.io/badge/docs-gh--pages-brightgreen)](https://elct9620.github.io/line-message-builder/)
 
 Build LINE messages using DSL (Domain Specific Language) in Ruby.
 
@@ -11,6 +12,7 @@ Build LINE messages using DSL (Domain Specific Language) in Ruby.
 - Build LINE messages using DSL
 - Validation of properties
 - RSpec matchers for testing
+- LINE Bot SDK v2 support (Experimental)
 
 ## Installation
 
@@ -31,18 +33,32 @@ gem install line-message-builder
 > [!NOTE]
 > Working in progress.
 
+### LLM.txt
+
+The `llm.txt` is available in document assets.
+
+You can get it from [http://aotoki.me/line-message-builder/llm.txt](http://aotoki.me/line-message-builder/llm.txt).
+
 ### Builder
 
 ```ruby
 builder = Line::MessageBuilder::Builder.with do
-    text "Hello, world!"
+  text "Hello, world!"
 end
 
 pp builder.build
 # => [{ type: "text", text: "Hello, world!" }]
 
 puts builder.to_json
-# => {"type":"text","text":"Hello, world!"}
+# => "[{\"type\":\"text",\"text\":\"Hello, world!\"}"
+```
+
+To use with [line-bot-sdk-ruby](https://github.com/line/line-bot-sdk-ruby) v2, you can set mode to `sdkv2`:
+
+```ruby
+builder = Line::MessageBuilder::Builder.with(mode: :sdkv2) do
+  text "Hello, world!"
+end
 ```
 
 ### Context
@@ -51,18 +67,18 @@ The context can make `Builder` to access additional methods and variables.
 
 ```ruby
 context = OpenStruct.new(
-    name: "John Doe",
+  name: "John Doe",
 )
 
 builder = Line::MessageBuilder::Builder.with(context) do
-    text "Hello, #{name}!"
+  text "Hello, #{name}!"
 end
 
 pp builder.build
 # => [{ type: "text", text: "Hello, John Doe!" }]
 
 puts builder.to_json
-# => {"type":"text","text":"Hello, John Doe!"}
+# => "[{\"type\":\"text\",\"text\":\"Hello, John Doe!\"}"
 ```
 
 For Rails, you can use `view_context` to make `Builder` to access Rails helpers.
@@ -70,12 +86,12 @@ For Rails, you can use `view_context` to make `Builder` to access Rails helpers.
 ```ruby
 # app/controllers/line_controller.rb
 builder = Line::MessageBuilder::Builder.with(view_context) do
-    text "Anything you want?" do
-        quick_reply do
-            message "Yes", label: "Yes", image_url: image_url("yes.png")
-            message "No", label: "No", image_url: image_url("no.png")
-        end
+  text "Anything you want?" do
+    quick_reply do
+      message "Yes", label: "Yes", image_url: image_url("yes.png")
+      message "No", label: "No", image_url: image_url("no.png")
     end
+  end
 end
 ```
 
@@ -84,18 +100,18 @@ If not in controller, you can create a `ActionView::Base` instance and pass it t
 ```ruby
 # app/presenters/line_presenter.rb
 context = ActionView::Base.new(
-    ActionController::Base.view_paths,
-    {},
-    ActionController::Base.new,
+  ActionController::Base.view_paths,
+  {},
+  ActionController::Base.new,
 )
 
 builder = Line::MessageBuilder::Builder.with(context) do
-    text "Anything you want?" do
-        quick_reply do
-            message "Yes", label: "Yes", image_url: image_url("yes.png")
-            message "No", label: "No", image_url: image_url("no.png")
-        end
+  text "Anything you want?" do
+    quick_reply do
+      message "Yes", label: "Yes", image_url: image_url("yes.png")
+      message "No", label: "No", image_url: image_url("no.png")
     end
+  end
 end
 ```
 
@@ -163,6 +179,7 @@ end
 | `have_line_flex_image`      | Match a flex message with image      |
 | `have_line_flex_button`     | Match a flex message with button     |
 | `have_line_flex_box`        | Match a flex message with box        |
+| `have_line_flex_separator`  | Match a flex message with separator  |
 
 
 Add `line/message/rspec` to your `spec_helper.rb` or `rails_helper.rb`:
@@ -175,7 +192,7 @@ Include `Line::Message::RSpec::Matchers` in your RSpec configuration:
 
 ```ruby
 RSpec.configure do |config|
-    config.include Line::Message::RSpec::Matchers
+  config.include Line::Message::RSpec::Matchers
 end
 ```
 
@@ -183,10 +200,10 @@ Then the matchers are available in your specs:
 
 ```ruby
 let(:builder) do
-    Line::MessageBuilder::Builder.with do
-        text "Hello, world!"
-        text "Nice to meet you!"
-    end
+  Line::MessageBuilder::Builder.with do
+    text "Hello, world!"
+    text "Nice to meet you!"
+  end
 end
 
 subject { builder.build }
@@ -199,12 +216,13 @@ The matchers can work with webmock `a_request`:
 
 ```ruby
 it "reply with message" do
-    expect(a_request(:post, "https://api.line.me/v2/bot/message/reply")
-        .with(
-            body: hash_including({
-                messages: have_line_text_message(/Hello, world!/),
-            },
-        ))).to have_been_made.once
+  expect(a_request(:post, "https://api.line.me/v2/bot/message/reply")
+    .with(
+      body: hash_including({
+        messages: have_line_text_message(/Hello, world!/),
+      })
+    )
+  ).to have_been_made.once
 end
 ```
 
@@ -263,8 +281,8 @@ end
 | Video     | ❌            |
 | Icon      | ❌            |
 | Text      | 🚧            |
-| Span      | ❌            |
-| Separator | ❌            |
+| Span      | ✅            |
+| Separator | ✅            |
 | Filler    | ❌ Deprecated |
 
 ## Development

data/lib/line/message/builder/actions/message.rb

@@ -3,22 +3,88 @@
 module Line
   module Message
     module Builder
+      # The `Actions` module serves as a namespace for action objects that can be
+      # associated with various LINE message components, such as buttons in
+      # quick replies or imagemaps. Each class within this module represents a
+      # specific type of action a user can perform.
       module Actions
-        # The Message class is used to build message actions for quick replies.
+        # Represents a "message action" for LINE messages.
+        #
+        # A message action sends a specified text message to the chat from the user
+        # when a button associated with this action is tapped. It's commonly used
+        # in quick replies or other interactive message components.
+        #
+        # @example Creating a message action for a quick reply button
+        #   Line::Message::Builder.with do
+        #     text "Select your favorite food:"
+        #     quick_reply do
+        #       # When this button is tapped, the user sends "Pizza"
+        #       button action: :message, label: "Pizza", text: "Pizza"
+        #       # When this button is tapped, the user sends "Sushi"
+        #       button action: :message, label: "Sushi", text: "Sushi"
+        #     end
+        #   end
+        #
+        # @see https://developers.line.biz/en/reference/messaging-api/#message-action
         class Message < Line::Message::Builder::Base
+          # @!attribute [r] text
+          #   @return [String] The text that is sent as a message from the user
+          #     when the action is performed. This is a required attribute.
           attr_reader :text
 
+          # Defines an optional `label` for the action.
+          # The label is recommended by LINE for accessibility purposes, but it's
+          # not displayed in all LINE versions. For some message types like buttons,
+          # the label of the button itself is used as the action's label.
+          #
+          # @!method label(value = nil)
+          #   @param value [String, nil] The label text for the action.
+          #   @return [String, nil] The current label text.
           option :label, default: nil
 
+          # Initializes a new Message action.
+          #
+          # @param text [String] The text to be sent when the action is performed.
+          #   This is a required parameter.
+          # @param context [Object, nil] An optional context object for resolving
+          #   method calls within a block, if one is provided.
+          # @param options [Hash] A hash of options to set instance variables.
+          #   Can include `:label`.
+          # @param block [Proc, nil] An optional block to be instance-eval'd.
+          #   While available, it's not commonly used for simple actions like this.
+          # @raise [RequiredError] if `text` is nil. (This check is done in `to_h`
+          #   but `text` is conceptually required on initialization).
           def initialize(text, context: nil, **options, &)
             @text = text
 
             super(context: context, **options, &)
           end
 
+          # Converts the Message action object to a hash suitable for the LINE
+          # Messaging API.
+          #
+          # @return [Hash] A hash representing the message action.
+          #   Includes `:type`, `:label` (if set), and `:text`.
+          # @raise [RequiredError] if `text` is nil.
           def to_h
             raise RequiredError, "text is required" if text.nil?
 
+            return to_sdkv2 if context.sdkv2?
+
+            to_api
+          end
+
+          private
+
+          def to_api
+            {
+              type: "message",
+              label: label,
+              text: text
+            }.compact
+          end
+
+          def to_sdkv2
             {
               type: "message",
               label: label,

data/lib/line/message/builder/actions/postback.rb

@@ -4,22 +4,83 @@ module Line
   module Message
     module Builder
       module Actions
-        # The Postback class is used to build postback actions for quick replies.
+        # Represents a "postback action" for LINE messages.
+        #
+        # A postback action sends a postback event to your bot's webhook when a
+        # button associated with this action is tapped. The event contains the
+        # specified `data` payload. Optionally, `displayText` can be provided,
+        # which will be shown in the chat as a message from the user.
+        #
+        # This action is useful for triggering specific backend logic or flows
+        # without necessarily displaying a message in the chat, or for displaying
+        # a different message than the data payload.
+        #
+        # @example Creating a postback action for a quick reply button
+        #   Line::Message::Builder.with do
+        #     text "What do you want to do?"
+        #     quick_reply do
+        #       button action: :postback,
+        #              label: "Track Order",
+        #              data: "action=track_order&order_id=123",
+        #              display_text: "I want to track my order."
+        #     end
+        #   end
+        #
+        # @see https://developers.line.biz/en/reference/messaging-api/#postback-action
         class Postback < Line::Message::Builder::Base
+          # @!attribute [r] data
+          #   @return [String] The data payload to be sent in the postback event
+          #     to the webhook. This is a required attribute. Max 300 characters.
           attr_reader :data
 
+          # Defines an optional `label` for the action.
+          # The label is recommended by LINE for accessibility. For some message
+          # types (e.g., buttons), the button's label itself is used.
+          #
+          # @!method label(value = nil)
+          #   @param value [String, nil] The label text for the action.
+          #   @return [String, nil] The current label text.
           option :label, default: nil
+
+          # Defines an optional `displayText` for the action.
+          # This is the text that will be displayed in the chat as a message from
+          # the user when the action is performed. If not set, no message is displayed.
+          #
+          # @!method display_text(value = nil)
+          #   @param value [String, nil] The text to display in the chat. Max 300 characters.
+          #   @return [String, nil] The current display text.
           option :display_text, default: nil
 
+          # Initializes a new Postback action.
+          #
+          # @param data [String] The data to be sent in the postback event. This is required.
+          # @param context [Object, nil] An optional context object.
+          # @param options [Hash] Options for the action, including `:label` and `:display_text`.
+          # @param block [Proc, nil] An optional block for instance_eval.
+          # @raise [RequiredError] if `data` is nil. (This check is done in `to_h`
+          #   but `data` is conceptually required on initialization).
           def initialize(data, context: nil, **options, &)
             @data = data
 
             super(context: context, **options, &)
           end
 
+          # Converts the Postback action object to a hash suitable for the LINE Messaging API.
+          #
+          # @return [Hash] A hash representing the postback action.
+          #   Includes `:type`, `:label` (if set), `:data`, and `:displayText` (if set).
+          # @raise [RequiredError] if `data` is nil.
           def to_h
             raise RequiredError, "data is required" if data.nil?
 
+            return to_sdkv2 if context.sdkv2?
+
+            to_api
+          end
+
+          private
+
+          def to_api
             {
               type: "postback",
               label: label,
@@ -27,6 +88,15 @@ module Line
               displayText: display_text
             }.compact
           end
+
+          def to_sdkv2
+            {
+              type: "postback",
+              label: label,
+              data: data,
+              display_text: display_text
+            }.compact
+          end
         end
       end
     end

data/lib/line/message/builder/actions.rb

@@ -3,7 +3,24 @@
 module Line
   module Message
     module Builder
-      # The actions module contains classes for building different types of actions
+      # The `Line::Message::Builder::Actions` module serves as a central namespace
+      # for all action objects used within the LINE message builder DSL. Actions
+      # represent operations that can be triggered by users interacting with
+      # message components like buttons (in quick replies, templates, etc.) or
+      # imagemap areas.
+      #
+      # This module itself does not define specific action classes directly but
+      # acts as a container that loads them from individual files (e.g., `message.rb`,
+      # `postback.rb`). Each loaded file defines a class corresponding to a
+      # specific action type supported by the LINE Messaging API.
+      #
+      # By organizing actions under this namespace, the builder provides a clear
+      # and consistent way to create and manage different types of interactive
+      # elements in messages.
+      #
+      # @see Line::Message::Builder::Actions::Message
+      # @see Line::Message::Builder::Actions::Postback
+      # @see https://developers.line.biz/en/reference/messaging-api/#action-objects
       module Actions
         require_relative "actions/message"
         require_relative "actions/postback"

data/lib/line/message/builder/base.rb

@@ -3,21 +3,63 @@
 module Line
   module Message
     module Builder
-      # The base class to provide DSL functionality.
+      # The `Base` class serves as the foundation for all message builder classes
+      # within the `Line::Message::Builder` DSL. It provides core functionality
+      # for defining options, handling initialization, and delegating method calls
+      # to a context object.
+      #
+      # This class is not typically used directly but is inherited by specific
+      # message type builders (e.g., `Text`, `Flex`).
       class Base
         class << self
+          # @!visibility private
+          # @!parse extend ClassMethods
           def inherited(subclass)
             super
             subclass.extend ClassMethods
           end
         end
 
-        # :nodoc:
+        # The `ClassMethods` module is automatically extended by any class that
+        # inherits from {Base}. It provides class-level methods for defining
+        # DSL options and configurations.
         module ClassMethods
+          # Returns an array of option names that have been defined for this class
+          # using the {option} method.
+          #
+          # @return [Array<Symbol>] A list of defined option names.
+          # @!visibility private
           def options
             @options ||= []
           end
 
+          # Defines a new option for the builder class.
+          # This method dynamically creates an instance method on the builder class
+          # with the given `name`. When this instance method is called:
+          # - Without arguments, it returns the current value of the option, or
+          #   the `default` value if not set.
+          # - With an argument, it sets the value of the option. If a `validator`
+          #   is provided, the value is validated before being set.
+          #
+          # @param name [Symbol] The name of the option to define. This will also
+          #   be the name of the generated instance method.
+          # @param default [Object, nil] The default value for the option if not
+          #   explicitly set.
+          # @param validator [#valid!?, nil] An optional validator object that must
+          #   respond to `valid!(value)`. If the value is invalid, the validator
+          #   should raise an error (typically a {ValidationError}).
+          # @return [void]
+          # @example
+          #   class MyBuilder < Base
+          #     option :color, default: "red"
+          #     option :size, validator: SizeValidator.new
+          #   end
+          #
+          #   builder = MyBuilder.new
+          #   puts builder.color # => "red"
+          #   builder.color "blue"
+          #   puts builder.color # => "blue"
+          #   builder.size "large" # Assuming SizeValidator allows "large"
           def option(name, default: nil, validator: nil)
             options << name
 
@@ -34,8 +76,20 @@ module Line
 
         attr_reader :context
 
+        # Initializes a new instance of a builder class.
+        #
+        # @param context [Object, nil] An optional external context object.
+        #   Methods not defined in the builder will be delegated to this context
+        #   if it responds to them. This allows for using helper methods or
+        #   accessing data from the surrounding environment within the builder DSL.
+        # @param options [Hash] A hash of options to set on the builder instance.
+        #   These options are typically defined using the {ClassMethods.option .option}
+        #   method in the builder class.
+        # @param block [Proc, nil] An optional block that is instance-eval'd
+        #   within the new builder instance. This is the primary way the DSL
+        #   is used to define message content.
         def initialize(context: nil, **options, &block)
-          @context = Context.new(context)
+          @context = context
           @quick_reply = nil
 
           self.class.options.each do |option|
@@ -45,14 +99,54 @@ module Line
           instance_eval(&block) if ::Kernel.block_given?
         end
 
+        # Defines a quick reply for the message.
+        # A quick reply consists of a set of buttons that are displayed along
+        # with the message, allowing users to make quick responses.
+        #
+        # The provided block is executed in the context of a new {QuickReply}
+        # instance, where you can define the quick reply buttons.
+        #
+        # @yield [quick_reply] The block is yielded with a {QuickReply} instance.
+        # @return [QuickReply] The created {QuickReply} object.
+        # @example
+        #   text_message do
+        #     text "Please choose an option:"
+        #     quick_reply do
+        #       button action: :message, label: "Option A", text: "You chose A"
+        #       button action: :camera,  label: "Open Camera"
+        #     end
+        #   end
         def quick_reply(&)
           @quick_reply = QuickReply.new(context: context, &)
         end
 
+        # Determines if the builder can respond to a given method, including
+        # checking if the context object can respond to it.
+        # This is part of Ruby's mechanism for `method_missing` and is used
+        # here to enable delegation to the `context` object.
+        #
+        # @param method_name [Symbol] The name of the method.
+        # @param include_private [Boolean] Whether to include private methods
+        #   in the search.
+        # @return [Boolean] `true` if the builder or its context can respond to
+        #   the method, `false` otherwise.
+        # @!visibility private
         def respond_to_missing?(method_name, include_private = false)
           context.respond_to?(method_name, include_private) || super
         end
 
+        # Handles calls to undefined methods by attempting to delegate them to the
+        # `context` object. If the `context` object responds to the method,
+        # it is called. Otherwise, it behaves like the standard `method_missing`.
+        # This allows the DSL to feel more integrated with the surrounding code
+        # by making methods from the `context` directly available within the
+        # builder block.
+        #
+        # @param method_name [Symbol] The name of the missing method.
+        # @param ... [Object] Arguments passed to the method.
+        # @raise [NoMethodError] If neither the builder nor the context can
+        #   handle the method call.
+        # @!visibility private
         def method_missing(method_name, ...)
           if context.respond_to?(method_name)
             context.public_send(method_name, ...)
@@ -60,6 +154,22 @@ module Line
             super
           end
         end
+
+        def to_h
+          return to_sdkv2 if sdkv2?
+
+          to_api
+        end
+
+        private
+
+        def to_api
+          raise NotImplementedError, "#{self.class} must implement #to_api"
+        end
+
+        def to_sdkv2
+          raise NotImplementedError, "#{self.class} must implement #to_sdkv2"
+        end
       end
     end
   end