front_matter_parser 0.0.4 → 1.0.0

data/lib/front_matter_parser/loader.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'front_matter_parser/loader/yaml'
+
+module FrontMatterParser
+  # This module includes front matter loaders (from a string -usually extracted
+  # with a {SyntaxParser}- to hash). They must respond to a `::call` method
+  # which accepts the String as argument and respond with a Hash.
+  module Loader
+  end
+end

data/lib/front_matter_parser/loader/yaml.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module FrontMatterParser
+  module Loader
+    # {Loader} that uses YAML library
+    class Yaml
+      # @!attribute [r] allowlist_classes
+      # Classes that may be parsed by #call.
+      attr_reader :allowlist_classes
+
+      def initialize(allowlist_classes: [])
+        @allowlist_classes = allowlist_classes
+      end
+
+      # Loads a hash front matter from a string
+      #
+      # @param string [String] front matter string representation
+      # @return [Hash] front matter hash representation
+      def call(string)
+        YAML.safe_load(string, allowlist_classes)
+      end
+    end
+  end
+end

data/lib/front_matter_parser/parsed.rb

@@ -1,18 +1,29 @@
-# Parsed is the result of calling {FrontMatterParser.parse} or {FrontMatterParser.parse_file} in {FrontMatterParser}. It keeps the front matter and the content parsed and it has some useful methods to work with them.
-class FrontMatterParser::Parsed
-  # @!attribute [rw] front_matter
-  #   @return [Hash{String => String, Array, Hash}] the parsed front matter
-  # @!attribute [rw] content
-  #   @return [String] the parsed content
-  attr_accessor :front_matter, :content
+# frozen_string_literal: true
 
-  alias_method :to_hash, :front_matter
+module FrontMatterParser
+  # Result of parsing front matter and content from a string
+  class Parsed
+    # @!attribute [rw] front_matter
+    # @see #initialize
+    attr_reader :front_matter
 
-  # Returns the front matter value for the given key
-  #
-  # @param key [String] The key of the front matter
-  # @return [String, Array, Hash] The value of the front matter for the given key
-  def [](key)
-    @front_matter[key]
+    # @!attribute [rw] content
+    # @see #initialize
+    attr_reader :content
+
+    # @param front_matter [Hash] parsed front_matter
+    # @param content [String] parsed content
+    def initialize(front_matter:, content:)
+      @front_matter = front_matter
+      @content = content
+    end
+
+    # Returns front matter value for given key
+    #
+    # @param key [String] key for desired value
+    # @return [String, Array, # Hash] desired value
+    def [](key)
+      front_matter[key]
+    end
   end
 end

data/lib/front_matter_parser/parser.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module FrontMatterParser
+  # Entry point to parse a front matter from a string or file.
+  class Parser
+    # @!attribute [r] syntax_parser
+    # Current syntax parser in use. See {SyntaxParser}
+    attr_reader :syntax_parser
+
+    # @!attribute [r] loader
+    # Current loader in use. See {Loader} for details
+    attr_reader :loader
+
+    # Parses front matter and content from given pathname, inferring syntax from
+    # the extension or, otherwise, using syntax_parser argument.
+    #
+    # @param pathname [String]
+    # @param syntax_parser [Object] see {SyntaxParser}
+    # @param loader [Object] see {Loader}
+    # @return [Parsed] parsed front matter and content
+    def self.parse_file(pathname, syntax_parser: nil, loader: nil)
+      syntax_parser ||= syntax_from_pathname(pathname)
+      loader ||= Loader::Yaml.new
+      File.open(pathname) do |file|
+        new(syntax_parser, loader: loader).call(file.read)
+      end
+    end
+
+    # @!visibility private
+    def self.syntax_from_pathname(pathname)
+      File.extname(pathname)[1..-1].to_sym
+    end
+
+    # @!visibility private
+    def self.syntax_parser_from_symbol(syntax)
+      Kernel.const_get(
+        "FrontMatterParser::SyntaxParser::#{syntax.capitalize}"
+      ).new
+    end
+
+    # @param syntax_parser [Object] Syntax parser to use. It can be one of two
+    #   things:
+    #
+    #   - An actual object which acts like a parser. See {SyntaxParser} for
+    #   details.
+    #
+    #   - A symbol, in which case it refers to a parser
+    #   `FrontMatterParser::SyntaxParser::#{symbol.capitalize}` which can be
+    #   initialized without arguments
+    #
+    # @param loader [Object] Front matter loader to use. See {Loader} for
+    # details.
+    def initialize(syntax_parser, loader: Loader::Yaml.new)
+      @syntax_parser = infer_syntax_parser(syntax_parser)
+      @loader = loader
+    end
+
+    # Parses front matter and content from given string
+    #
+    # @param string [String]
+    # @return [Parsed] parsed front matter and content
+    # :reek:FeatureEnvy
+    def call(string)
+      match = syntax_parser.call(string)
+      front_matter, content =
+        if match
+          [loader.call(match[:front_matter]), match[:content]]
+        else
+          [{}, string]
+        end
+      Parsed.new(front_matter: front_matter, content: content)
+    end
+
+    private
+
+    def infer_syntax_parser(syntax_parser)
+      return syntax_parser unless syntax_parser.is_a?(Symbol)
+
+      self.class.syntax_parser_from_symbol(syntax_parser)
+    end
+  end
+end

