pasta 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2c8fdd32cce14e905c1580e6af1c06da7d2f59a0
+  data.tar.gz: b005f8e3e02b5bd0535e6280fb8394341d5df30f
+SHA512:
+  metadata.gz: b8ba1e99b022691f6552459d2a4031384077b831834de4dd19dbbfc940aa9978ab8beef93be68ba5f94479d843e0ba9df78a1f67837224f69f400ea7ed19343a
+  data.tar.gz: fad438c988da4bb8c0987e9276b68a6c0e89748dcef143662e456cb8fd8802d35faed0bc35097426cde031e49ad18150d327c44b3d0bd81464ad8939907fe9dd

data/.gitignore

@@ -0,0 +1,19 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.DS_Store
+*/.DS_Store

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Dave Kinkead
+
+MIT License
+
+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,57 @@
+# Pasta
+
+### À la carte markdown parsing.
+
+There's no such thing as markdown, only markdowns.  Multi-Markdown, Github Flavoured, Pandoc, or Stack Overflow style...each implementation makes subtle changes to Gruber's original in order to better address the needs of their users.  
+
+It might be nice to have one true standard but that just ain't gonna happen.  And it shouldn't.  One of the great strengths of writing in plain text is that it can easily be adapted to specific needs through different flavours or dialects.
+
+Pasta allows you to choose the flavour of markdown that best meets your needs, or to whip a new one up as needed.
+
+## Ingredients
+
+- 1 pasta gem
+- A handful of text
+- A sprig of file references
+
+## Directions
+
+Ensure your pasta gem is ready to go with
+    
+    $ gem install pasta
+
+Then use Pasta as a tasty addition to your ruby code:
+
+    Pasta.prepare('a handful of text').with(:markdown).make(:html)
+    
+Alternatively, you can use Pasta as a binary:
+
+    $ pasta a-tasty-file.txt --recipe gruber
+
+## Recipes
+
+Choose a recipe from the menu or make your own - extensibility is Pasta's _raison d'être_. 
+
+- **Gruber** The original but rarely the best.
+- **Markdown** The default according to the http://www.w3.org/community/markdown/ spec
+
+## Works in Progress
+
+- **Github** Github flavoured markdown.
+- **Latin** Markdown for scholars.
+- **Reveal** Generate slide decks from markdown.  
+
+## Rolling your own
+
+Creating your own recipe for a markdown flavour is simple.  First up, write a test suite for your recipe and add it to the `specs` directory.  Use the yaml format like the others.
+
+Next, extend `Pasta::Recipe::Base` and use the DSL to declare your recipe's `grammar`.  For example:
+
+    grammar(:html) { [:headings, :paragraphs] }
+    grammar(:pdf)  { [:meta, :headings, :paragraphs] }
+    
+Each grammar rule creates a `to_x` method and invokes the code in `Pasta::Ingredients` of the same name.  You can either create your own ingredients or use existing ones. Extensibility is the name of the game here. 
+
+Grammars are order sensitive and use a depth-first strategy allowing you to nest rules.  
+
+Finally, add your recipe to the `Pasta::Menu` so in order to create a delicious new `Pasta::Dish`.

data/Rakefile

@@ -0,0 +1,9 @@
+#require "bundler/gem_tasks"
+require 'rake'
+
+task default: [:specs]
+
+namespace :specs do
+  $LOAD_PATH.unshift('lib', 'specs')
+  Dir.glob('specs/**/*spec.rb').each { |file| require_relative file }
+end

data/bin/pasta

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'pasta'
+
+options = {recipe: :gruber, output: :html}
+
+OptionParser.new do |opts|
+  opts.banner = "Usage: pasta [sauce] [options]"
+  opts.summary_indent = ' '*4
+  
+  opts.separator ""
+  opts.separator "The Pasta Menu:"
+  opts.separator ""
+  
+  opts.on("-h", "--help", "Show the menu") do
+    p opts.summarize('', 5, 72)
+    exit
+  end
+  
+  opts.on("-v", "--version", "Show the version") do
+    p Pasta::VERSION
+    exit
+  end
+  
+  opts.on("-r", "--recipe [RECIPE]", String, "Specify a recipe") do |recipe|
+    options[:recipe] = recipe.to_sym
+  end
+  
+end.parse!
+
+begin
+  while ARGV.length > 1
+    ARGV.pop
+  end
+  p Pasta.prepare(ARGF.read).with(options[:recipe]).make(:html)
+rescue Pasta::Error => e
+  $stderr.puts "Error: #{e.message}"
+  exit(1)
+end

