mbrao 1.2.3 → 1.3.0

data/lib/mbrao/content.rb

@@ -19,7 +19,8 @@ module Mbrao
     # 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.
+    # @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
@@ -28,7 +29,8 @@ module Mbrao
     #
     # @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.
+    # @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
@@ -36,7 +38,8 @@ module Mbrao
     # 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.
+    # @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
@@ -44,7 +47,8 @@ module Mbrao
     # 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.
+    # @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
@@ -54,7 +58,8 @@ module Mbrao
       #
       # @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.
+      # @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)
 
@@ -70,7 +75,8 @@ module Mbrao
       #
       # @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 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)
@@ -89,13 +95,17 @@ module Mbrao
   # @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.
+  #   @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.
+  #   @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.
+  #   @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.
+  #   @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
@@ -134,9 +144,10 @@ module Mbrao
 
     # 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) ? value.ensure_hash(:indifferent, nil, :ensure_string) : value.ensure_string
+    # @param new_title [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=(new_title)
+      @title = is_hash?(new_title) ? new_title.ensure_hash(:indifferent, nil, :ensure_string) : new_title.ensure_string
     end
 
     # Sets the `body` attribute.
@@ -148,33 +159,35 @@ module Mbrao
 
     # 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
-        value.ensure_hash(:indifferent) { |v| v.ensure_array(nil, true, true, true, :ensure_string) }
+    # @param new_tags [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. Tags can also be comma-separated.
+    def tags=(new_tags)
+      @tags = if is_hash?(new_tags) then
+        new_tags.ensure_hash(:indifferent) { |v| parse_tags(v) }
       else
-        value.ensure_array(nil, true, true, true, :ensure_string)
+        parse_tags(new_tags)
       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) ? value.ensure_hash(:indifferent, nil, :ensure_string) : value.ensure_string
+    # @param new_more [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=(new_more)
+      @more = is_hash?(new_more) ? new_more.ensure_hash(:indifferent, nil, :ensure_string) : new_more.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 = value.ensure_hash(:indifferent)
-        @author = Mbrao::Author.new(value["name"], value["email"], value["website"], value["image"], value["metadata"], value["uid"])
+    # @param new_author [Author|Hash|Object|NilClass] The new value for the attribute.
+    def author=(new_author)
+      if new_author.is_a?(Mbrao::Author) then
+        @author = new_author
+      elsif is_hash?(new_author) then
+        new_author = new_author.ensure_hash(:indifferent)
+        @author = Mbrao::Author.create(new_author)
       else
-        @author = Mbrao::Author.new(value.ensure_string)
+        @author = new_author ? Mbrao::Author.new(new_author.ensure_string) : nil
       end
     end
 
@@ -202,18 +215,32 @@ module Mbrao
 
     # Sets the `metadata` attribute.
     #
-    # @param value [Hash] The new value for the attribute.
-    def metadata=(value)
-      if value.is_a?(Hash) then
-        @metadata = value.ensure_hash(:indifferent)
+    # @param new_metadata [Hash] The new value for the attribute.
+    def metadata=(new_metadata)
+      if is_hash?(new_metadata) then
+        @metadata = new_metadata.ensure_hash(:indifferent)
       else
-        @metadata = HashWithIndifferentAccess.new({raw: value})
+        @metadata = HashWithIndifferentAccess.new({raw: new_metadata})
       end
     end
 
+    # Returns the content as an Hash.
+    #
+    # @param options [Hash] Options to modify behavior of the serialization.
+    #   The only supported value are:
+    #
+    #   * `:exclude`, an array of attributes to skip.
+    #   * `:exclude_empty`, if to exclude nil values. Default is `false`.
+    # @return [Hash] An hash with all attributes.
+    def as_json(options = {})
+      keys = [:uid, :locales, :title, :body, :tags, :more, :author, :created_at, :updated_at, :metadata]
+      ::Mbrao::Parser.as_json(self, keys, options)
+    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 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)
@@ -278,21 +305,43 @@ module Mbrao
       # Extracts a date and time from a value.
       #
       # @param value [String|DateTime|Fixnum] The value to parse.
-      # @return [DateTime] The extract values.
+      # @return [DateTime] The extracted value.
       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 = parse_datetime(value) if value
           value ? value.utc : nil
         rescue ArgumentError
           raise Mbrao::Exceptions::InvalidDate.new
         end
       end
