mbrao 1.0.0

data/lib/mbrao/content.rb

@@ -0,0 +1,300 @@
+# encoding: utf-8
+#
+# This file is part of the mbrao gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module Mbrao
+  # Setter methods for the {Content Content} class.
+  module ContentPublicInterface
+    # Checks if the content is available for at least one of the provided locales.
+    #
+    # @param locales [Array] The desired locales. Can include `*` to match all. If none are specified, the default mbrao locale will be used.
+    # @return [Boolean] `true` if the content is available for at least one of the desired locales, `false` otherwise.
+    def enabled_for_locales?(*locales)
+      locales = Mbrao::Parser.sanitized_array(locales).collect(&:strip).reject {|l| l == "*" }
+      @locales.blank? || locales.blank? || (@locales & locales).present?
+    end
+
+    # Gets the title of the content in the desired locales.
+    #
+    # @param locales [String|Array] The desired locales. Can include `*` to match all. If none are specified, the default mbrao locale will be used.
+    # @return [String|HashWithIndifferentAccess] Return the title of the content in the desired locales. If only one locale is required, then a `String` is returned, else a `HashWithIndifferentAccess` with locales as keys.
+    def get_title(locales = [])
+      filter_attribute_for_locales(@title, locales)
+    end
+
+    # Gets the body returning only the portion which are available for the given locales.
+    #
+    # @param locales [String|Array] The desired locales. Can include `*` to match all. If none are specified, the default mbrao locale will be used.
+    # @param engine [String|Symbol|Object] The engine to use to filter contents.
+    # @return [String|HashWithIndifferentAccess] Return the body of the content in the desired locales. If only one locale is required, then a `String` is returned, else a `HashWithIndifferentAccess` with locales as keys.
+    def get_body(locales = [], engine = :plain_text)
+      Mbrao::Parser.create_engine(engine).filter_content(self, locales)
+    end
+
+    # Gets the tags of the content in the desired locales.
+    #
+    # @param locales [String|Array] The desired locales. Can include `*` to match all. If none are specified, the default mbrao locale will be used.
+    # @return [Array|HashWithIndifferentAccess] Return the title of the content in the desired locales. If only one locale is required, then a `Array` is returned, else a `HashWithIndifferentAccess` with locales as keys.
+    def get_tags(locales = [])
+      filter_attribute_for_locales(@tags, locales)
+    end
+
+    # Gets the "more link" text of the content in the desired locales.
+    #
+    # @param locales [String|Array] The desired locales. Can include `*` to match all. If none are specified, the default mbrao locale will be used.
+    # @return [String|HashWithIndifferentAccess] Return the label of the "more link" of the content in the desired locales. If only one locale is required, then a `String` is returned, else a `HashWithIndifferentAccess` with locales as keys.
+    def get_more(locales = [])
+      filter_attribute_for_locales(@more, locales)
+    end
+
+    private
+      # Filters an attribute basing a set of locales.
+      #
+      # @param attribute [Object|HashWithIndifferentAccess] The desired attribute.
+      # @param locales [String|Array] The desired locales. Can include `*` to match all. If none are specified, the default mbrao locale will be used.
+      # @return [String|HashWithIndifferentAccess] Return the object for desired locales. If only one locale is available, then only a object is returned, else a `HashWithIndifferentAccess` with locales as keys.
+      def filter_attribute_for_locales(attribute, locales)
+        locales = ::Mbrao::Content.validate_locales(locales, self)
+
+        if attribute.is_a?(HashWithIndifferentAccess) then
+          rv = attribute.inject(HashWithIndifferentAccess.new) { |hash, pair| append_value_for_locale(hash, pair[0], locales, pair[1]) }
+          rv.keys.length == 1 ? rv.values.first : rv
+        else
+          attribute
+        end
+      end
+
+      # Adds an value on a hash if enable for requested locales.
+      #
+      # @param hash [Hash] The hash to handle.
+      # @param locale [String] The list of locale (separated by commas) for which the value is available.
+      # @param locales [Array] The list of locale for which this value is requested. Can include `*` to match all. If none are specified, the default mbrao locale will be used.
+      # @param value [Object] The value to add.
+      # @return [Hash] Return the original hash.
+      def append_value_for_locale(hash, locale, locales, value)
+        locale.split(/\s*,\s*/).collect(&:strip).each do |l|
+          hash[l] = value if locales.include?("*") || locales.include?(l)
+        end
+
+        hash
+      end
+  end
+
+  # Represents a parsed content, with its metadata.
+  #
+  # @attribute uid
+  #   @return [String] A unique ID for this post. This is only for client uses.
+  # @attribute locales
+  #   @return [Array] A list of locales for this content should be visible. An empty list means that there are no limitations.
+  # @attribute title
+  #   @return [String|HashWithIndifferentAccess] The content's title. Can be a `String` or an `HashWithIndifferentAccess`, if multiple title are specified for multiple locales.
+  # @attribute body
+  #   @return [String|HashWithIndifferentAccess] The content's body. Can be a `String` or an `HashWithIndifferentAccess`, if multiple contents are specified for multiple locales.
+  # @attribute tags
+  #   @return [String|HashWithIndifferentAccess] The content's "more link" label. Can be a `String` or an `HashWithIndifferentAccess`, if multiple labels are specified for multiple locales.
+  # @attribute tags
+  #   @return [Array|HashWithIndifferentAccess] The tags associated with the content. Can be an `Array` or an `HashWithIndifferentAccess`, if multiple tags set are specified for multiple locales.
+  # @attribute author
+  #   @return [Author] The post author.
+  # @attribute created_at
+  #   @return [DateTime] The post creation date and time. The timezone is always UTC.
+  # @attribute updated_at
+  #   @return [DateTime] The post creation date and time. Defaults to the creation date. The timezone is always UTC.
+  # @attribute metadata
+  #   @return [Hash] The full list of metadata of this content.
+  class Content
+    include Mbrao::ContentPublicInterface
+
+    attr_accessor :uid
+    attr_accessor :locales
+    attr_accessor :title
+    attr_accessor :body
+    attr_accessor :tags
+    attr_accessor :more
+    attr_accessor :author
+    attr_accessor :created_at
+    attr_accessor :updated_at
+    attr_accessor :metadata
+
+    # Creates a new content.
+    #
+    # @param uid [String] The UID for this content.
+    def initialize(uid = nil)
+      @uid = uid
+    end
+
+    # Sets the `locales` attribute.
+    #
+    # @param value [Array] The new value for the attribute. If an Hash, keys must be a string with one or locale separated by commas. A empty or "*" will be the default value.
+    def locales=(value)
+      @locales = Mbrao::Parser.sanitized_array(value)
+    end
+
+    # Sets the `title` attribute.
+    #
+    # @param value [String|Hash] The new value for the attribute. If an Hash, keys must be a string with one or locale separated by commas. A empty or "*" will be the default value.
+    def title=(value)
+      @title = value.is_a?(Hash) ? Mbrao::Parser.sanitized_hash(value, :ensure_string) : value.ensure_string
+    end
+
+    # Sets the `body` attribute.
+    #
+    # @param value [String] The new value for the attribute. Can contain locales restriction (like !en), which will must be interpreted using #get_body.
+    def body=(value)
+      @body = value.ensure_string
+    end
+
+    # Sets the `tags` attribute.
+    #
+    # @param value [Array|Hash] The new value for the attribute. If an Hash, keys must be a string with one or locale separated by commas. A empty or "*" will be the default value.
+    def tags=(value)
+      @tags = if value.is_a?(Hash) then
+        values = Mbrao::Parser.sanitized_hash(value)
+        values.each {|k, v| values[k] = Mbrao::Parser.sanitized_array(v, true, true) }
+        @tags = values
+      else
+        Mbrao::Parser.sanitized_array(value, true, true)
+      end
+    end
+
+    # Sets the `more` attribute.
+    #
+    # @param value [String|Hash] The new value for the attribute. If an Hash, keys must be a string with one or locale separated by commas. A empty or "*" will be the default value.
+    def more=(value)
+      @more = value.is_a?(Hash) ? Mbrao::Parser.sanitized_hash(value, :ensure_string) : value.ensure_string
+    end
+
+    # Sets the `author` attribute.
+    #
+    # @param value [Author|Hash|Object] The new value for the attribute.
+    def author=(value)
+      if value.is_a?(Mbrao::Author) then
+        @author = value
+      elsif value.is_a?(Hash) then
+        value = Mbrao::Parser.sanitized_hash(value, nil)
+        @author = Mbrao::Author.new(value["name"], value["email"], value["website"], value["image"], value["metadata"], value["uid"])
+      else
+        @author = Mbrao::Author.new(value.ensure_string)
+      end
+    end
+
+    # Sets the `created_at` attribute.
+    #
+    # @param value [String|DateTime|Fixnum] The new value for the attribute.
+    def created_at=(value)
+      @created_at = extract_datetime(value)
+    end
+
+    # Sets the `updated_at` attribute.
+    #
+    # @param value [String|DateTime|Fixnum] The new value for the attribute.
+    def updated_at=(value)
+      @updated_at = extract_datetime(value)
+      @updated_at = @created_at if !@updated_at
+    end
+
+    # Gets metadata attribute.
+    #
+    # @return The metadata attribute.
+    def metadata
+      @metadata || {}
+    end
+
+    # Sets the `metadata` attribute.
+    #
+    # @param value [Hash] The new value for the attribute.
+    def metadata=(value)
+      if value.is_a?(Hash) then
+        @metadata = Mbrao::Parser.sanitized_hash(value)
+      else
+        @metadata = HashWithIndifferentAccess.new({raw: value})
+      end
+    end
+
+    # Validates locales for attribute retrieval.
+    #
+    # @param locales [Array] A list of desired locales for an attribute. Can include `*` to match all. If none are specified, the default mbrao locale will be used.
+    # @param content [Content|nil] An optional content to check for availability
+    # @return [Array] The validated list of locales.
+    def self.validate_locales(locales, content = nil)
+      locales = Mbrao::Parser.sanitized_array(locales).collect(&:strip)
+      locales = (locales.empty? ? [Mbrao::Parser.locale] : locales)
+      raise Mbrao::Exceptions::UnavailableLocalization.new if content && !content.enabled_for_locales?(locales)
+      locales
+    end
+
+    # Creates a content with metadata and body.
+    #
+    # @param metadata [Hash] The metadata.
+    # @param body [String] The body of the content.
+    # @return [Content] A new content.
+    def self.create(metadata, body)
+      rv = Mbrao::Content.new
+      rv.body = body.ensure_string.strip
+      assign_metadata(rv, metadata) if metadata.is_a?(Hash)
+      rv
+    end
+
+    private
+      # Assigns metadata to a content
+      #
+      # @param content [Content] The content to manipulate.
+      # @param metadata [Hash] The metadata to assign.
+      # @return [Content] The content with metadata.
+      def self.assign_metadata(content, metadata)
+        metadata = metadata.symbolize_keys!
+
+        content.uid = metadata.delete(:uid)
+        content.title = metadata.delete(:title)
+        content.author = Mbrao::Author.create(metadata.delete(:author))
+        content.tags = metadata.delete(:tags)
+        content.more = metadata.delete(:more)
+        content.created_at = metadata.delete(:created_at)
+        content.updated_at = metadata.delete(:updated_at)
+        content.locales = extract_locales(metadata)
+        content.metadata = metadata
+
+        content
+      end
+
+      # Extract locales from metadata.
+      #
+      # @param metadata [Hash] The metadata that contains the locales.
+      # @return [Array] The locales.
+      def self.extract_locales(metadata)
+        locales = metadata.delete(:locales)
+        locales = locales.ensure_string.split(/\s*,\s*/) if !locales.is_a?(::Array)
+        normalize_locales(locales)
+      end
+
+      # Normalize locales for further usage.
+      #
+      # @param locales [Array] The locales to normalize.
+      # @return [Array] The normalized locales.
+      def self.normalize_locales(locales)
+        locales.flatten.collect(&:ensure_string).collect(&:strip).uniq
+      end
+
+      # Extracts a date and time from a value.
+      #
+      # @param value [String|DateTime|Fixnum] The value to parse.
+      # @return [DateTime] The extract values.
+      def extract_datetime(value)
+        begin
+          if value.is_a?(Date) || value.is_a?(Time) then
+            value = value.to_datetime
+          elsif value.to_float > 0 then
+            value = Time.at(value.to_float).to_datetime
+          elsif value && !value.is_a?(DateTime) then
+            value = DateTime.strptime(value.ensure_string, "%Y%m%dT%H%M%S%z")
+          end
+
+          value ? value.utc : nil
+        rescue ArgumentError => _
+          raise Mbrao::Exceptions::InvalidDate.new
+        end
+      end
+  end
+end

