middleman-vegas 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 11a6e075c85ec4bc5795feb0a5cf8b1e6072cb59
+  data.tar.gz: f3bf9881353914c84facb586e40a38ff36b40434
+SHA512:
+  metadata.gz: 9117b96ee612425ef25d031e17bbe094a4795400ba6655a789f7ae1e238b7d3aa028bd861bbc5f70957384f9eac638aa94c900c1dbb9631bc49e110cc1f6766c
+  data.tar.gz: a74bca176f8b0b66df18e46dc95b2da0302f1dfa95b9bb27cd5461cd31bdb5759d9a1e89b1ef22c6fbc557fcc6b1663587e71d937b27217a1606f51b1c14367d

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,74 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as
+contributors and maintainers pledge to making participation in our project and
+our community a harassment-free experience for everyone, regardless of age, body
+size, disability, ethnicity, gender identity and expression, level of experience,
+nationality, personal appearance, race, religion, or sexual identity and
+orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment
+include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or
+advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+  professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable
+behavior and are expected to take appropriate and fair corrective action in
+response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community. Examples of
+representing a project or community include using an official project e-mail
+address, posting via an official social media account, or acting as an appointed
+representative at an online or offline event. Representation of a project may be
+further defined and clarified by project maintainers.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting the project team at franklin.webber@gmail.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. The project team is
+obligated to maintain confidentiality with regard to the reporter of an incident.
+Further details of specific enforcement policies may be posted separately.
+
+Project maintainers who do not follow or enforce the Code of Conduct in good
+faith may face temporary or permanent repercussions as determined by other
+members of the project's leadership.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4,
+available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in middleman-vegas.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Franklin Webber
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,80 @@
+# Middleman::Vegas
+
+This brings the great styles and metadata support found in the Octopress Code Highlighter to Middleman. This has some additional features beyond that to support the work being done for Habitat.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'middleman-vegas'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install middleman-vegas
+
+## Usage
+
+Activate it to the Middleman `config.rb`:
+
+```ruby
+activate :vegas
+```
+
+## Syntax
+
+You can define code fences as you would normally. These code fences have support for the languages defined in [rouge](https://github.com/jneen/rouge/wiki/List-of-supported-languages-and-lexers).
+
+Define a code fence with a language.
+
+    ```lang
+    [code]
+    ```
+
+Define a code fence for a language with the addition of a title.
+
+    ```lang title
+    [code]
+    ```
+
+Define a code fence for a language with additional metadata
+
+    ```lang [metadata]
+    [code]
+    ```
+
+The additional metadata that can be specified:
+
+| Metadata     | Example                    | Description                                                           |
+|:-------------|:---------------------------|:----------------------------------------------------------------------|
+|`lang`        | `ruby`                     | Used by the syntax highlighter. Passing 'plain' disables highlighting.|
+|`title`       | `title:"Figure 1.A"`       | Add a figcaption title to your code block. |
+|`url`         | `url:"https://github.com"` | No default value |
+|`link_text`   | `link_text:"Download"`     | Text for the link, default: `"link"` |
+|`linenos`     | `linenos:true`             | Enables line numbering |
+|`start`       | `start:5`                  | Start the line numbering at the given value. |
+|`mark`        | `mark:1-4,8`               | Highlight lines of code. This example marks lines 1,2,3,4 and 8 |
+|`class`       | `class:"css example"`      | Add CSS class names to the code `<figure>` element |
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/burtlo/middleman-vegas. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Middleman::Octopress::Code::Highlighter project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/burtlo/middleman-vegas/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "middleman/octopress/code/highlighter"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/middleman-vegas.rb

@@ -0,0 +1,5 @@
+require 'middleman-core'
+require 'middleman-vegas/version'
+require 'middleman-vegas/extension'
+
+::Middleman::Extensions.register(:vegas, ::Middleman::Vegas::SyntaxExtension)

data/lib/middleman-vegas/extension.rb

@@ -0,0 +1,60 @@
+require 'middleman-vegas/highlighter'
+require 'middleman-vegas/redcarpet_code_renderer'
+
+module Middleman
+  module Vegas
+    class SyntaxExtension < ::Middleman::Extension
+      option :css_class, 'highlight', 'Class name applied to the syntax-highlighted output.'
+      option :line_numbers, false, 'Generate line numbers.'
+      option :start_line, 1, 'Start the line numbering (if enabled) at the desired integer'
+      option :inline_theme, nil, 'A Rouge::CSSTheme that will be used to highlight the output with inline styles instead of using CSS classes.'
+      option :wrap, true, 'Wrap the highlighted content in a container (<pre> or <div>, depending on whether :line_numbers is on).'
+      option :lexer_options, {}, 'Options for the Rouge lexers.'
+
+      def after_configuration
+        Middleman::Vegas::Highlighter.options = options
+        if app.config[:markdown_engine] == :redcarpet
+          require 'middleman-core/renderers/redcarpet'
+          Middleman::Renderers::MiddlemanRedcarpetHTML.send :include, RedcarpetCodeRenderer
+        end
+      end
+
+      helpers do
+        # Output highlighted code. Use like:
+        #
+        #    <% code('ruby', :line_numbers => true, :start_line => 7) do %>
+        #      my code
+        #    <% end %>
+        #
+        # To produce the following structure:
+        #
+        #    <pre class="highlight ruby">
+        #      <code>#{your code}</code>
+        #    </pre>
+        #
+        # If no language is provided, then the language name is `plaintext`.
+        #
+        # @param [String] language that the Rouge lexer should use
+        # @param [Hash] Options to pass to the Rouge formatter & lexer, overriding global options set by :highlighter_options.
+        def code(language=nil, options={}, &block)
+          raise 'The code helper requires a block to be provided.' unless block_given?
+
+          options[:lang] = language.to_s
+          options[:marks] ||= []
+
+          # Save current buffer for later
+          @_out_buf, _buf_was = "", @_out_buf
+
+          begin
+            content = capture_html(&block)
+          ensure
+            # Reset stored buffer
+            @_out_buf = _buf_was
+          end
+          content = content.encode(Encoding::UTF_8)
+          concat_content Highlighter.highlight(content, options).html_safe
+        end
+      end
+    end
+  end
+end

data/lib/middleman-vegas/formatters/table_formatter.rb

@@ -0,0 +1,81 @@
+module Middleman
+  module Vegas
+
+    # When you want to render code with a title, a link, line numbers and highlights
+    # in a table style.
+    class TableFormatter
+      def render(code, metadata)
+        lexer = Rouge::Lexer.find_fancy(metadata[:lang], code) || Rouge::Lexers::PlainText
+        lexed_code = expand_tokens_with_newlines(lexer.lex(code, {}))
+
+        formatter = Rouge::Formatters::HTML.new(wrap: false)
+        rendered_code = formatter.format(lexed_code)
+        rendered_code = tableize_code(rendered_code, metadata)
+
+        classnames = [ 'code-highlight-figure', metadata[:class].to_s ].join(' ')
+
+        "<figure class='#{classnames}'>#{caption(metadata)}#{rendered_code}</figure>"
+      end
+
+      # The lexed code generates an enumerator of tokens with their values.
+      # Before they are rendered to HTML all of the non-text tokens with newlines
+      # should be split into several tokens of the same type. This ensures
+      # that when they are tableized later the surrounding spans are not broken.
+      def expand_tokens_with_newlines(lexed_code)
+        full_lex = []
+        lexed_code.each do |token, value|
+          if token.qualname == "Text"
+            full_lex << [ token, value ]
+          else
+            lines = value.split("\n")
+            lines.each_with_index do |line, index|
+              # if not the last line or the last line had a newline at the end
+              suffix = if index < (lines.length - 1) || (index == (lines.length - 1) && value.end_with?("\n"))
+                "\n"
+              else
+                ""
+              end
+
+              full_lex << [ token, "#{line}#{suffix}" ]
+            end
+          end
+        end
+        full_lex
+      end
+
+      # Given the rendered code it is time to present the information in a table.
+      def tableize_code(code, options)
+        start = options[:start] || 1
+        lines = options[:linenos] || false
+        marks = options[:marks]
+
+        table = "<div class='code-highlight'>"
+        table += "<pre class='code-highlight-pre'>"
+        code.lines.each_with_index do |line,index|
+          classes = 'code-highlight-row'
+          classes += lines ? ' numbered' : ' unnumbered'
+          if marks.include? index + start
+            classes += ' marked-line'
+            classes += ' start-marked-line' unless marks.include? index - 1 + start
+            classes += ' end-marked-line' unless marks.include? index + 1 + start
+          end
+          line = line.strip.empty? ? ' ' : line
+          table += "<div data-line='#{index + start}' class='#{classes}'><div class='code-highlight-line'>#{line}</div></div>"
+        end
+        table +="</pre></div>"
+      end
+
+      # Generates a caption above the code area when there is a title / url
+      def caption(options)
+        if options[:title]
+          figcaption  = "<figcaption class='code-highlight-caption'><span class='code-highlight-caption-title'>#{options[:title]}</span>"
+          figcaption += "<a class='code-highlight-caption-link' href='#{options[:url]}'>#{(options[:link_text] || 'link').strip}</a>" if options[:url]
+          figcaption += "</figcaption>"
+        else
+          ''
+        end
+      end
+
+    end
+  end
+end

data/lib/middleman-vegas/highlighter.rb

@@ -0,0 +1,50 @@
+require 'rouge'
+require 'middleman-vegas/formatters/table_formatter'
+
+module Middleman
+  module Vegas
+    module Highlighter
+      mattr_accessor :options
+
+      # The highlight method is called when code fences are used in RedCarpet
+      # and when the code helper is used.
+      #
+      # @param code [String] the content found within the code block
+      # @param options [Hash] contains any additional rendering options provided
+      #    to the code helper methods, as code fences don't have a way to
+      #    provide additional parameters.
+      #
+      # @return the HTML that will be rendered to the page
+      def self.highlight(code, metadata={})
+        return no_html if code_block_is_empty?(code.strip)
+        metadata[:lang] = with_lang_aliases_considered(metadata[:lang])
+        TableFormatter.new.render(code, metadata)
+      end
+
+      def self.code_block_is_empty?(code)
+        code == "" || code == "</div>"
+      end
+
+      def self.no_html
+        ""
+      end
+
+      # When languages are provided they could be aliases for other languages
+      # or the way that they are presented. With a few languages we want to
+      # make sure that they are presented within the context of a console.
+      def self.with_lang_aliases_considered(lang)
+        case lang
+        when 'cmd'
+          'console?lang=powershell'
+        when 'posh', 'powershell', 'shell', 'studio'
+          "console?lang=#{lang}"
+        when 'ps1'
+          'powershell'
+        else
+          lang
+        end
+      end
+
+    end
+  end
+end

data/lib/middleman-vegas/lexers/habitat_studio.rb

@@ -0,0 +1,164 @@
+require 'rouge'
+
+module Middleman
+  module Vegas
+    class HabitatStudio < Rouge::RegexLexer
+      title "studio"
+      desc "Habitat Studio uses bash but there are a few binaries, aliases, and functions that already exist"
+
+      tag 'studio'
+
+      KEYWORDS = %w(
+        if fi else while do done for then return function
+        select continue until esac elif in
+      ).join('|')
+
+      BUILTINS = %w(
+        hab build sl sup-log
+      ).join('|')
+
+      state :basic do
+        rule /#.*$/, Comment
+
+        rule /\b(#{KEYWORDS})\s*\b/, Keyword
+        rule /\bcase\b/, Keyword, :case
+
+        rule /\b(#{BUILTINS})\s*\b(?!(\.|-))/, Name::Builtin
+        rule /[.](?=\s)/, Name::Builtin
+
+        rule /(\b\w+)(=)/ do |m|
+          groups Name::Variable, Operator
+        end
+
+        rule /[\[\]{}()!=>]/, Operator
+        rule /&&|\|\|/, Operator
+
+        # here-string
+        rule /<<</, Operator
+
+        rule /(<<-?)(\s*)(\'?)(\\?)(\w+)(\3)/ do |m|
+          groups Operator, Text, Str::Heredoc, Str::Heredoc, Name::Constant, Str::Heredoc
+          @heredocstr = Regexp.escape(m[5])
+          push :heredoc
+        end
+      end
+
+      state :heredoc do
+        rule /\n/, Str::Heredoc, :heredoc_nl
+        rule /[^$\n]+/, Str::Heredoc
+        mixin :interp
+        rule /[$]/, Str::Heredoc
+      end
+
+      state :heredoc_nl do
+        rule /\s*(\w+)\s*\n/ do |m|
+          if m[1] == @heredocstr
+            token Name::Constant
+            pop! 2
+          else
+            token Str::Heredoc
+          end
+        end
+
+        rule(//) { pop! }
+      end
+
+
+      state :double_quotes do
+        # NB: "abc$" is literally the string abc$.
+        # Here we prevent :interp from interpreting $" as a variable.
+        rule /(?:\$#?)?"/, Str::Double, :pop!
+        mixin :interp
+        rule /[^"`\\$]+/, Str::Double
+      end
+
+      state :ansi_string do
+        rule /\\./, Str::Escape
+        rule /[^\\']+/, Str::Single
+        mixin :single_quotes
+      end
+
+      state :single_quotes do
+        rule /'/, Str::Single, :pop!
+        rule /[^']+/, Str::Single
+      end
+
+      state :data do
+        rule /\s+/, Text
+        rule /\\./, Str::Escape
+        rule /\$?"/, Str::Double, :double_quotes
+        rule /\$'/, Str::Single, :ansi_string
+
+        # single quotes are much easier than double quotes - we can
+        # literally just scan until the next single quote.
+        # POSIX: Enclosing characters in single-quotes ( '' )
+        # shall preserve the literal value of each character within the
+        # single-quotes. A single-quote cannot occur within single-quotes.
+        rule /'/, Str::Single, :single_quotes
+
+        rule /\*/, Keyword
+
+        rule /;/, Punctuation
+
+        rule /--?[\w-]+/, Name::Tag
+        rule /[^=\*\s{}()$"'`;\\<]+/, Text
+        rule /\d+(?= |\Z)/, Num
+        rule /</, Text
+        mixin :interp
+      end
+
+      state :curly do
+        rule /}/, Keyword, :pop!
+        rule /:-/, Keyword
+        rule /[a-zA-Z0-9_]+/, Name::Variable
+        rule /[^}:"`'$]+/, Punctuation
+        mixin :root
+      end
+
+      state :paren do
+        rule /\)/, Keyword, :pop!
+        mixin :root
+      end
+
+      state :math do
+        rule /\)\)/, Keyword, :pop!
+        rule %r([-+*/%^|&!]|\*\*|\|\|), Operator
+        rule /\d+(#\w+)?/, Num
+        mixin :root
+      end
+
+      state :case do
+        rule /\besac\b/, Keyword, :pop!
+        rule /\|/, Punctuation
+        rule /\)/, Punctuation, :case_stanza
+        mixin :root
+      end
+
+      state :case_stanza do
+        rule /;;/, Punctuation, :pop!
+        mixin :root
+      end
+
+      state :backticks do
+        rule /`/, Str::Backtick, :pop!
+        mixin :root
+      end
+
+      state :interp do
+        rule /\\$/, Str::Escape # line continuation
+        rule /\\./, Str::Escape
+        rule /\$\(\(/, Keyword, :math
+        rule /\$\(/, Keyword, :paren
+        rule /\${#?/, Keyword, :curly
+        rule /`/, Str::Backtick, :backticks
+        rule /\$#?(\w+|.)/, Name::Variable
+        rule /\$[*@]/, Name::Variable
+      end
+
+      state :root do
+        mixin :basic
+        mixin :data
+      end
+    end
+  end
+end

data/lib/middleman-vegas/markdown_parser.rb

@@ -0,0 +1,62 @@
+require 'middleman-vegas/options_parser'
+
+module Middleman
+  module Vegas
+    module MarkdownParser
+      # Evaluate the entire document and look code blocks:
+      #
+      #     ```LANGUAGE METADATA
+      #     CODE
+      #     ```
+      def self.parse_document(full_document)
+        full_document.gsub /^`{3}.+?`{3}/m do |code_block|
+          parse_code_block code_block
+        end
+      end
+
+      # Extract from the code block the metadata and the code and highlight it.
+      #
+      #     ```LANGUAGE METADATA
+      #     CODE
+      #     ```
+      #
+      def self.parse_code_block(code_block)
+        code_block.gsub /`{3}([^\n]+)?\n(.+?)`{3}\Z/m do
+          metadata = get_metadata(Regexp.last_match(1).to_s)
+          code = Regexp.last_match(2).to_s
+          ::Middleman::Vegas::Highlighter.highlight(code, metadata)
+        end
+      end
+
+      AllOptions = /([^\s]+)\s+(.+?)\s+(https?:\/\/\S+|\/\S+)\s*(.+)?/i
+      LangCaption = /([^\s]+)\s*(.+)?/i
+
+      # Extract the metadata from the code block. There are two simple formats:
+      #
+      #     ```LANGUAGE TITLE
+      #
+      #     ```LANGUAGE TITLE URL LINK_TEXT
+      #
+      #
+      def self.get_metadata(markup)
+        defaults = { escape: true }
+        clean_markup = OptionsParser.new(markup).clean_markup
+
+        if clean_markup =~ AllOptions
+          defaults = {
+            lang: $1,
+            title: $2,
+            url: $3,
+            link_text: $4,
+          }
+        elsif clean_markup =~ LangCaption
+          defaults = {
+            lang: $1,
+            title: $2
+          }
+        end
+        OptionsParser.new(markup).parse_markup(defaults)
+      end
+    end
+  end
+end

data/lib/middleman-vegas/options_parser.rb

@@ -0,0 +1,140 @@
+module Middleman
+  module Vegas
+    class OptionsParser
+      attr_accessor :input
+
+      def initialize(markup)
+        @input = markup.strip
+      end
+
+      def clean_markup
+        input.sub(/\s*lang:\s*\S+/i,'')
+          .sub(/\s*title:\s*(("(.+?)")|('(.+?)')|(\S+))/i,'')
+          .sub(/\s*url:\s*(\S+)/i,'')
+          .sub(/\s*link_text:\s*(("(.+?)")|('(.+?)')|(\S+))/i,'')
+          .sub(/\s*mark:\s*\d\S*/i,'')
+          .sub(/\s*linenos:\s*\w+/i,'')
+          .sub(/\s*start:\s*\d+/i,'')
+          .sub(/\s*end:\s*\d+/i,'')
+          .sub(/\s*range:\s*\d+-\d+/i,'')
+          .sub(/\s*escape:\s*\w+/i,'')
+          .sub(/\s*startinline:\s*\w+/i,'')
+          .sub(/\s*class:\s*(("(.+?)")|('(.+?)')|(\S+))/i,'')
+      end
+
+      def parse_markup(defaults = {})
+        options = {
+          lang:      lang,
+          url:       url,
+          title:     title,
+          linenos:   linenos,
+          marks:     marks,
+          link_text: link_text,
+          start:     start,
+          end:       endline,
+          escape:    escape,
+          startinline: startinline,
+          class:     classnames
+        }
+        options = options.delete_if { |k,v| v.nil? }
+        defaults.merge(options)
+      end
+
+      def lang
+        extract(/\s*lang:\s*(\S+)/i)
+      end
+
+      def startinline
+        boolize(extract(/\s*startinline:\s*(\w+)/i))
+      end
+
+      def classnames
+        extract(/\s*class:\s*(("(.+?)")|('(.+?)')|(\S+))/i, [3, 5, 6])
+      end
+
+      def url
+        extract(/\s*url:\s*(("(.+?)")|('(.+?)')|(\S+))/i, [3, 5, 6])
+      end
+
+      def title
+        extract(/\s*title:\s*(("(.+?)")|('(.+?)')|(\S+))/i, [3, 5, 6])
+      end
+
+      def linenos
+        boolize(extract(/\s*linenos:\s*(\w+)/i))
+      end
+
+      def escape
+        boolize(extract(/\s*escape:\s*(\w+)/i))
+      end
+
+      # Public: Matches pattern for line marks and returns array of line
+      #         numbers to mark
+      #
+      # Example input
+      #   Input:  "mark:1,5-10,2"
+      #   Output: [1,2,5,6,7,8,9,10]
+      #
+      # Returns an array of integers corresponding to the lines which are
+      #   indicated as marked
+      def marks
+        marks = []
+        if input =~ / *mark:(\d\S*)/i
+          marks = $1.gsub /(\d+)-(\d+)/ do
+            ($1.to_i..$2.to_i).to_a.join(',')
+          end
+          marks = marks.split(',').collect {|s| s.to_i}.sort
+        end
+        marks
+      end
+
+      def link_text
+        extract(/\s*link[-_]text:\s*(("(.+?)")|('(.+?)')|(\S+))/i, [3, 5, 6], 'link')
+      end
+
+      def start
+        if range
+          range.first
+        else
+          num = extract(/\s*start:\s*(\d+)/i)
+          num = num.to_i unless num.nil?
+          num
+        end
+      end
+
+      def endline
+        if range
+          range.last
+        else
+          num = extract(/\s*end:\s*(\d+)/i)
+          num = num.to_i unless num.nil?
+          num
+        end
+      end
+
+      def range
+        if input.match(/ *range:(\d+)-(\d+)/i)
+          [$1.to_i, $2.to_i]
+        end
+      end
+
+      def extract(regexp, indices_to_try = [1], default = nil)
+        thing = input.match(regexp)
+        if thing.nil?
+          default
+        else
+          indices_to_try.each do |index|
+            return thing[index] if thing[index]
+          end
+        end
+      end
+
+      def boolize(str)
+        return nil if str.nil?
+        return true if str == true || str =~ (/(true|t|yes|y|1)$/i)
+        return false if str == false || str =~ (/(false|f|no|n|0)$/i) || str.strip.size > 1
+        return str
+      end
+    end
+  end
+end

data/lib/middleman-vegas/redcarpet_code_renderer.rb

@@ -0,0 +1,20 @@
+require 'middleman-vegas/markdown_parser'
+
+module Middleman
+  module Vegas
+    # A mixin for the Redcarpet Markdown renderer that will assist in finding
+    # codeblocks and replacing them with rendered HTML.
+    module RedcarpetCodeRenderer
+      #
+      # Traditionally you would enable code fences in RedCarpet and then
+      # process it with #block_code function. But code blocks parsed that way
+      # will not allow you to define metadata. So the entire document needs to
+      # be examined.
+      #
+      # @see Middleman::Vegas::MarkdownParser
+      def preprocess(full_document)
+        MarkdownParser.parse_document full_document
+      end
+    end
+  end
+end

data/lib/middleman-vegas/version.rb

@@ -0,0 +1,5 @@
+module Middleman
+  module Vegas
+    VERSION = '0.1.0'
+  end
+end

data/middleman-vegas.gemspec

@@ -0,0 +1,29 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "middleman-vegas/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "middleman-vegas"
+  spec.version       = Middleman::Vegas::VERSION
+  spec.authors       = ["Franklin Webber"]
+  spec.email         = ["franklin.webber@gmail.com"]
+
+  spec.summary       = %q{Add code highlighting to your middleman application.}
+  spec.description   = %q{This brings the powerful features found in the Octopress Code Highlighter to Middleman. This allows you to specify code fences with additional metadata to provide a richer experience when using code to tell your stories.}
+  spec.homepage      = "https://github.com/burtlo/middleman-vegas"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency("middleman-core", ["~> 4.0"])
+  spec.add_runtime_dependency("rouge", ["~> 3.0"])
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: middleman-vegas
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Franklin Webber
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-11-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: middleman-core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: rouge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: This brings the powerful features found in the Octopress Code Highlighter
+  to Middleman. This allows you to specify code fences with additional metadata to
+  provide a richer experience when using code to tell your stories.
+email:
+- franklin.webber@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/middleman-vegas.rb
+- lib/middleman-vegas/extension.rb
+- lib/middleman-vegas/formatters/table_formatter.rb
+- lib/middleman-vegas/highlighter.rb
+- lib/middleman-vegas/lexers/habitat_studio.rb
+- lib/middleman-vegas/markdown_parser.rb
+- lib/middleman-vegas/options_parser.rb
+- lib/middleman-vegas/redcarpet_code_renderer.rb
+- lib/middleman-vegas/version.rb
+- middleman-vegas.gemspec
+homepage: https://github.com/burtlo/middleman-vegas
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Add code highlighting to your middleman application.
+test_files: []