+
+      # Parse a datetime
+      # @param value [String|DateTime|Fixnum] The value to parse.
+      # @return [DateTime] The extracted value.
+      def parse_datetime(value)
+        case value.class.to_s
+          when "DateTime" then value
+          when "Date", "Time" then value.to_datetime
+          when "Float", "Fixnum" then
+            value.to_float > 0 ? Time.at(value.to_float).to_datetime : nil
+          else DateTime.strptime(value.ensure_string, "%Y%m%dT%H%M%S%z")
+        end
+      end
+
+      # Extract tags from an array, making sure all the comma separated strings are evaluated.
+      #
+      # @param value [String|Array] The string or array to parse.
+      # @return [Array] The list of tags.
+      def parse_tags(value)
+        value.ensure_array(nil, true, true, true) { |v| v.ensure_string.split(/\s*,\s*/) }
+      end
+
+      # Check if value is an Hash.
+      #
+      # @param value [Object] The object to check.
+      # @return [Boolean] `true` if value is an Hash, `false` otherwise
+      def is_hash?(value)
+        value.is_a?(Hash)
+      end
   end
 end

data/lib/mbrao/integrations/rails.rb

@@ -17,6 +17,11 @@ module ActionView::Template::Handlers
       @instance ||= ActionView::Template::Handlers::MbraoTemplate.new
     end
 
+    # Register Mbrao into Rails.
+    def self.register
+      ActionView::Template.register_template_handler("emt", instance) if defined?(ActionView) && defined?(Rails) && Rails.version =~ /^[34]/
+    end
+
     # Renders a template into a renderer context.
     #
     # @param renderer [Object] The renderer context.
@@ -24,11 +29,13 @@ module ActionView::Template::Handlers
     # @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.class.send(:helper_method, :mbrao_content)
+      controller = renderer.controller
+
+      controller.instance_variable_set(:@mbrao_content, content)
+      controller.define_singleton_method(:mbrao_content) { @mbrao_content }
+      controller.class.send(:helper_method, :mbrao_content)
 
-      ::Mbrao::Parser.render(content, {engine: content.metadata[:engine], locale: renderer.controller.params[:locale]})
+      ::Mbrao::Parser.render(content, {engine: content.metadata[:engine], locale: controller.params[:locale]})
     end
 
     # Declares support for streaming.
@@ -48,4 +55,4 @@ module ActionView::Template::Handlers
   end
 end
 
-ActionView::Template.register_template_handler("emt", ActionView::Template::Handlers::MbraoTemplate.instance) if defined?(ActionView) && defined?(Rails) && Rails.version =~ /^[34]/
+ActionView::Template::Handlers::MbraoTemplate.register

data/lib/mbrao/parser.rb

@@ -63,6 +63,29 @@ module Mbrao
         instance.render(content, options, context)
       end
 
+      # Returns an object as a JSON compatible hash
+      #
+      # @param target [Object] The target to serialize.
+      # @param keys [Array] The attributes to include in the serialization
+      # @param options [Hash] Options to modify behavior of the serialization.
+      #   The only supported value are:
+      #
+      #   * `:exclude`, an array of attributes to skip.
+      #   * `:exclude_empty`, if to exclude nil values. Default is `false`.
+      # @return [Hash] An hash with all attributes.
+      def as_json(target, keys, options = {})
+        include_empty = !options[:exclude_empty].to_boolean
+        exclude = options[:exclude].ensure_array(nil, true, true, true, :ensure_string)
+        keys = keys.ensure_array(nil, true, true, true, :ensure_string)
+
+        (keys - exclude).reduce({}) {|rv, key|
+          value = target.send(key)
+          value = value.as_json if value && value.respond_to?(:as_json)
+          rv[key] = value if include_empty || !value.is_a?(NilClass)
+          rv
+        }.deep_stringify_keys
+      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.

data/lib/mbrao/parsing_engines/base.rb

@@ -11,29 +11,30 @@ module Mbrao
     class Base
       # Parses a whole post content and return its metadata and content parts.
       #
-      # @param content [Object] The content to parse.
-      # @param options [Hash] Options to customize parsing.
+      # @param _content [Object] The content to parse.
+      # @param _options [Hash] Options to customize parsing.
       # @return [Array] An array of metadata and contents parts.
-      def separate_components(content, options = {})
+      def separate_components(_content, _options = {})
         raise Mbrao::Exceptions::Unimplemented.new
       end
 
       # Parses metadata part and returns all valid metadata.
       #
