twilio-rails 1.0.0

data/lib/twilio/rails/models/phone_caller.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+module Twilio
+  module Rails
+    module Models
+      # The core identity object, uniquely identifying an individual by their phone number. All ingoing or outgoing
+      # phone calls or SMS messages are associated to a phone caller. A phone caller is automatically created when any
+      # phone call or SMS message is sent or received.
+      module PhoneCaller
+        extend ActiveSupport::Concern
+
+        included do
+          include Twilio::Rails::HasPhoneNumber
+
+          has_many :phone_calls, -> { order(created_at: :asc) }, class_name: Twilio::Rails.config.phone_call_class_name
+          has_many :responses, -> { order(created_at: :asc) }, through: :phone_calls, class_name: Twilio::Rails.config.response_class_name
+        end
+
+        class_methods do
+          # Finds a phone caller by phone number string or object, regardless of formatting. Returns `nil` if not found.
+          #
+          # @param phone_number_string [String, Twilio::Rails::PhoneNumber] The phone number to find the record.
+          # @return [Twilio::Rails::Models::PhoneCaller, nil] The phone caller record or `nil` if not found.
+          def for(phone_number_string)
+            phone_number = Twilio::Rails::Formatter.coerce_to_valid_phone_number(phone_number_string)
+            find_by(phone_number: phone_number) if phone_number.present?
+          end
+        end
+
+        # @return [String] A well formatted string with the city/state/country of the phone caller, if available.
+        def location
+          phone_calls.inbound.last&.location
+        end
+
+        # @return [Array<Twilio::Rails::Models::PhoneCall>] All inbound phone calls for the given phone tree or tree name.
+        def inbound_calls_for(tree)
+          tree = tree.is_a?(Twilio::Rails::Phone::Tree) ? tree.name : tree
+          phone_calls.inbound.tree(tree)
+        end
+
+        # @return [Array<Twilio::Rails::Models::PhoneCall>] All outbound phone calls for the given phone tree or tree name.
+        def outbound_calls_for(tree)
+          tree = tree.is_a?(Twilio::Rails::Phone::Tree) ? tree.name : tree
+          phone_calls.outbound.tree(tree)
+        end
+
+        # @return [Array<Twilio::Rails::Models::SmsConversation>] All SMS conversations for the phone caller.
+        def sms_conversations
+          Twilio::Rails.config.sms_conversation_class.phone_number(self.phone_number)
+        end
+
+        # Returns the digits as a `String` as entered through the keypad during a phone call as `gather:`. Returns
+        #`nil` if the response is not found, if the response has no digits, or if the response was a timeout. Can
+        # include both `*` and `#` characters if the caller pressed them.
+        #
+        # @param prompt [String, Symbol] The prompt handle to query.
+        # @param tree [String, Symbol, Twilio::Rails::Phone::Tree] The tree or name of the tree to query.
+        # @return [String, nil] The digits as entered by the caller or `nil` if not found or not present.
+        def response_digits(prompt:, tree:)
+          response = responses.tree(tree).where(prompt_handle: prompt, timeout: false).last
+          return nil unless response
+          response.digits
+        end
+
+        # Returns the digits as an `Integer` entered through the keypad during a phone call as `gather:`. Returns `nil`
+        # if the response is not found, if the response has no digits, if the response was a timeout, or if the response
+        # contains `*` or `#` characters. Useful for doing branching logic within a phone tree, such as "Press 2 for
+        # sales..." etc..
+        #
+        # @param prompt [String, Symbol] The prompt handle to query.
+        # @param tree [String, Symbol, Twilio::Rails::Phone::Tree] The tree or name of the tree to query.
+        # @return [Integer, nil] The digits as entered by the caller or `nil` if not found or not present.
+        def response_integer_digits(prompt:, tree:)
+          response = responses.tree(tree).where(prompt_handle: prompt, timeout: false).last
+          return nil unless response
+          response.integer_digits
+        end
+
+        # Checks if this phone caller has ever reached a response in a given phone tree. This is useful for building
+        # phone trees and determining if a phone caller has reached a certain point in the tree before or not.
+        #
+        # @param prompt [String, Symbol] The prompt handle to query.
+        # @param tree [String, Symbol, Twilio::Rails::Phone::Tree] The tree or name of the tree to query.
+        # @return [true, false] If the response has been reached or not.
+        def response_reached?(prompt:, tree:)
+          response_for(prompt: prompt, tree: tree).present?
+        end
+
+        # Finds the most recent {Twilio::Rails::Models::Response} for the given prompt and tree. This is useful for
+        # building phone trees and finding previous responses to prompts. Returns `nil` if no response is found.
+        #
+        # @param prompt [String, Symbol] The prompt handle to find the response for.
+        # @param tree [String, Symbol, Twilio::Rails::Phone::Tree] The tree or name of the tree in which to find the response.
+        # @return [Twilio::Rails::Models::Response, nil] The response or `nil` if not found.
+        def response_for(prompt:, tree:)
+          responses.tree(tree).where(prompt_handle: prompt).last
+        end
+      end
+    end
+  end
+end