data/lib/pasta.rb

@@ -0,0 +1,18 @@
+require 'pasta/dish'
+
+module Pasta
+  
+  # Public: Instantiates a new Pasta::Dish object with text to be parsed.
+  #
+  # sauce - the text to be parsed
+  #
+  # Example:
+  #
+  #   Pasta.prepare 'some yummy text'
+  #   # => #<Pasta::Dish:0x007ff232948938>
+  #
+  # Returns a Pasta::Dish
+  def self.prepare(sauce)
+    Pasta::Dish.new sauce
+  end
+end

data/lib/pasta/cookbook.rb

@@ -0,0 +1,13 @@
+require 'pasta/version'
+require 'pasta/error'
+
+module Pasta
+  module Recipes
+
+    autoload :Base,     'pasta/recipes/base'      # The granddaddy of them all. All recipes should extend Base
+    autoload :Gruber,   'pasta/recipes/gruber'    # The original but rarely the best
+    autoload :Markdown, 'pasta/recipes/markdown'  # Markdown as per the http://www.w3.org/community/markdown/ spec
+  
+  end
+end
+    

data/lib/pasta/dish.rb

@@ -0,0 +1,62 @@
+require 'pasta/cookbook'
+
+module Pasta
+  class Dish
+    
+    # Public: The source document that will be the subject of parsing.
+    attr_reader :sauce
+    
+        
+    # Public: Creates a new Pasta::Dish.
+    #
+    # sauce - The String document to be parsed. Required
+    #
+    # Example
+    #   Pasta::Dish.new 'Some yummy text to parse'
+    #
+    # Returns a new Pasta::Dish.
+    def initialize(sauce)
+      @sauce = sauce
+      @recipe = Pasta::Recipes::Markdown.new
+    end
+    
+    
+    # Public: Looks up a recipe from the menu
+    #
+    # recipe - A Symbol specifying the recipe to use when parsing and outputing
+    # 
+    # Example
+    #   with(:markdown)
+    #
+    # Returns Self
+    def with(recipe)
+      @receipe = check_cookbook_for recipe
+      self
+    end
+    
+    
+    # Public.  Converts the sauce to an output according to a recipe.  Raises a Pasta::Error is the recipe
+    #   doesn't have a to_x method
+    # 
+    # Example
+    #   make(:html)
+    #   # => '<p>....</p>'
+    #
+    # Returns a String of the converted root
+    def make(output)
+      @recipe.send "to_#{output}", @sauce
+    end
+    
+    
+    private 
+    
+    
+    # Private. Checks the cookbook for a recipe, raising an error if not found.
+    #
+    # Returns the @recipe
+    def check_cookbook_for recipe
+      raise Pasta::Error.new "Recipe '#{recipe}' wasn't found in the cookbook" unless Recipes.const_defined? "#{recipe.to_s.capitalize}"
+      Recipes.const_get("#{recipe.to_s.capitalize}").new
+    end
+  end
+end

data/lib/pasta/error.rb

@@ -0,0 +1,3 @@
+module Pasta
+  class Error < RuntimeError; end
+end

data/lib/pasta/ingredients.rb

@@ -0,0 +1,49 @@
+module Pasta
+  module Ingredients     
+
+    def self.included(base)
+      base.extend ClassMethods
+    end
+       
+    # Public. Returns the grammars of a recipe
+    # 
+    # name - the name of a grammar rule as a Symbol
+    #
+    # Example
+    #   grammars(:html)
+    #   # => <Proc:>
+    #
+    # Returns a Proc containing grammar rules
+    def grammars(name=nil)
+      return name.nil? ? self.class.grammars : self.class.grammars[name]
+    end 
+
+    module ClassMethods    
+      @@grammars = {}
+      
+      def grammars
+        @@grammars
+      end
+         
+      # Public. The DSL for declaring grammar rules in a recipe.
+      #
+      # Recipes contain grammars that are defined in ordered arrays. Grammars are recursively matched in a top down
+      #   fashion where the array elements match ingredients.  Grammar matching is done on a first match basis so that
+      #   the last rule can be a catch-all one.
+      #
+      # name  - a Symbol naming the grammar
+      # rules - a block defining the grammar
+      #
+      # Example
+      #   grammar(:html)       { [:blockquotes, :paragraphs] }
+      #   grammar(:blockquote) { [:blockquote, :paragraphs] }
+      #   grammar(:paragraph)  { [:links, :emphasis, :bold, :text] }
+      #
+      # Returns nothing
+      def grammar(name, &rules)
+        rules.call.each { |rule| require "pasta/ingredients/#{rule.to_s}" }
+        @@grammars[name] = rules.call
+      end
+    end
+  end
+end