-      # @param content [Object] The content to parse.
-      # @param options [Hash] Options to customize parsing.
+      # @param _content [Object] The content to parse.
+      # @param _options [Hash] Options to customize parsing.
       # @return [Hash] All valid metadata for the content.
-      def parse_metadata(content, options = {})
+      def parse_metadata(_content, _options = {})
         raise Mbrao::Exceptions::Unimplemented.new
       end
 
       # Filters content of a post by locale.
       #
-      # @param content [Content] The content to filter.
-      # @param locales [String|Array] The desired locales. Can include `*` to match all.
-      # @param options [Hash] Options to customize parsing.
-      # @return [String|HashWithIndifferentAccess] Return the filtered content in the desired locales. If only one locale is required, then a `String` is returned, else a `HashWithIndifferentAccess` with locales as keys.
-      def filter_content(content, locales = [], options = {})
+      # @param _content [Content] The content to filter.
+      # @param _locales [String|Array] The desired locales. Can include `*` to match all.
+      # @param _options [Hash] Options to customize parsing.
+      # @return [String|HashWithIndifferentAccess] Return the filtered content in the desired locales. If only one locale is required, then a `String` is
+      #   returned, else a `HashWithIndifferentAccess` with locales as keys.
+      def filter_content(_content, _locales = [], _options = {})
         raise Mbrao::Exceptions::Unimplemented.new
       end
 

data/lib/mbrao/parsing_engines/plain_text.rb

@@ -15,15 +15,15 @@ module Mbrao
       # @param options [Hash] Options to customize parsing.
       # @return [Array] An array of metadata and contents parts.
       def separate_components(content, options = {})
-        metadata = nil
-        content = content.ensure_string.strip
-        options = sanitize_options(options)
-        scanner = StringScanner.new(content)
-        end_tag = options[:meta_tags].last
-
-        if scanner.scan_until(options[:meta_tags].first) && (metadata = scanner.scan_until(end_tag)) then
-          metadata = metadata.partition(end_tag).first
-          content = scanner.rest.strip
+        metadata, content, scanner, start_tag, end_tag = prepare_for_separation(content, options)
+
+        if scanner.scan_until(start_tag) then
+          metadata = scanner.scan_until(end_tag)
+
+          if metadata then
+            metadata = metadata.partition(end_tag).first
+            content = scanner.rest.strip
+          end
         end
 
         [metadata.ensure_string.strip, content]
@@ -47,30 +47,31 @@ module Mbrao
       # @param content [Content] The content to filter.
       # @param locales [String|Array] The desired locales. Can include `*` to match all. If none are specified, the default Mbrao locale will be requested.
       # @param options [Hash] Options to customize parsing.
-      # @return [String|HashWithIndifferentAccess] Return the filtered content in the desired locales. If only one locale is required, then a `String` is returned, else a `HashWithIndifferentAccess` with locales as keys.
+      # @return [String|HashWithIndifferentAccess] Return the filtered content in the desired locales. If only one locale is required, then a `String` is
+      #   returned, else a `HashWithIndifferentAccess` with locales as keys.
       def filter_content(content, locales = [], options = {})
         body = content.body.ensure_string.strip
-        options = sanitize_options(options)
+        content_tags = sanitize_tags(options[:content_tags], ["{{content: %ARGS%}}", "{{/content}}"])
         locales = ::Mbrao::Content.validate_locales(locales, content)
 
         # Split the content
-        result = scan_content(body, options[:content_tags].first, options[:content_tags].last)
+        result = scan_content(body, content_tags.first, content_tags.last)
 
         # Now filter results
         perform_filter_content(result, locales)
       end
 
       private
-        # Sanitizes options.
+        # Prepare arguments for separation.
         #
+        # @param content [String] The content to separate.
         # @param options [Hash] The options to sanitize.
-        # @return [HashWithIndifferentAccess] The sanitized options.
-        def sanitize_options(options)
-          # Tags
-          options[:meta_tags] = sanitize_tags(options[:meta_tags], ["{{metadata}}", "{{/metadata}}"])
-          options[:content_tags] = sanitize_tags(options[:content_tags], ["{{content: %ARGS%}}", "{{/content}}"])
+        # @return [Array] The sanitized arguments.
+        def prepare_for_separation(content, options)
+          content = content.ensure_string.strip
+          meta_tags = sanitize_tags(options[:meta_tags], ["{{metadata}}", "{{/metadata}}"])
 