data/lib/mbrao/exceptions.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+#
+# This file is part of the mbrao gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+module Mbrao
+  # The exceptions raised by mbrao.
+  module Exceptions
+    # Exception raised when metadata are not valid.
+    class InvalidMetadata < ::Exception
+    end
+
+    # Exception raised when a date is valid.
+    class InvalidDate < ::Exception
+    end
+
+    # Exception raised when there is a parsing error.
+    class Parsing < ::Exception
+    end
+
+    # Exception raised when there is a rendering error.
+    class Rendering < ::Exception
+    end
+
+    # Exception raised when a requested object is not available in any of the desired locales.
+    class UnavailableLocalization < ::Exception
+    end
+
+    # Exception raised when a invalid parsing or rendering engine is requested.
+    class UnknownEngine < ::Exception
+    end
+
+    # Exception raised when a requested method must be overridden by a subclass.
+    class Unimplemented < ::Exception
+    end
+  end
+end

data/lib/mbrao/integrations/rails.rb

@@ -0,0 +1,51 @@
+# encoding: utf-8
+#
+# This file is part of the mbrao gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+# Generic interface to multiple Ruby template engines.
+module ActionView::Template::Handlers
+  # Class for rendering mbrao contents in Rails.
+  class MbraoTemplate
+    # Returns a unique (singleton) instance of the template handler.
+    #
+    # @param force [Boolean] If to force recreation of the instance.
+    # @return [MbraoTemplate] The unique (singleton) instance of the template handler.
+    def self.instance(force = false)
+      @instance = nil if force
+      @instance ||= ActionView::Template::Handlers::MbraoTemplate.new
+    end
+
+    # Renders a template into a renderer context.
+    #
+    # @param renderer [Object] The renderer context.
+    # @param template [String] The template to render.
+    # @return [String] The rendered template.
+    def render(renderer, template)
+      content = ::Mbrao::Parser.parse(template)
+      renderer.controller.instance_variable_set(:@mbrao_content, content)
+      renderer.controller.define_singleton_method(:mbrao_content) { @mbrao_content }
+      renderer.controller.send(:helper_method, :mbrao_content)
+
+      ::Mbrao::Parser.render(content, {engine: content.metadata[:engine], locale: renderer.controller.params[:locale]})
+    end
+
+    # Declares support for streaming.
+    #
+    # @return [TrueClass] Declares support for streaming.
+    def supports_streaming?
+      true
+    end
+
+    # Method called to render a template.
+    #
+    # @param template [ActionView::Template] The template to render.
+    # @return [String] A Ruby snippet to execute to render the template.
+    def call(template)
+      "ActionView::Template::Handlers::MbraoTemplate.instance.render(self, #{template.source.to_json})"
+    end
+  end
+end
+
+ActionView::Template.register_template_handler "emt", ActionView::Template::Handlers::MbraoTemplate.instance if defined?(ActionView) && defined?(Rails) && Rails.version =~ /^[34]/