data/lib/pasta/ingredients/anything.rb

@@ -0,0 +1,12 @@
+module Pasta
+  module Ingredients
+   
+    ANYTHING = /(.+)/
+    
+    def anything(text,html)
+      p text
+      html << text
+      [text,html]
+    end
+  end
+end

data/lib/pasta/ingredients/atx_headings.rb

@@ -0,0 +1,21 @@
+module Pasta
+  module Ingredients
+              
+    ATX_HEADING     = /\A(\#{1,6})(.+?)\#*($|\z)/
+    
+    def atx_headings(text, html)   
+      text.sub!(ATX_HEADING) do |match| 
+        inner = $2
+        if grammars.key? :heading
+          grammars[:heading].each do |rule|
+            inner, text = send(rule, $2, '')
+          end
+        end
+        html << "<h#{$1.length}>#{inner.strip}</h#{$1.length}>\n" unless $2.nil?
+        match = ''
+      end
+      [text, html]
+    end
+    
+  end
+end

data/lib/pasta/ingredients/automatic_links.rb

@@ -0,0 +1,14 @@
+module Pasta
+  module Ingredients
+     
+    AUTOMATIC_LINKS = /(?<!\]: )<(.+?):\/\/(.+?)>/
+    
+    def automatic_links(text, html)
+      text.gsub!(AUTOMATIC_LINKS) do |match|
+        url = "#{$1}://#{$2}"
+        match = "<a href=\"#{url}\">#{url}</a>"
+      end
+      [text, html]
+    end
+  end
+end

data/lib/pasta/ingredients/blockquotes.rb

@@ -0,0 +1,23 @@
+module Pasta
+  module Ingredients
+    
+    BLOCKQUOTE = /\A {0,3}(>.+?)(^\s*[\n\r]|\z)/m 
+    
+    def blockquotes(text, html)
+      text.sub!(BLOCKQUOTE) do |match|
+        inner_text, inner_html = $1, ''
+        inner_text.gsub!(/^>/, '')
+        while inner_text != '' do
+          if grammars.key? :blockquotes
+            grammars[:blockquotes].each do |rule|
+              inner_text, inner_html = send(rule, inner_text, inner_html)
+            end
+          end
+        end
+        html << "<blockquote>\n#{inner_html.strip}\n</blockquote>\n\n"
+        match = ''
+      end
+      [text, html]   
+    end
+  end
+end

data/lib/pasta/ingredients/code.rb

@@ -0,0 +1,15 @@
+module Pasta
+  module Ingredients
+   
+    CODE = /(`+)(.+?)\1/
+    
+    def code(text, html)
+      text.gsub!(CODE) do |match|
+        require 'cgi'
+        html = "<code>#{CGI::escapeHTML $2}</code>"
+        match = html
+      end
+      [text, html]
+    end
+  end
+end

data/lib/pasta/ingredients/codeblocks.rb

@@ -0,0 +1,19 @@
+module Pasta
+  module Ingredients
+    
+    CODEBLOCK = /\A( {4,}|\t)(.+?)(^\s{0,3}[\n\r]|\z)/m
+    
+    def codeblocks(text, html)     
+      text.sub!(CODEBLOCK) do |match|
+        require 'cgi'
+        # clean the leading whitespace from the block and escape html
+        new_text = $2
+        new_text.gsub!(/^#{$1}/, '')
+        new_text = CGI::escapeHTML new_text
+        html << "<pre><code>#{new_text}</code></pre>\n\n"
+        match = ''
+      end
+      [text, html]
+    end 
+  end
+end

data/lib/pasta/ingredients/emphasis.rb

@@ -0,0 +1,14 @@
+module Pasta
+  module Ingredients
+    
+    EMPHASIS = /(?!\\)([*_]{1,2})(?!\s)(.+?)(?!\s)(?!\\)\1/
+    
+    def emphasis(text, html)
+      html = text.gsub(EMPHASIS) do |match|
+        tag = $1.length == 1 ? 'em' : 'strong'
+        match = "<#{tag}>#{$2}</#{tag}>"
+      end
+      [text, html]
+    end
+  end
+end