-          options
+          [nil, content.ensure_string.strip, StringScanner.new(content), meta_tags.first, meta_tags.last]
         end
 
         # Sanitizes tag markers.
@@ -135,12 +136,13 @@ module Mbrao
         def parse_embedded_content(scanner, start_tag, end_tag)
           rv = ""
           balance = 1
+          embedded_part = scanner.scan_until(end_tag)
 
-          while (embedded_part = scanner.scan_until(end_tag)) do
+          while balance > 0 && embedded_part do
             balance += embedded_part.scan(start_tag).count - 1 # -1 Because there is a closure
             embedded_part = embedded_part.partition(end_tag).first if balance == 0 || !scanner.exist?(end_tag) # This is the last occurrence.
             rv << embedded_part
-            break if balance == 0
+            embedded_part = scanner.scan_until(end_tag) if balance > 0
           end
 
           rv
@@ -153,10 +155,11 @@ module Mbrao
         # @return [String|nil] Return the filtered content or `nil` if the content must be hidden.
         def perform_filter_content(content, locales)
           content.map { |part|
+            part_content = part[0]
             part_locales = parse_locales(part[1])
 
             if locales_valid?(locales, part_locales) then
-              part[0].is_a?(Array) ? perform_filter_content(part[0], locales) : part[0]
+              part_content.is_a?(Array) ? perform_filter_content(part_content, locales) : part_content
             else
               nil
             end
@@ -180,7 +183,10 @@ module Mbrao
         # @param part_locales[Hash] An hash with valid and invalid locales.
         # @return [Boolean] `true` if the locales are valid, `false` otherwise.
         def locales_valid?(locales, part_locales)
-          locales.include?("*") || part_locales["valid"].include?("*") || ((part_locales["valid"].empty? || (locales & part_locales["valid"]).present?) && (locales & part_locales["invalid"]).blank?)
+          valid = part_locales["valid"]
+          invalid = part_locales["invalid"]
+
+          locales.include?("*") || valid.include?("*") || ((valid.empty? || (locales & valid).present?) && (locales & invalid).blank?)
         end
     end
   end

data/lib/mbrao/rendering_engines/base.rb

@@ -11,10 +11,10 @@ module Mbrao
     class Base
       # Renders a content.
       #
-      # @param content [Content|String] The content to parse.
-      # @param options [Hash] A list of options for renderer.
-      # @param context [Hash] A context for rendering.
-      def render(content, options = {}, context = {})
+      # @param _content [Content|String] The content to parse.
+      # @param _options [Hash] A list of options for renderer.
+      # @param _context [Hash] A context for rendering.
+      def render(_content, _options = {}, _context = {})
         raise Mbrao::Exceptions::Unimplemented.new
       end
     end

data/lib/mbrao/rendering_engines/html_pipeline.rb

@@ -36,7 +36,9 @@ module Mbrao
     # A renders which use the [html-pipeline](https://github.com/jch/html-pipeline) gem.
     #
     # @attribute default_pipeline
-    #   @return [Array] The default pipeline to use. It should be an array of pairs of `Symbol`, which the first element is the filter (in underscored version and without the filter suffix) and the second is a shortcut to disable the pipeline via options. You can also specify a single element to disable shortcuts.
+    #   @return [Array] The default pipeline to use. It should be an array of pairs of `Symbol`, which the first element is the filter (in underscored version
+    #     and without the filter suffix) and the second is a shortcut to disable the pipeline via options.
+    #     You can also specify a single element to disable shortcuts.
     # @attribute default_options
     #   @return [Hash] The default options for the renderer.
     class HtmlPipeline < Mbrao::RenderingEngines::Base
@@ -118,7 +120,10 @@ module Mbrao
         # @param context [Hash] A context for rendering.
         # @return [HTML::Pipeline] The pipeline
         def create_pipeline(options, context)
-          ::HTML::Pipeline.new(options[:pipeline].map {|f| ::Lazier.find_class(f, "::HTML::Pipeline::%CLASS%Filter", true) }, options[:pipeline_options].merge(context))
+          ::HTML::Pipeline.new(
+            options[:pipeline].map {|f| ::Lazier.find_class(f, "::HTML::Pipeline::%CLASS%Filter", true) },
+            options[:pipeline_options].merge(context)
+          )
         end
 
         # Filters pipeline filters basing on the options provided.

data/lib/mbrao/version.rb

@@ -14,10 +14,10 @@ module Mbrao
     MAJOR = 1
 
     # The minor version.
-    MINOR = 2
+    MINOR = 3
 
     # The patch version.
-    PATCH = 3
+    PATCH = 0
 
     # The current version of mbrao.
     STRING = [MAJOR, MINOR, PATCH].compact.join(".")

data/spec/mbrao/author_spec.rb

@@ -23,40 +23,56 @@ describe Mbrao::Author do
     end
 
     it "creates a author from a hash" do
-      expect(Mbrao::Author).to receive(:new).with("NAME", "EMAIL", "WEBSITE", "IMAGE", {"other" => "OTHER"}, "UID")
+      expect(Mbrao::Author).to receive(:new).with("NAME", "EMAIL", "WEBSITE", "IMAGE", {"other" => "OTHER"}).and_call_original
+      expect_any_instance_of(Mbrao::Author).to receive("uid=").with("UID")
       Mbrao::Author.create({name: "NAME", email: "EMAIL", website: "WEBSITE", image: "IMAGE", other: "OTHER", uid: "UID"})
     end
   end
 
   describe "#initialize" do
     it "create a new object" do
-      reference = Mbrao::Author.new("NAME", "name@example.com", "http://example.com", "http://example.com/image.jpg", {a: {b: :c}})
-      expect(reference.name).to eq("NAME")
-      expect(reference.email).to eq("name@example.com")
-      expect(reference.website).to eq("http://example.com")
-      expect(reference.image).to eq("http://example.com/image.jpg")
-      expect(reference.metadata).to eq({"a" => {"b" => :c}})
+      subject = Mbrao::Author.new("NAME", "name@example.com", "http://example.com", "http://example.com/image.jpg", {a: {b: :c}})
+      expect(subject.name).to eq("NAME")
+      expect(subject.email).to eq("name@example.com")
+      expect(subject.website).to eq("http://example.com")
+      expect(subject.image).to eq("http://example.com/image.jpg")
+      expect(subject.metadata).to eq({"a" => {"b" => :c}})
     end
 
     it "make sure that email is valid" do
-      reference = Mbrao::Author.new("NAME", "INVALID", "http://example.com", "http://example.com/image.jpg", {a: {b: :c}})
-      expect(reference.email).to be_nil
+      subject = Mbrao::Author.new("NAME", "INVALID", "http://example.com", "http://example.com/image.jpg", {a: {b: :c}})
+      expect(subject.email).to be_nil
     end
 
     it "make sure that website is a valid URL" do
-      reference = Mbrao::Author.new("NAME", "name@example.com", "INVALID", "http://example.com/image.jpg", {a: {b: :c}})
-      expect(reference.website).to be_nil
+      subject = Mbrao::Author.new("NAME", "name@example.com", "INVALID", "http://example.com/image.jpg", {a: {b: :c}})
+      expect(subject.website).to be_nil
     end
 
     it "make sure that image is a valid URL" do
-      reference = Mbrao::Author.new("NAME", "name@example.com", "http://example.com", "INVALID", {a: {b: :c}})
-      expect(reference.image).to be_nil
+      subject = Mbrao::Author.new("NAME", "name@example.com", "http://example.com", "INVALID", {a: {b: :c}})
+      expect(subject.image).to be_nil
     end
 
     it "make sure that hash is a recursively a HashWithIndifferentAccess" do
-      reference = Mbrao::Author.new("NAME", "name@example.com", "http://example.com", "http://example.com/image.jpg", {a: {b: :c}})
-      expect(reference.metadata).to be_a(HashWithIndifferentAccess)
-      expect(reference.metadata["a"]).to be_a(HashWithIndifferentAccess)
+      subject = Mbrao::Author.new("NAME", "name@example.com", "http://example.com", "http://example.com/image.jpg", {a: {b: :c}})
+      expect(subject.metadata).to be_a(HashWithIndifferentAccess)
+      expect(subject.metadata["a"]).to be_a(HashWithIndifferentAccess)
+    end
+  end
+
+  describe "#as_json" do
+    it "should return the content as a JSON hash" do
+      subject = Mbrao::Author.new("NAME", "name@example.com", "http://example.com", "http://example.com/image.jpg", {a: {b: :c}})
+
+      expect(subject.as_json).to eq({
+        "email" => "name@example.com",
+        "image" => "http://example.com/image.jpg",
+        "metadata" => {"a" => {"b" => :c}},
+        "name" => "NAME",
+        "uid" => nil,
+        "website" => "http://example.com"
+      })
     end
   end
 end