data/lib/twilio/rails/models/recording.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module Twilio
+  module Rails
+    module Models
+      # A recording of a fragment of a phone call gathered from Twilio. See `gather: { type: :voice }` in the
+      # documentation for {Twilio::Rails::Phone::BaseTree}. Is associated to one {Twilio::Rails::Models::Response}.
+      # Attaches the audio file as an ActiveStorage attachment.
+      module Recording
+        extend ActiveSupport::Concern
+
+        included do
+          belongs_to :phone_call, class_name: Twilio::Rails.config.phone_call_class_name
+
+          has_one :response, class_name: Twilio::Rails.config.response_class_name
+          has_one_attached :audio
+
+          scope :sid, ->(sid) { where(recording_sid: sid) }
+        end
+
+        # @return [Integer, nil] The length of the recording in seconds, or nil if unavailable.
+        def length_seconds
+          duration.to_i if duration.present?
+        end
+      end
+    end
+  end
+end

data/lib/twilio/rails/models/response.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+module Twilio
+  module Rails
+    module Models
+      # A response object is created for every prompt in a phone call. It is associated to a
+      # {Twilio::Rails::Models::PhoneCall} in order, and contains transcriptions, digits, recordings, timestamps, and
+      # all other metadata.
+      module Response
+        extend ActiveSupport::Concern
+
+        included do
+          include Twilio::Rails::HasTimeScopes
+
+          validates :prompt_handle, presence: true
+
+          belongs_to :phone_call, class_name: Twilio::Rails.config.phone_call_class_name
+          belongs_to :recording, required: false, class_name: Twilio::Rails.config.recording_class_name
+
+          delegate :phone_caller, to: :phone_call
+
+          scope :completed, -> { where(timeout: false) }
+          scope :recent_transcriptions, ->(number=5) { completed.order(created_at: :desc).where.not(transcription: nil).limit(number) }
+          scope :final_timeout_check, ->(count:, prompt_handle:) {
+            prompt(prompt_handle).order(created_at: :desc).limit(count)
+          }
+          scope :tree, ->(name) { joins(:phone_call).where(phone_calls: { tree_name: name }) }
+          scope :prompt, ->(prompt_handle) { where(prompt_handle: prompt_handle) }
+          scope :in_order, -> { reorder(created_at: :asc) }
+          scope :transcribed, -> { where(transcribed: true) }
+
+          after_commit :recalculate_phone_call_length, on: :create
+        end
+
+        # Checks if the response is for a given prompt or promts, and given tree or trees or tree names.
+        #
+        # @param tree [Twilio::Rails::Phone::Tree, String, Symbol, Array] The tree or tree name or an array of them.
+        # @param prompt [String, Symbol, Array] The prompt handle or an array of them.
+        # @return [true, false] true if the response is for the given prompt and tree.
+        def is?(tree:, prompt:)
+          trees = Array(tree).map { |t| t.is_a?(Twilio::Rails::Phone::Tree) ? t.name : t.to_s }
+
+          from?(tree: tree) && Array(prompt).map(&:to_s).reject(&:blank?).include?(self.prompt_handle)
+        end
+
+        # Checks if the response is for a given tree or trees or tree names.
+        #
+        # @param tree [Twilio::Rails::Phone::Tree, String, Symbol, Array] The tree or tree name or an array of them.
+        # @return [true, false] true if the response is for the given tree.
+        def from?(tree:)
+          trees = Array(tree).map { |t| t.is_a?(Twilio::Rails::Phone::Tree) ? t.name : t.to_s }
+
+          trees.include?(self.phone_call.tree_name)
+        end
+
+        # Returns the digits as an `Integer` entered through the keypad during a phone call as `gather:`. Returns `nil`
+        # if the response has no digits, or if the response contains `*` or `#` characters. Useful for doing branching
+        # logic within a phone tree, such as "Press 2 for sales..." etc..
+        #
+        # @return [Integer, nil] The digits as entered by the caller or `nil` if not found or not present.
+        def integer_digits
+          return nil unless digits.present?
+          return nil unless digits =~ /\A[0-9]+\Z/
+          digits.to_i
+        end
+
+        # Returns true if the digits entered through the keypad during a phone call as `gather:` contain only `*` or `#`
+        #
+        # @return [true, false] true if the digits are only `*` or `#`.
+        def pound_star?
+          !!(digits =~ /\A[#*]+\Z/)
+        end
+        alias_method :star_pound?, :pound_star?
+
+        # Checks if any of the passed in patterns match the transcription. Will always return false if the
+        # transcription is blank. Patterns can be a `String`, `Symbol`, `Regexp`, or an `Array` of any of those. Will
+        # raise `ArgumentError` if no transcriptions are passed in.
+        #
+        # @param patterns [String, Symbol, Regexp, Array] The patterns to match against.
+        # @return [true, false] true if any of the patterns match the transcription.
+        def transcription_matches?(*patterns)
+          patterns = Array(patterns).flatten
+          raise ArgumentError, "transcription must match against at least one pattern" if patterns.blank?
+
+          return false if transcription.blank?
+
+          patterns.each do |pattern|
+            case pattern
+            when Regexp
+              return true if pattern.match?(transcription)
+            when String, Symbol
+              return true if transcription.downcase.include?(pattern.to_s.downcase)
+            else
+              raise ArgumentError, "can only match a String or Regexp"
+            end
+          end
+
+          false
+        end
+
+        # Returns true if the transcription matches any of the configured "yes". Will return false if the transcription
+        # is blank. See {Twilio::Rails::Configuration#yes_responses} for the default values. It is possible for
+        # {#answer_yes?} and {#answer_no?} to both be false.
+        #
+        # @return [true, false] true if the transcription matches any of the configured "yes" responses.
+        def answer_yes?
+          transcription_matches?(Twilio::Rails.config.yes_responses)
+        end
+
+        # Returns true if the transcription matches any of the configured "no". Will return false if the transcription
+        # is blank. See {Twilio::Rails::Configuration#yes_responses} for the default values. It is possible for
+        # {#answer_yes?} and {#answer_no?} to both be false.
+        #
+        # @return [true, false] true if the transcription matches any of the configured "no" responses.
+        def answer_no?
+          transcription_matches?(Twilio::Rails.config.no_responses)
+        end
+
+        # Returns true if this response is the first time the caller has encountered the given prompt for this phone
+        # call. The parameter `include_timeouts` defaults to true and flags whether or not to include responses that
+        # are timeouts. If the response is unsaved it will always return false.
+        #
+        # @param include_timeouts [true, false] Whether or not to include timeouts responses.
+        # @return [true, false] if this is the first time the caller has encountered this prompt in this phone call.
+        def first_for_phone_call?(include_timeouts: true)
+          return false unless id
+          finder = phone_call.responses.prompt(prompt_handle).order(id: :asc)
+          finder = finder.where(timeout: false) if !include_timeouts
+          finder.first&.id == id
+        end
+
+        # Returns true if this response is the first time the caller has encountered the given prompt across *any* phone
+        # call. The parameter `include_timeouts` defaults to true and flags whether or not to include responses that
+        # are timeouts. If the response is unsaved it will always return false.
+        #
+        # @param include_timeouts [true, false] Whether or not to include timeouts responses.
+        # @return [true, false] if this is the first time the caller has encountered this prompt in any phone call.
+        def first_for_phone_caller?(include_timeouts: true)
+          return false unless id
+          finder = phone_caller.responses.prompt(prompt_handle).tree(phone_call.tree_name).order(id: :asc)
+          finder = finder.where(timeout: false) if !include_timeouts
+          finder.first&.id == id
+        end
+
+        private
+
+        def recalculate_phone_call_length
+          phone_call.recalculate_length
+          true
+        end
+      end
+    end
+  end
+end

data/lib/twilio/rails/models/sms_conversation.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module Twilio
+  module Rails
+    module Models
+      # A conversation via SMS. Has many {Twilio::Rails::Models::Message}s. Each message has a direction and can be
+      # unrolled into a full conversation.
+      module SMSConversation
+        extend ActiveSupport::Concern
+
+        included do
+          has_many :messages, -> { order(created_at: :asc) }, dependent: :destroy, class_name: Twilio::Rails.config.message_class_name
+
+          scope :recent, -> { reorder(created_at: :desc).limit(10) }
+          scope :phone_number, ->(number) { where(from_number: number) }
+        end
+
+        # @return [Twilio::Rails::Models::PhoneCaller] The phone caller associated with this conversation.
+        def phone_caller
+          Twilio::Rails.config.phone_caller_class.for(from_number)
+        end
+
+        # @return [String] A well formatted string with the city/state/country of the phone number if available.
+        def location
+          Twilio::Rails::Formatter.location(city: from_city, country: from_country, province: from_province)
+        end
+      end
+    end
+  end
+end

data/lib/twilio/rails/phone/base_tree.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+module Twilio
+  module Rails
+    module Phone
+      # Base class for all phone trees which provides the DSL to define a tree. To define a phone tree start by
+      # generating a sublcass.
+      #
+      #     rails generate twilio:rails:phone_tree LeaveFeedback
+      #
+      # This will create a new class in `app/phone_trees/leave_feedback_tree.rb` which will subclass this class. It must be
+      # registered with the framework in the initializer for it to be available. The generator does this.
+      #
+      #     # config/initializers/twilio_rails.rb
+      #     config.phone_trees.register { LeaveFeedbackTree }
+      #
+      # Then define the tree using the DSL methods provided by this class. For example:
+      #
+      #     class LeaveFeedbackTree < Twilio::Rails::Phone::BaseTree
+      #       voice "Polly.Matthew-Neural"
+      #       final_timeout_message "Sorry, you don't appear to be there. Goodbye."
+      #       unanswered_call ->(phone_call) { MyMailer.send_followup(phone_call).deliver_later }
+      #       finished_call ->(phone_call) { MyMailer.send_followup(phone_call).deliver_later }
+      #       invalid_phone_number "Sorry, we can only accept calls from North America. Goodbye."
+      #
+      #       greeting message: "Hello, and thank you for calling.",
+      #         prompt: :leave_feedback
+      #
+      #       prompt :leave_feedback,
+      #         message: "Please leave your feedback after the tone, and press pound when you are finished.",
+      #         gather: {
+      #           type: :voice,
+      #           timeout: 30,
+      #           transcribe: true,
+      #         },
+      #         after: ->(response) {
+      #           if MyServiceObject.new(response.phone_caller).has_followup_message?
+      #             { prompt: :followup_message }
+      #           else
+      #             {
+      #               message: "Thank you for your feedback. Have a nice day.",
+      #               hangup: true,
+      #             }
+      #           end
+      #         }
+      #
+      #       prompt :followup_message,
+      #         message: ->(response) {
+      #           [
+      #             { play: "http://example.com/followup_message_sound.mp3" },
+      #             { say: MyServiceObject.new(response.phone_caller).followup_message_text },
+      #           ]
+      #         },
+      #         after: {
+      #           message: "Thank you. Have a nice day.",
+      #           hangup: true,
+      #         }
+      #     end
+      class BaseTree
+        class << self
+          # Accepts a string with the voice parameter to be used throughout the phone tree, unless overridden for a
+          # given message. See the Twilio documentation for a list of available voices. The voices are dependent on
+          # locale, and can also accept Amazon Polly voices. The default is "male".
+          # https://www.twilio.com/docs/voice/twiml/say/text-speech
+          #
+          # @param voice_name [String] the name of the voice to use.
+          # @return [nil]
+          def voice(voice_name)
+            tree.config[:voice] = voice_name
+            nil
+          end
+
+          # The `message:` object that is played to the caller if the phone tree is expecting input but none is
+          # received. The default number of attempts before this is called is 3, configured in `final_timeout_attempts`.
+          # The default value is a simple "Goodbye."
+          def final_timeout_message(message)
+            tree.config[:final_timeout_message] = message
+            nil
+          end
+
+          # The entrypoint and first call for any incoming or outgoing phone call. It should only be called once as
+          # there is only one greeting. Subsequent calls will overwrite the earlier ones. It accepts an optional
+          # `message:` object which will be played to the caller. See the documentation for {.prompt} for what a message
+          # can contain. It then accepts a required `prompt:` which is the next prompt in the flow of the call.
+          #
+          # @param message [String, Hash, Array, Proc] The message to play to the caller.
+          # @param prompt [Symbol, Hash, Proc] The name of the next prompt.
+          # @return [nil]
+          def greeting(message: nil, prompt:)
+            tree.greeting = Twilio::Rails::Phone::Tree::After.new(message: message, prompt: prompt)
+            nil
+          end
+
+          # Defines a prompt in the phone tree. It accepts a required `name:` which must be unique within the tree.
+          #
+          # It accepts an optional `message:` object which will be played to the caller. A message must be one of:
+          # * `nil`: No message will be played.
+          # * `String`: A string that will be read to the caller using text-to-speech. This is the equivalent of
+          #   `{ say: "a string" }`.
+          # * `Hash`: A hash that contain only the following keys:
+          #   * `{ say: "hello" }`: A string that will be read to the caller using text-to-speech. Optionally also
+          #     accepts a `voice:` key which will override the default voice for this message.
+          #   * `{ play: "https://example.com/sound.mp3" }`: A URL to a "wav" or "mp3" file that will be played to the
+          #     caller via Twilio.
+          #   * `{ pause: 1 }`: Pause in silence for the given number of seconds.
+          # * `Array`: An array that contains any number of the above.
+          # * `Proc`: A proc that will be called when the prompt is reached. The prompt will receive the previous
+          #   {Twilio::Rails::Models::Response} instance as an argument. The proc must return one of the above.
+          #
+          # It accepts an optional `gather:` object which, if present, will be used to gather input from the caller.
+          # After the optional message completes, the gather will collect the input. The gather object must be a hash
+          # with one of the following types:
+          # * `{ type: :digits }`: Collects one or more integer digits from the caller's keypad. Those digits will be
+          #   stored in the `digits` field of the {Twilio::Rails::Models::Response} instance. Digits accepts the
+          #   following configuration keys:
+          #   * `:timeout`: The number of seconds to wait for input before timing out and falling through to the
+          #     `after:`. The default is 5.
+          #   * `:number`: The number of digits to collect. The default is 1.
+          #   * `:interrupt`: Weather pressing a key will interrupt the message, or if the gather will not start
+          #     until the message is complete. The default is `false`.
+          # * `{ type: :voice }`: Records and collects the phone caller's voice as audio. The framework handles
+          #   updating the `url` and fetching the audio file as a {Twilio::Rails::Models::Recording} attached to the
+          #   response instance. However, this all happens asynchronously with no guarantee of time or success. Voice
+          #   accepts the following configuration keys:
+          #   * `:length`: The number of seconds to record. The default is 10.
+          #   * `:beep`: A boolean if the gather is preceeded by a beep. The default is `true`.
+          #   * `:transcribe`: A boolean if Twilio should attempt to transcribe the audio and send it back as text. The
+          #     framework handles this all asynchronously and will update the `transcription` field. Default is `false`.
+          #   * `:profanity_filter`: Replaces any profanity in the transcription with ***. Default is `false`.
+          # * `{ type: :speech }`: Collects speech from the caller as text using a specialzed model designed to better
+          #   identify utterances of digits, commands, conversations, etc.. This does not collect audio files, and is
+          #   more expensive, but returns the `response.transcription` in realtime which can be immediately used in
+          #   the call flow. Speech accepts the following configuration keys:
+          #   * `:language`: The language of the caller. The default is "en-US".
+          #   * `:speech_model`: The model to use for the speech recognition. Accepts "default", "numbers_and_commands",
+          #     "phone_call", "experimental_conversations", and "experimental_utterances". The default is "default".
+          #     See the Twilio documentation for details. https://www.twilio.com/docs/voice/twiml/gather#speechmodel
+          #   * `:enhanced`: A boolean if the enhanced model should be used. Results are better but the cost is higher.
+          #      The default is `false`.
+          #   * `:timeout`: The number of seconds to wait for input before timing out and falling through to the
+          #     `after:`. The default is 5.
+          #   * `:speech_timeout`: Accepts an interger or "auto". If both this and `timeout` is set, Twilio will use
+          #     `timeout` for digits and this value for voice or speech.
+          #   * `:profanity_filter`: Replaces any profanity in the transcription with ***. Default is `false`.
+          #
+          # It accepts an required `after:` object which, will be used to determine the next prompt in the call flow.
+          # The after object must be one of:
+          # * `Symbol`: The name of the next prompt in the flow.
+          # * `Hash`: A hash that contains:
+          #   * `:message`: An optional message to play before the next prompt. See the above documentation for what
+          #     a message can contain.
+          #   * `:prompt`: The name of the next prompt in the flow.
+          #   * `:hangup`: A boolean if the call should be hung up after the message. Only one of prompt and hangup can
+          #     be present.
+          # * `Proc`: A proc that will be called after the message and gather have been called. The proc will receive
+          #   the current {Twilio::Rails::Models::Response} instance as an argument. The proc must return one of the
+          #   above.
+          def prompt(prompt_name, message: nil, gather: nil, after:)
+            tree.prompts[prompt_name] = Twilio::Rails::Phone::Tree::Prompt.new(name: prompt_name, message: message, gather: gather, after: after)
+            nil
+          end
+
+          # Accepts a proc which will be called when a call goes unanswered, or is answered by an answering machine.
+          # The proc will be called asynchronously in a job. The proc will be passed the
+          # {Twilio::Rails::Models::PhoneCall} instance for the call. It is called after the call has been completed
+          # so cannot control the flow of the call. It is intended to be used as a hook to handle application logic for
+          # unanswered calls. The default is `nil` and no action is taken.
+          #
+          # @param proc [Proc] the proc to call when a call goes unanswered, must accept a phone call instance.
+          # @return [nil]
+          def unanswered_call(proc)
+            tree.unanswered_call = proc
+            nil
+          end
+
+          # Accepts a proc which will be called when a call is completed, unanswered, or any state not in progress.
+          # The proc will be called asynchronously in a job. The proc will be passed the
+          # {Twilio::Rails::Models::PhoneCall} instance for the call. It is called after the call has been completed
+          # so cannot control the flow of the call. It is intended to be used as a hook to handle application logic for
+          # when a call finishes and is no longer in progress. The default is `nil` and no action is taken.
+          #
+          # @param proc [Proc] the proc to call when a call is finished, must accept a phone call instance.
+          # @return [nil]
+          def finished_call(proc)
+            tree.finished_call = proc
+            nil
+          end
+
+          # The `message:` object that played to the caller if a call from an invalid phone number is received. The
+          # important case here is a number from outside of North America. This is currently a limitation of the
+          # framework. The default is `nil` and no action is taken. See the documentation for {.prompt} for what a
+          # message object can contain.
+          #
+          # @param message [String, Hash, Array, Proc] The message to play to the caller.
+          def invalid_phone_number(message)
+            tree.config[:invalid_phone_number] = message
+            nil
+          end
+
+          # The string name of the tree used to look it up and identify it in the registry and used in the routes. It
+          # must be unique and use URL safe characters. It defaults to the class name but can be overridden here.
+          #
+          # @return [String] the name of the tree.
+          def tree_name
+            self.name.demodulize.underscore.sub(/_tree\z/, "")
+          end
+
+          # The instance of {Twilio::Rails::Phone::Tree} built from the DSL. Should be treated as read-only. Used
+          # mostly internally by the framework. It is named according to {.tree_name}.
+          #
+          # @return [Twilio::Rails::Phone::Tree] the tree instance.
+          def tree
+            @tree ||= Twilio::Rails::Phone::Tree.new(tree_name)
+          end
+
+          # A module of convenience macros used in prompts to prevent repetition or wordy tasks. See
+          # {Twilio::Rails::Phone::TreeMacros} for the available methods. The macros do not have access to any instance
+          # information and must be passed any context they require.
+          #
+          # Additional macros can be added through the application config. See {Twilio::Rails::Configuration#include_phone_macros}.
+          #
+          # @return [Twilio::Rails::Phone::TreeMacros] the module of macros.
+          def macros
+            Twilio::Rails::Phone::TreeMacros
+          end
+        end
+      end
+    end
+  end
+end