data/lib/front_matter_parser/syntax_parser.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'front_matter_parser/syntax_parser/factorizable'
+require 'front_matter_parser/syntax_parser/multi_line_comment'
+require 'front_matter_parser/syntax_parser/indentation_comment'
+require 'front_matter_parser/syntax_parser/single_line_comment'
+
+module FrontMatterParser
+  # This module includes parsers for different syntaxes.  They respond to
+  # a method `#call`, which takes a string as argument and responds with
+  # a hash interface with `:front_matter` and `:content` keys, or `nil` if no
+  # front matter is found.
+  #
+  # :reek:TooManyConstants
+  module SyntaxParser
+    Coffee = SingleLineComment['#']
+    Sass = SingleLineComment['//']
+    Scss = SingleLineComment['//']
+
+    Html = MultiLineComment['<!--', '-->']
+    Erb = MultiLineComment['<%#', '%>']
+    Liquid = MultiLineComment['{% comment %}', '{% endcomment %}']
+    Md = MultiLineComment['', '']
+
+    Slim = IndentationComment['/']
+    Haml = IndentationComment['-#']
+  end
+end

data/lib/front_matter_parser/syntax_parser/factorizable.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module FrontMatterParser
+  module SyntaxParser
+    # This is just a helper to allow creating syntax parsers with a more terse
+    # syntax, without the need of explicitly creating descendant classes for the
+    # most general cases. See {SyntaxParser} for examples in use.
+    module Factorizable
+      # @param delimiters [String] Splat arguments with all comment delimiters
+      # used by the parser
+      #
+      # @return [Object] A base class of self with a `delimiters` class method
+      # added which returns an array with given comment delimiters
+      def [](*delimiters)
+        delimiters = delimiters.map { |delimiter| Regexp.escape(delimiter) }
+        create_base_class(delimiters)
+      end
+
+      private
+
+      def create_base_class(delimiters)
+        parser = Class.new(self)
+        parser.define_singleton_method(:delimiters) do
+          delimiters
+        end
+        parser
+      end
+    end
+  end
+end

data/lib/front_matter_parser/syntax_parser/indentation_comment.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module FrontMatterParser
+  module SyntaxParser
+    # Parser for syntaxes which use comments ended by indentation
+    class IndentationComment
+      extend Factorizable
+
+      # @!attribute [r] regexp
+      # A regexp that returns two groups: front_matter and content
+      attr_reader :regexp
+
+      def initialize
+        @regexp = build_regexp(*self.class.delimiters)
+      end
+
+      # @see SyntaxParser
+      def call(string)
+        string.match(regexp)
+      end
+
+      # @see Factorizable
+      # :nocov:
+      def self.delimiters
+        raise NotImplementedError
+      end
+
+      private
+
+      # rubocop:disable Metrics/MethodLength
+      def build_regexp(delimiter)
+        /
+        \A
+        [[:space:]]*
+        (?<multiline_comment_indentation>^[[:blank:]]*)
+        #{delimiter}
+        [[:space:]]*
+        ---
+        (?<front_matter>.*?)
+        ---
+        [[:blank:]]*$[\n\r]
+        (?<content>.*)
+        \z
+        /mx
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end

