raconteur 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c64b155fb75f4fa4e92ca6d4c0109c7bf71905f0
+  data.tar.gz: 668db905ee4fbc62b71df3a73dcbf46ce2d4b21f
+SHA512:
+  metadata.gz: 336e2825fd8658bbf8a7dcc493b7594527f49ce1346f921f8a669ac1ee45c565e91bea6a623e01a00464e67038b92169b2eaad327f4fcd7cc7e00ea68bd2f5b5
+  data.tar.gz: 252382f235f204f32d1a4f5f1fd63113a7ccfeb3a6705261708c5a35c1fadbcb627253206c90929d22ccd0e22b4443724bac7ffc8e5309f36671394fef8ec50d

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.10.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in raconteur.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,42 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exists?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+guard :minitest do
+  # with Minitest::Unit
+  watch(%r{^test/(.*)\/?(.*)_test\.rb$})
+  watch(%r{^lib/(.*/)?([^/]+)\.rb$})     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
+  watch(%r{^test/test_helper\.rb$})      { 'test' }
+
+  # with Minitest::Spec
+  # watch(%r{^spec/(.*)_spec\.rb$})
+  # watch(%r{^lib/(.+)\.rb$})         { |m| "spec/#{m[1]}_spec.rb" }
+  # watch(%r{^spec/spec_helper\.rb$}) { 'spec' }
+
+  # Rails 4
+  # watch(%r{^app/(.+)\.rb$})                               { |m| "test/#{m[1]}_test.rb" }
+  # watch(%r{^app/controllers/application_controller\.rb$}) { 'test/controllers' }
+  # watch(%r{^app/controllers/(.+)_controller\.rb$})        { |m| "test/integration/#{m[1]}_test.rb" }
+  # watch(%r{^app/views/(.+)_mailer/.+})                   { |m| "test/mailers/#{m[1]}_mailer_test.rb" }
+  # watch(%r{^lib/(.+)\.rb$})                               { |m| "test/lib/#{m[1]}_test.rb" }
+  # watch(%r{^test/.+_test\.rb$})
+  # watch(%r{^test/test_helper\.rb$}) { 'test' }
+
+  # Rails < 4
+  # watch(%r{^app/controllers/(.*)\.rb$}) { |m| "test/functional/#{m[1]}_test.rb" }
+  # watch(%r{^app/helpers/(.*)\.rb$})     { |m| "test/helpers/#{m[1]}_test.rb" }
+  # watch(%r{^app/models/(.*)\.rb$})      { |m| "test/unit/#{m[1]}_test.rb" }
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Jamie Appleseed
+
+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,94 @@
+# Raconteur
+
+With Raconteur, you can define custom text tags and have them parsed according to your specifications, allowing you to do some neat pre- and post-processing of your texts. You could for instance insert dynamic content fetched from your database whenever {{ customer-quote: id=43 }} appears in your text.
+
+## Installation
+
+Raconteur is a Ruby gem so install like any other gem. For example, if you're using Bundler, then add this to your application's Gemfile:
+
+```ruby
+gem 'raconteur'
+```
+
+## Usage
+
+Raconteur is based around the notion of processors. Each processor has a tag-name and a set of instructions for how it should perform the content replacement and what it should insert.
+
+```ruby
+@raconteur = Raconteur.new
+@raconteur.processors.register!('customer-quote', {
+  template: '<div class="quote" id="customer-quote-{{ id }}">\'{{ text }}\' - {{ author }}</div>',
+  handler: lambda do |settings|
+    quote = CustomerQuote.find(settings[:id])
+    { author: quote.author_name, text: quote.citation, id: quote.id }
+  end
+  })
+@raconteur.parse("Here's what some of our customers are saying about the product:\n{{ customer-quote: id=43 }}\n{{ customer-quote: id=266 }}\n{{ customer-quote: id=7 }}")
+# -- outputs --
+# Here's what some of our customers are saying:
+# <div class="quote" id="customer-quote-43">'The most amazing usability report I have ever read!' - James Newman</div>
+# <div class="quote" id="customer-quote-266">'I cannot believe how incredible the benchmark database is!' - Jane Newton</div>
+# <div class="quote" id="customer-quote-7">'Spetacular customer service.' - John Oldling</div>
+```
+
+Here's what's happening in the above example:
+
+- We first create a new instance of Raconteur. (Tip: You can create multiple Raconteur instances, each with its own settings and set of processors.)
+- We then register a processor with the tag-name 'customer-quote'. This means that any instances of {{ customer-quote }} in the parsed text will be replaced according to the settings of this processor.
+- The processor has a <code>template</code> and a <code>handler</code>. The <code>template</code> is a simple string with {{ variables }} that are replaced with dynamic content. The <code>handler</code> loads the customer quotes from our database based on the id that was passed in as a setting in the customer-quote tags (i.e. {{ customer-quote: id=43 }} invokes the handler with a settings hash of { id: "43" }).
+- Finally, we call the <code>parse</code> function on our Raconteur instance, which runs over the text and replaces all instances that match its registered processors according to their specifications.
+
+Processors must always have a tag-name name along with either a template defined, a handler defined, or both. If a handler returns a hash (like in the above example), it should have a template defined as well – Raconteur will take the returned hash and use its keys as replacement variables for the template (again, like seen in the example above). Handlers may also return a string, in which Raconteur will use this as the replacement, allowing you full control over the replaced text. If there's only a template defined, Raconteur will simply pass in any inputted tag settings as variables and then replace the tag with that template.
+
+Processors may also be used for wrapping tags, which is a great way to encapsulate sections in your text. Let's look at an example:
+
+```ruby
+@raconteur = Raconteur.new
+@raconteur.processors.register!('gallery', {
+  template: '<div class="aside"><p class="box-label">Aside:</p>{{ _yield_ }}</div>'
+  })
+@raconteur.processors.register!('image', {
+  handler: lambda do |settings|
+    image = MediaLibrary.find(settings[:id]).image
+    "<div class=\"graphic\"><img src=\"#{image.url}\" /><p class=\"caption\">#{image.caption}</p></div>"
+  end
+  })
+@raconteur.parse("Some paragraph text.\n\n{{ image: id=43 }}\n\nAnother paragraph.\n\n{{% aside %}}\n\nAdditional tangentially-related text.\n\n{{ image: id=125 }}\n\nWe're really getting off-topic here.\n\n{{% end %}}\n\nOk, back to regular text.")
+# -- outputs --
+# Some paragraph text.
+#
+# <div class="graphic"><img src="http://some-url.com/some-path-for-image-43.jpg" /><p class="caption">A captivating caption text for the image.</p></div>
+#
+# Another paragraph.
+#
+# <div class="aside"><p class="box-label">Aside:</p>
+#
+# Additional tangentially-related text.
+#
+# <div class="graphic"><img src="http://some-url.com/some-path-for-image-125.jpg" /><p class="caption">Another fascinating caption for another incredible image, but this time wrapped within an aside!</p></div>
+#
+# We're really getting off-topic here.
+#
+# </div>
+#
+# Ok, back to regular text.
+```
+
+Wrappers are registered like all other processors but are invoked a lille differently in the text by having percentage symbols added to their curly braces and needing an {{% end %}} tag to signify when they should end. Wrapper templates work the same except they have a special {{ _yield_ }} variable passed into them, which holds the contents of the wrapped content.
+
+In the above example, you'll notice that regular tags (in this case {{ image }}) can be used within wrappers. Wrappers may also be nested within each other. Any tags (both wrappers and regular blocks) nested within a wrapper will have a special _scope_ variable passed to their <code>handler</code> method, allowing you to customize the behavior of a tag based on its surrounding context. For instance, you could register an {{ image }} tag which renders differently depending on whether it is placed within a {{% gallery %}} wrapper or not.
+
+Let's take a look at tags:
+
+- Tags are wrapper by two curly braces and their name should be a string without any white-space <code>{{ like-this }}</code>.
+- Tags don't need any settings. Something simple like <code>{{ page-count }}</code> will work perfectly fine.
+- If you do want to pass in settings to a tag, the tag-name should be followed by a colon and a set of key-value pairs. The key must not include any white-space characters and will be converted to an underscored symbol for the settings hash. The separator should be an equals '=' symbol. The value may either be a word without any white-space characters, or it can be "a text wrapped by quotes". <code>{{ definition: term=UXD + description="User Experience Design (aka UXD + UED + XD) refers to the ..." }}</code>
+- To escape quotes within a quoted settings value, put a backslash in front of the quote. You may alternatively configure Raconteur to use a different symbol for wrapping the text. Both non-white-space values and quoted values may be used in the same tag (as seen in the above "User Experience Design" example where the <code>term</code> isn't quoted but the <code>description</code> is). The key-value pairs in settings don't need to be separated by anything other than a white-space character but it can greatly help readability to include some character (such as a '+' symbol, as seen in the above "User Experience Design" example).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/raconteur.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "raconteur"
+
+# 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

data/bin/setup

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

data/lib/raconteur.rb

@@ -0,0 +1,49 @@
+class Raconteur
+  DEFAULTS = {
+    processors: [],
+    settings: {
+      closing_tag: 'end',
+      setting_quotes: '"'
+    }
+  }
+  ORIGINAL_DEFAULTS = Marshal.load(Marshal.dump(DEFAULTS)).freeze
+  ATTRS = DEFAULTS.keys.freeze
+
+  # Bootstrap attributes
+  def initialize(customizations={})
+    @data = Marshal.load(Marshal.dump(DEFAULTS))
+    @raconteur = self
+  end
+
+  # Parse the inputted text with the registered processors
+  def parse(text="", scope=nil)
+    Raconteur::Parse.scoped self, text, scope
+  end
+
+  # Prettier print
+  def inspect
+    "#<Raconteur:0x#{object_id} #{ATTRS.map { |att| "@#{att}=#{send(att).inspect}" }.join(', ')}>"
+  end
+
+  # Accessing settings and processors
+  def settings
+    Raconteur::Setting.scoped self
+  end
+  def processors
+    Raconteur::Processor.scoped self
+  end
+
+
+  private
+
+  def data
+    @data
+  end
+
+end
+
+require "raconteur/version"
+require "raconteur/config"
+require "raconteur/processor"
+require "raconteur/setting"
+require "raconteur/parse"

data/lib/raconteur/config.rb

@@ -0,0 +1,27 @@
+class Raconteur::Config
+
+  # return current default settings for Raconteur
+  def self.default_settings
+    Raconteur::DEFAULTS[:settings]
+  end
+  # revert default settings for Raconteur to original defaults
+  def self.revert_to_original_defaults!
+    Raconteur::DEFAULTS[:settings] = original_default_settings
+  end
+  # return a copy of the original default settings
+  def self.original_default_settings
+    Marshal.load(Marshal.dump(Raconteur::ORIGINAL_DEFAULTS[:settings]))
+  end
+  # Let user override defaults for Raconteur
+  class << self
+    Raconteur::Config.default_settings.keys.each do |att|
+      define_method(att) do
+        self.default_settings[att]
+      end
+      define_method("#{att}=") do |val|
+        self.default_settings[att] = val
+      end
+    end
+  end
+
+end

data/lib/raconteur/parse.rb

@@ -0,0 +1,111 @@
+class Raconteur::Parse
+
+  def self.scoped(raconteur, document, scope)
+    @@raconteur = raconteur
+    parse_blocks(parse_wrappers(document, scope), scope)
+  end
+
+  def self.parse_wrappers(document, scope)
+    output = document
+    regex = /{{%(.*?)%}}/m
+    # scan for all instances of wrappers, i.e. {{% tag-name %}}
+    wrappers = output.scan(regex).flatten
+    unless wrappers.empty?
+      # if wrappers, loop over all opening tags in reverse order (this way the inner-most wrapper is always processed before its parent wrappers)
+      wrappers.map(&:strip).reject { |str| str == @@raconteur.settings.closing_tag }.reverse.each do |open_tag|
+        # loop over each registered processor
+        @@raconteur.processors.each do |processor|
+          # check if the processor matches the tag
+          match = open_tag.match(processor.regex)
+          if match
+            # if there is a match, parse the tag's settings, if it has any
+            match_settings = parse_settings(match[:settings])
+            # merge in the nested wrapper scope, if present
+            match_settings.merge!(_scope_: scope) if scope
+            # identify the tag and its contents
+            regex = /.*(?<tag>{{%\s*#{Regexp.quote(open_tag)}\s*%}}(?<content>.*?){{%\s*#{Regexp.quote(@@raconteur.settings.closing_tag)}\s*%}})/m
+            wrapper_match = output.match(regex)
+            if wrapper_match
+              # if there is a match, run its contents through raconteur with the wrapper set as scope, to perform all necessary replacements (this allows nesting and wrapper customizations)
+              content = @@raconteur.parse(wrapper_match[:content], {
+                tag: open_tag,
+                processor: processor,
+                settings: match_settings
+                })
+              # set _yield_ variable with the (parsed) inner contents of wrapper tag
+              match_settings.merge!(_yield_: content)
+              # execute processor and replace output with result
+              content = processor.execute(content, match_settings)
+              # replace wrapper and its contents with the parsed content
+              output = output.sub(wrapper_match[:tag], content)
+            end
+          end
+        end
+      end
+    end
+    output
+  end
+
+  def self.parse_blocks(output, scope)
+    # replace all instances of {{ some-tag }}
+    output.gsub(/{{(.*?)}}/m) do |raw_str|
+      # the matched string if no processing occurs
+      output = raw_str
+      # clean the matched string to only get the tag and its settings
+      str = output.gsub(/^\{\{\%?\s*|\s*\%?\}\}$/, '')
+      # loop over each registered processor
+      @@raconteur.processors.each do |processor|
+        # check if the processor matches the tag
+        match = str.match(processor.regex)
+        if match
+          # parse the tag's settings, if any
+          match_settings = self.parse_settings(match[:settings])
+          # merge in the nested wrapper scope, if present
+          match_settings.merge!(_scope_: scope) if scope
+          # execute processor and replace output with result
+          output = processor.execute(output, match_settings)
+        end
+      end
+      output
+    end
+  end
+
+  # input: (string) 'id=353 + report-title="E-Commerce Checkout Usability Report"'
+  # output: (hash) { id: '353', report_title: 'E-Commerce Checkout Usability Report' }
+  def self.parse_settings(str)
+    # regex escape 'quote' character
+    quote = Regexp.quote(@@raconteur.settings.setting_quotes)
+    # Parsing logic:
+    # First, one or more non-white-space characters,
+    # .. followed by an equal sign '=' character,
+    # .. followed by either:
+    #       a) 1+ non-white-space characters, or
+    #       b) a string wrapped by the 'quote' character at both ends
+    # (instances of the 'quote' character within the string can be escaped by a backward-slash '\')
+    regex = /([^\s]+)\=(#{quote}.*?[^\\]#{quote}|[^\s]+)/mi
+    # prepare a fresh hash for the parsed settings
+    parsed_settings = {}
+    # loop over all key-value setting pairs in the string
+    str.scan(regex).each do |setting_str|
+      # grap keys and turn them into underscored symbols
+      key = setting_str[0].strip.gsub('-','_').to_sym
+      # strip values from whitespace and surrounding quote characters
+      value = setting_str[1].strip.gsub(/^#{quote}|#{quote}$/mi, '').gsub(/\\#{quote}/mi, quote)
+      # add to settings hash
+      parsed_settings[key] = value
+    end
+    # return the parsed settings (transformed from string to hash)
+    parsed_settings
+  end
+
+  def self.render_template(template, data)
+    output = template
+    # loop over data hash (for value substitution)
+    data.each do |tag, value|
+      # replace dynamic values in the template
+      output = output.gsub(/{{\s*#{tag}\s*}}/, value.to_s)
+    end
+    output
+  end
+
+end

data/lib/raconteur/processor.rb

@@ -0,0 +1,118 @@
+class Raconteur::Processor
+  DEFAULTS = {
+    tag: nil,
+    template: nil,
+    handler: nil,
+    settings: {}
+  }.freeze
+  ATTRS = DEFAULTS.keys.freeze
+
+  # register new processor by providing a tag name + any settings (optional)
+  def self.register!(tag, customizations={})
+    if find(tag)
+      raise 'Processor already exists!'
+    else
+      all << Raconteur::Processor.new(tag, customizations)
+    end
+    self
+  end
+
+  # delete existing processor by tag name
+  def self.deregister!(tag)
+    all.delete(find(tag))
+    self
+  end
+
+  # update existing processor by providing its tag name and passing in any customizations (optional)
+  def self.update!(tag, customizations={})
+    deregister!(tag)
+    register!(tag, customizations)
+    self
+  end
+
+  # scoped
+  def self.scoped(raconteur)
+    @@raconteur = raconteur
+    self
+  end
+
+  # return array of all processors
+  def self.all
+    @@raconteur.send(:data)[:processors]
+  end
+
+  # find processor by tag name
+  def self.find(tag)
+    all.detect { |processor| processor.tag == tag }
+  end
+
+  # print array
+  def self.inspect
+    "#{all} (Raconteur::Processor array)"
+  end
+
+  # treat class as array
+  def self.method_missing(method_sym, *arguments, &block)
+    if !arguments.empty? && block_given?
+      all.send(method_sym, *arguments, &block)
+    elsif !arguments.empty?
+      all.send(method_sym, *arguments)
+    elsif block_given?
+      all.send(method_sym, &block)
+    else
+      all.send(method_sym)
+    end
+  end
+
+
+  # -- Instances --
+
+  # new processor
+  def initialize(tag, customizations={})
+    @data = Marshal.load(Marshal.dump(DEFAULTS))
+    @processor = self
+    @processor.tag = tag
+    @processor.template = customizations[:template] if customizations[:template].is_a?(String)
+    @processor.handler = customizations[:handler] if customizations[:handler].is_a?(Proc)
+    @processor
+  end
+
+  # prettier print
+  def inspect
+    "#<Raconteur::Processor:0x#{object_id} #{ATTRS.map { |att| "@#{att}=#{@processor.send(att)}" }.join(', ')}>"
+  end
+
+  # piecemeal access and manipulation of processor attributes
+  ATTRS.each do |att|
+    define_method(att) do
+      @data[att]
+    end
+    define_method("#{att}=") do |val|
+      @data[att] = val
+    end
+  end
+
+  # regex for matching tag and its settings
+  def regex
+    /^\s*#{Regexp.quote(@processor.tag)}:?(?<settings>.*?)?\s*$/im
+  end
+
+  # execute the processor
+  def execute(content="", settings={})
+    output = content
+    if self.handler
+      # if the processor has a custom handler, then pass everything to it for processing
+      output = self.handler.call(settings)
+      if output.is_a?(Hash) && self.template
+        # if the handler returns a hash and has a template, then pass the hash as options to the template
+        # (this allows for custom variable setting and overriding before the template is rendered)
+        output = Raconteur::Parse.render_template(self.template, output)
+      end
+    elsif self.template
+      # if there's no handler but there is a processor, simply render the template with the tag's settings
+      output = Raconteur::Parse.render_template(self.template, settings)
+    end
+    output
+  end
+
+end

data/lib/raconteur/setting.rb

@@ -0,0 +1,54 @@
+class Raconteur::Setting
+
+  # scoped
+  def self.scoped(raconteur)
+    @@raconteur = raconteur
+    self
+  end
+
+  # return hash of all settings
+  def self.all
+    @@raconteur.send(:data)[:settings]
+  end
+
+  # revert the settings of this Raconteur instance to the current default settings for Raconteur
+  def self.revert_to_defaults!
+    self.all.delete_if { true }.merge!(Marshal.load(Marshal.dump(Raconteur::Config.default_settings)))
+    self
+  end
+
+  # revert the settings of this Raconteur instance to the original default settings of Raconteur
+  def self.revert_to_original_defaults!
+    self.all.delete_if { true }.merge!(Marshal.load(Marshal.dump(Raconteur::Config.original_default_settings)))
+    self
+  end
+
+  # piecemeal access and manipulation of settings
+  Raconteur::Config.default_settings.keys.each do |att|
+    define_singleton_method(att) do
+      all[att]
+    end
+    define_singleton_method("#{att}=") do |val|
+      all[att] = val
+    end
+  end
+
+  # print hash
+  def self.inspect
+    "#{all} (Raconteur::Setting hash)"
+  end
+
+  # treat class as hash
+  def self.method_missing(method_sym, *arguments, &block)
+    if !arguments.empty? && block_given?
+      all.send(method_sym, *arguments, &block)
+    elsif !arguments.empty?
+      all.send(method_sym, *arguments)
+    elsif block_given?
+      all.send(method_sym, &block)
+    else
+      all.send(method_sym)
+    end
+  end
+
+end

data/lib/raconteur/version.rb

@@ -0,0 +1,3 @@
+class Raconteur
+  VERSION = "0.1.0"
+end

data/raconteur.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'raconteur/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "raconteur"
+  spec.version       = Raconteur::VERSION
+  spec.authors       = ["Jamie Appleseed"]
+  spec.email         = ["jamieappleseed@gmail.com"]
+
+  spec.summary       = %q{Custom text tag parsing}
+  spec.description   = %q{Define custom text tags and have Raconteur parse them as per your specifications}
+  spec.homepage      = "https://github.com/JamieAppleseed/raconteur"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-minitest"
+  spec.add_development_dependency "kramdown"
+
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: raconteur
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jamie Appleseed
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-11-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: kramdown
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Define custom text tags and have Raconteur parse them as per your specifications
+email:
+- jamieappleseed@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/raconteur.rb
+- lib/raconteur/config.rb
+- lib/raconteur/parse.rb
+- lib/raconteur/processor.rb
+- lib/raconteur/setting.rb
+- lib/raconteur/version.rb
+- raconteur.gemspec
+homepage: https://github.com/JamieAppleseed/raconteur
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: Custom text tag parsing
+test_files: []