data/lib/mbrao/parser.rb

@@ -0,0 +1,276 @@
+# encoding: utf-8
+#
+# This file is part of the mbrao gem. Copyright (C) 2013 and above Shogun <shogun_panda@me.com>.
+# Licensed under the MIT license, which can be found at http://www.opensource.org/licenses/mit-license.php.
+#
+
+# A content parser and renderer with embedded metadata support.
+module Mbrao
+  # Methods to allow class level access.
+  module PublicInterface
+    extend ActiveSupport::Concern
+
+    # Class methods.
+    #
+    # @attribute default_locale
+    #   @return [String] The mbrao default locale.
+    # @attribute parsing_engine
+    #   @return [String] The default parsing engine.
+    # @attribute rendering_engine
+    #   @return [String] The default rendering engine.
+    module ClassMethods
+      attr_accessor :locale
+      attr_accessor :parsing_engine
+      attr_accessor :rendering_engine
+
+      # Gets the default locale for mbrao.
+      #
+      # @return [String] The default locale.
+      def locale
+        attribute_or_default(@locale, "en")
+      end
+
+      # Gets the default parsing engine.
+      #
+      # @return [String] The default parsing engine.
+      def parsing_engine
+        attribute_or_default(@parsing_engine, :plain_text, :to_sym)
+      end
+
+      # Gets the default rendering engine.
+      #
+      # @return [String] The default rendering engine.
+      def rendering_engine
+        attribute_or_default(@rendering_engine, :html_pipeline, :to_sym)
+      end
+
+      # Parses a source text.
+      #
+      # @param content [Object] The content to parse.
+      # @param options [Hash] A list of options for parsing.
+      # @return [Content] The parsed data.
+      def parse(content, options = {})
+        self.instance.parse(content, options)
+      end
+
+      # Renders a content.
+      #
+      # @param content [Content] The content to parse.
+      # @param options [Hash] A list of options for renderer.
+      # @param context [Hash] A context for rendering.
+      # @return [String] The rendered content.
+      def render(content, options = {}, context = {})
+        self.instance.render(content, options, context)
+      end
+
+      # Instantiates a new engine for rendering or parsing.
+      #
+      # @param cls [String|Symbol|Object] If a `String` or a `Symbol`, then it will be the class of the engine.
+      # @param type [Symbol] The type or engine. Can be `:parsing` or `:rendering`.
+      # @return [Object] A new engine.
+      def create_engine(cls, type = :parsing)
+        begin
+          type = :parsing if type != :rendering
+          ::Mbrao::Parser.find_class(cls, "::Mbrao::#{type.to_s.classify}Engines::%CLASS%").new
+        rescue Mbrao::Exceptions::Unimplemented
+          raise Mbrao::Exceptions::UnknownEngine.new
+        end
+      end
+
+      # Finds a class to instantiate.
+      #
+      # @param cls [Symbol|String|Object] If a `String` or a `Symbol`, then it will be the class to instantiate. Otherwise the class of the object will returned.
+      # @param scope [String] An additional scope to find the class. `%CLASS%` will be substituted with the class name.
+      # @param only_in_scope [Boolean] If only try to instantiate the class in the scope.
+      # @return [Class] The found class.
+      def find_class(cls, scope = "::%CLASS%", only_in_scope = false)
+        if cls.is_a?(String) || cls.is_a?(Symbol) then
+          rv = nil
+
+          cls = cls.to_s.camelize
+          if only_in_scope then
+            cls.gsub!(/^::/, "")
+          else
+            rv = (cls.constantize rescue nil)
+          end
+
+          rv = (scope.ensure_string.gsub("%CLASS%", cls).constantize rescue nil) if !rv && cls !~ /^::/ && scope.present?
+          rv || raise(Mbrao::Exceptions::Unimplemented.new(cls))
+        else
+          cls.class
+        end
+      end
+
+      # Returns a unique (singleton) instance of the parser.
+      #
+      # @param force [Boolean] If to force recreation of the instance.
+      # @return [Parser] The unique (singleton) instance of the parser.
+      def instance(force = false)
+        @instance = nil if force
+        @instance ||= Mbrao::Parser.new
+      end
+
+      private
+        # Returns an attribute or a default value.
+        #
+        # @param attr [Object ]The attribute to return.
+        # @param default_value [Object] The value to return if `attr` is blank.
+        # @param sanitizer [Symbol] An optional method to sanitize the returned value.
+        def attribute_or_default(attr, default_value = nil, sanitizer = :ensure_string)
+          rv = attr.present? ? attr : default_value
+          rv = rv.send(sanitizer) if sanitizer
+          rv
+        end
+    end
+  end
+
+  # Methods to perform validations.
+  module Validations
+    extend ActiveSupport::Concern
+
+    # Class methods.
+    module ClassMethods
+      # Checks if the text is a valid email.
+      #
+      # @param text [String] The text to check.
+      # @return [Boolean] `true` if the string is valid email, `false` otherwise.
+      def is_email?(text)
+        regex = /^([a-z0-9_\.\-\+]+)@([\da-z\.\-]+)\.([a-z\.]{2,6})$/i
+        text.ensure_string.strip =~ regex
+      end
+
+      # Checks if the text is a valid URL.
+      #
+      # @param text [String] The text to check.
+      # @return [Boolean] `true` if the string is valid URL, `false` otherwise.
+      def is_url?(text)
+        regex = /
+          ^(
+            ([a-z0-9\-]+:\/\/) #PROTOCOL
+            (([\w-]+\.)?) # LOWEST TLD
+            ([\w-]+) # 2nd LEVEL TLD
+            (\.[a-z]+) # TOP TLD
+            ((:\d+)?) # PORT
+            ([\S|\?]*) # PATH, QUERYSTRING AND FRAGMENT
+          )$
+        /ix
+
+        text.ensure_string.strip =~ regex
+      end
+
+      # Converts an object making sure that every `Hash` is converted to a `HashWithIndifferentAccess`.
+      #
+      # @param object [Object] The object to convert. If the object is not an Hash or doesn't respond to `collect` then the original object is returned.
+      # @param sanitize_method [Symbol|nil] If not `nil`, the method to use to sanitize entries. Ignored if a block is present.
+      # @param block [Proc] A block to sanitize entries. It must accept the value as unique argument.
+      # @return [Object] The converted object.
+      def sanitized_hash(object, sanitize_method = nil, &block)
+        if object.is_a?(Hash) || object.is_a?(HashWithIndifferentAccess) then
+          object.inject(HashWithIndifferentAccess.new) do |hash, pair|
+            hash[pair[0]] = Mbrao::Parser.sanitized_hash(pair[1], sanitize_method, &block)
+            hash
+          end
+        elsif object.respond_to?(:collect) then
+          object.collect {|item| Mbrao::Parser.sanitized_hash(item, sanitize_method, &block) }
+        else
+          sanitized_hash_entry(object, sanitize_method, &block)
+        end
+      end
+
+      # Converts an object to a a flatten array with all values sanitized.
+      #
+      # @param object [Object] The object to convert.
+      # @param uniq [Boolean] If to remove duplicates from the array before sanitizing.
+      # @param compact [Boolean] If to compact the array before sanitizing.
+      # @param sanitize_method [Symbol|nil] If not `nil`, the method to use to sanitize entries. Ignored if a block is present.
+      # @param block [Proc] A block to sanitize entries. It must accept the value as unique argument.
+      # @return [Array] An flattened array whose all values are strings.
+      def sanitized_array(object, uniq = true, compact = false, sanitize_method = :ensure_string, &block)
+        rv = object.ensure_array.flatten
+        rv.uniq! if uniq
+        rv.compact! if compact
+
+        if block then
+          rv = rv.collect(&block)
+        elsif sanitize_method then
+          rv = rv.collect(&sanitize_method)
+        end
+
+        rv.uniq! if uniq
+        rv.compact! if compact
+        rv
+      end
+
+      private
+        # Sanitizes an value for an hash.
+        #
+        # @param value [Object] The value to sanitize.
+        # @param sanitize_method [Symbol|nil] If not `nil`, the method to use to sanitize the value. Ignored if a block is present.
+        # @param block [Proc] A block to sanitize the value. It must accept the value as unique argument.
+        def sanitized_hash_entry(value, sanitize_method = :ensure_string, &block)
+          if block
+            block.call(value)
+          elsif sanitize_method
+            value.send(sanitize_method)
+          else
+            value
+          end
+        end
+    end
+  end
+
+  # A parser to handle pipelined content.
+  #
+  class Parser
+    include Mbrao::PublicInterface
+    include Mbrao::Validations
+
+    # Parses a source text.
+    #
+    # @param content [Object] The content to parse.
+    # @param options [Hash] A list of options for parsing.
+    # @return [Content] The parsed data.
+    def parse(content, options = {})
+      options = sanitize_parsing_options(options)
+      ::Mbrao::Parser.create_engine(options[:engine]).parse(content, options)
+    end
+
+    # Renders a content.
+    #
+    # @param content [Content] The content to parse.
+    # @param options [Hash] A list of options for renderer.
+    # @param context [Hash] A context for rendering.
+    # @return [String] The rendered content.
+    def render(content, options = {}, context = {})
+      options = sanitize_rendering_options(options)
+      ::Mbrao::Parser.create_engine(options[:engine], :rendering).render(content, options, context)
+    end
+
+    private
+      # Sanitizes options for parsing.
+      #
+      # @param options [Hash] The options to sanitize.
+      # @return [HashWithIndifferentAccess] The sanitized options.
+      def sanitize_parsing_options(options)
+        options = (options.is_a?(Hash) ? options : {}).symbolize_keys
+
+        options[:engine] ||= Mbrao::Parser.parsing_engine
+        options[:metadata] = options.fetch(:metadata, true).to_boolean
+        options[:content] = options.fetch(:content, true).to_boolean
+
+        HashWithIndifferentAccess.new(options)
+      end
+
+      # Sanitizes options for rendering.
+      #
+      # @param options [Hash] The options to sanitize.
+      # @return [HashWithIndifferentAccess] The sanitized options.
+      def sanitize_rendering_options(options)
+        options = (options.is_a?(Hash) ? options : {}).symbolize_keys
+
+        options[:engine] ||= Mbrao::Parser.rendering_engine
+
+        HashWithIndifferentAccess.new(options)
+      end
+  end
+end