data/lib/front_matter_parser/syntax_parser/multi_line_comment.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module FrontMatterParser
+  module SyntaxParser
+    # Parser for syntaxes which use end and finish comment delimiters
+    class MultiLineComment
+      extend Factorizable
+
+      # @!attribute [r] regexp
+      # A regexp that returns two groups: front_matter and content
+      attr_reader :regexp
+
+      def initialize
+        @regexp = build_regexp(*self.class.delimiters)
+      end
+
+      # @see SyntaxParser
+      def call(string)
+        string.match(regexp)
+      end
+
+      # @see Factorizable
+      # :nocov:
+      def self.delimiters
+        raise NotImplementedError
+      end
+
+      private
+
+      # rubocop:disable Metrics/MethodLength
+      def build_regexp(start_delimiter, end_delimiter)
+        /
+        \A
+        [[:space:]]*
+        #{start_delimiter}
+        [[:space:]]*
+        ---
+        (?<front_matter>.*?)
+        ---
+        [[:space:]]*
+        #{end_delimiter}
+        [[:blank:]]*$[\n\r]
+        (?<content>.*)
+        \z
+        /mx
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end

data/lib/front_matter_parser/syntax_parser/single_line_comment.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module FrontMatterParser
+  module SyntaxParser
+    # Parser for syntaxes which each comment is for a single line
+    class SingleLineComment
+      extend Factorizable
+
+      # @!attribute [r] regexp
+      # A regexp that returns two groups: front_matter (with comment delimiter
+      # in it) and content
+      attr_reader :regexp
+
+      def initialize
+        @regexp = build_regexp(*self.class.delimiters)
+      end
+
+      # @see SyntaxParser
+      def call(string)
+        match = string.match(regexp)
+        if match
+          front_matter = self.class.remove_delimiter(match[:front_matter])
+          {
+            front_matter: front_matter,
+            content: match[:content]
+          }
+        else
+          match
+        end
+      end
+
+      # @see Factorizable
+      # :nocov:
+      def self.delimiters
+        raise NotImplementedError
+      end
+
+      # @!visibility private
+      def self.remove_delimiter(front_matter)
+        delimiter = delimiters.first
+        front_matter.gsub(/^[\s\t]*#{delimiter}/, '')
+      end
+
+      private
+
+      # rubocop:disable Metrics/MethodLength
+      def build_regexp(delimiter)
+        /
+        \A
+        [[:space:]]*
+        #{delimiter}[[:blank:]]*
+        ---
+        (?<front_matter>.*?)
+        ^[[:blank:]]*#{delimiter}[[:blank:]]*
+        ---
+        [[:blank:]]*$[\n\r]
+        (?<content>.*)
+        \z
+        /mx
+      end
+      # rubocop:enable Metrics/MethodLength
+    end
+  end
+end

data/lib/front_matter_parser/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FrontMatterParser
-  VERSION = "0.0.4"
+  VERSION = '1.0.0'
 end

data/spec/fixtures/example

@@ -0,0 +1,6 @@
+<!--
+  ---
+  title: hello
+  ---
+-->
+Content

data/spec/front_matter_parser/loader/yaml_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe FrontMatterParser::Loader::Yaml do
+  describe '#call' do
+    it 'loads using yaml parser' do
+      string = "title: 'hello'"
+
+      expect(described_class.new.call(string)).to eq(
+        'title' => 'hello'
+      )
+    end
+
+    it 'loads with classes in allowlist' do
+      string = 'timestamp: 2017-10-17 00:00:00Z'
+      params = { allowlist_classes: [Time] }
+
+      expect(described_class.new(**params).call(string)).to eq(
+        'timestamp' => Time.parse('2017-10-17 00:00:00Z')
+      )
+    end
+  end
+end

data/spec/front_matter_parser/parsed_spec.rb

@@ -1,28 +1,18 @@
-require 'spec_helper'
-
-module FrontMatterParser
-  describe Parsed do
-
-    let(:sample) { {'title' => 'hello'} }
+# frozen_string_literal: true
 
-    let(:string) { %Q(
----
-title: hello
----
-Content) }
+require 'spec_helper'
 
-    let(:parsed) { FrontMatterParser.parse(string) }
+describe FrontMatterParser::Parsed do
+  subject(:parsed) do
+    described_class.new(front_matter: front_matter, content: content)
+  end
 
-    describe "#to_hash" do
-      it "returns @front_matter" do
-        expect(parsed.to_hash).to eq(sample)
-      end
-    end
+  let(:front_matter) { { 'title' => 'hello' } }
+  let(:content) { 'Content' }
 
-    describe "#[]" do
-      it "returns the front matter value for the given key" do
-        expect(parsed['title']).to eq('hello')
-      end
+  describe '#[]' do
+    it 'returns front_matter value for given key' do
+      expect(parsed['title']).to eq('hello')
     end
   end
 end