alongslide 0.9.0

data/README.md

@@ -0,0 +1,118 @@
+# Alongslide
+
+Alongslide is a layout engine extending Markdown syntax.
+
+It was developed by [Triple Canopy](http://canopycanopycanopy.com/) as a
+text-editable yet sophisticated platform for producing long-form reading
+content on the web.
+
+Try the demo at [alongslide.com](http://alongslide.com) or [read some theory](http://canopycanopycanopy.com/contents/announcing_alongslide) underlying the project.
+
+## Dependencies
+
+The Ruby backend uses Redcarpet to extract layout directives from the
+Markdown, Treetop to parse their grammar, and HAML to render them into
+templates.
+
+The CoffeeScript/SASS frontend then scan the resulting HTML for layout
+cues, using Adobe's CSS Regions polyfill to flow the body text, and
+skrollr to build transition animations and respond to user scrolling.
+
+*Copyright 2013 Canopy Canopy Canopy, Inc.*
+
+## Syntax
+
+Alongslide blocks override the normal Markdown behavior for code blocks.
+Any text indented by four spaces will be handled by Alongslide.
+
+Within these blocks, special directives indicate which templates to render.
+Directives begin with a plus sign.
+
+For example:
+
+```
+Flowing paragraph text...
+
+	+ panel BigPanel fullscreen
+	
+	# Huge text in a huge panel.
+	
+Flowing paragraph text continues...
+
+```
+
+## Adding templates
+
+Templates are in `views/`. While basic `panel` and `section` templates are closely wedded to the frontend parser, panel templates may contain other templates, which are preloaded from `panel/content/`.
+
+### Nesting templates
+
+Each template begins with Middleman-style YAML frontmatter. Currently only one value is read: `greedy`, which refers to whether the template may contain other templates or not. If `true`, the template represents a
+greedy node, and can contain other templates; if `false`, it is
+non-greedy, and therefore cannot contain other templates.
+
+For example:
+
+```
+Flowing paragraph text...
+
+	+ panel GalleryPanel fullscreen
+	
+	+ gallery
+	
+	+ image url "/one.jpg"
+
+	+ image url "/two.jpg"	
+
+Flowing paragraph text continues...
+
+```
+
+In the above example, the two (nongreedy) `image` templates will both be
+contained by the `gallery` template (greedy), which in turn will be contained by the `panel` template (greedy).
+
+### Template parameters
+
+The syntax parser accepts arbitrary key/value pairs for templates, which are handed as they are to the HAML engine.
+
+Nongreedy templates additionally consume any arbitrary Markdown which appears
+below them.
+
+For example:
+
+```
+    + image url "/one.jpg" position top opacity 0.5 note "A \"nice\" note"
+    
+    Caption for _A Very Nice Image_.
+
+```
+
+In the above example, the `image.haml` template would receive variables for `url`, `position`, `opacity`, and `note`—in addition to a variable called `content`, which would contain the rendered HTML from the Markdown caption below.
+
+Each inline parameter value may optionally be enclosed in double quotation marks, with space and backslash-escaped quotes inside.
+
+## Adding panel parameters
+
+To add functionality to the system, follow the path through the full stack,
+from back to front:
+
+1. Add appropriate rules to `panel_params` in `panel.treetop` (consult [Treetop documentation](http://treetop.rubyforge.org/syntactic_recognition.html) for syntax)
+* Write tests for parsing the new rules in `parser_spec.rb`
+* Make sure the appropriate `SyntaxNode` subclass (defined in `parser.rb`) puts the Treetop data into the correct param for the template (`panel.haml`). By default, it'll just lump it in as a CSS class.
+* Add logic to parse the param in `checkForDirectives()` in `alongslide.coffee` adding CSS rules as necessary in `alongslide.sass`
+
+## Layout Engine
+
+On the front end, a layout engine written in CoffeeScript parses the layout cues (typically `<div>`s with special meta CSS classes) and renders the content as overlapping horizontally-scrolling **frames** (where one frame is one screen width).
+
+### Process
+
+1. **Pull panels out of flowing body text.** Alongslide supports flowing body text and **panels**, which behave like sidebars. In this step, pull those panels out, and index them by ID, to be displayed later.
+* **Separate sections.** Because Alongslide follows the CSS Regions specification, multiple text sections may not flow from a single "source" in the DOM. In this step, break up the single source element into the appopriate number of DOM elements, and register each as the source for a single NamedFlow, using CSS Regions JS integration.
+* **Lay out.** Iterate through the NamedFlows (and their respective sections), creating flowing **columns** (and their respective **frames**) one at a time, checking each for relevant cues about panel placement. If a panel directive is found, ensure that the panel appears and is dismissed at the correct points in the piece, and that the flowing text wraps around it (by applying CSS classes). In this step, each frame, whether flowing, panel, or section background, is assigned temporary DOM `data-` attributes (`alongslide-show-at` and `alongslide-hide-at`), to be parsed in the next step.
+* **Apply scroll transitions.** Once the positioning of every frame has been decided, convert all of the temporary `data-` attributes to specific skrollr transitions, which may scroll, fade, etc.
+* **Clean up**. Currently, this just entails resizing the frame container to fit total width of the frames (so that the scroll bar is proportional).
+
+### CSS Regions
+
+As the CSS Regions specification is under active development, Alongslide does not rely on correct browser implementation. Instead, it forces all browsers to use the Adobe polyfill. (And will continue to until the spec is firmed up.)

data/Rakefile

@@ -0,0 +1,5 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/alongslide/engine.rb

@@ -0,0 +1,10 @@
+# Tell Rails to check for assets and views here.
+# 
+# http://guides.rubyonrails.org/asset_pipeline.html#adding-assets-to-your-gems
+# 
+require 'rails'
+
+module Alongslide
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/alongslide/redcarpet/render.rb

@@ -0,0 +1,28 @@
+# 
+# render.rb: Extend Redcarpet renderer with Alongslide syntax.
+# 
+# Good resource for extending Redcarpet:
+# http://dev.af83.com/2012/02/27/howto-extend-the-redcarpet2-markdown-lib.html
+# 
+# Copyright 2013 Canopy Canopy Canopy, Inc.
+# Author Adam Florin
+# 
+require 'redcarpet'
+
+module Redcarpet
+  module Render
+    class Alongslide < HTML
+
+      # Run through all indented blocks (normally treated as code blocks)
+      # for Alongslide block definitions.
+      # 
+      # @param text is raw Markdown
+      # @param language is ignored
+      # 
+      def block_code(text, language)
+        ::Alongslide::render_block text
+      end
+
+    end
+  end
+end

data/lib/alongslide/syntax_error.rb

@@ -0,0 +1,11 @@
+# 
+# Custom exception class for caller to rescue.
+# 
+# Copyright 2013 Canopy Canopy Canopy, Inc.
+# Author Adam Florin
+# 
+
+module Alongslide
+  class SyntaxError < Exception
+  end
+end

data/lib/alongslide/templates.rb

@@ -0,0 +1,123 @@
+# 
+# templates.rb: load and parse HAML templates (with Middleman-style YAML
+# frontmatter).
+# 
+# Copyright 2013 Canopy Canopy Canopy, Inc.
+# Author Adam Florin
+# 
+
+module Alongslide
+  module Templates
+
+    # Template paths.
+    # 
+    # A minimum of templates are bundled with the gem.
+    # 
+    # The rest are provided by the user, and stored elsewhere.
+    # 
+    @@TEMPLATE_DIR = File.expand_path("../../app/views", File.dirname(__FILE__))
+    @@user_template_dir = nil
+
+    # Names of user templates, sorted by type.
+    # 
+    @@template_names = {}
+
+
+    @@locals = {}
+
+    class << self
+
+      # 
+      # 
+      def configure
+        yield self
+      end
+
+      # Scan user templates and populate list of names to be used by
+      # Treetop grammar to validate Alongslide directives.
+      # 
+      def scan_user_templates
+        if @@user_template_dir
+          @@template_names = {greedy: [], nongreedy: [], independent: []}
+          Dir.glob(File.join @@user_template_dir, "*.haml") do |filename|
+            name = File.basename filename, ".haml"
+            params, template = load name, true
+            greediness = params["greedy"] ? :greedy : :nongreedy
+            @@template_names[greediness] << name
+            @@template_names[:independent] << name if params["independent"]
+          end
+        end
+      end
+
+      # Load template, which consists of HAML + Middleman-style frontmatter.
+      # 
+      # @param is_user_template - true if requested template is user-generated,
+      #   not one of the basic bundled ones.
+      # 
+      # @return template_params (hash), raw HAML template
+      # 
+      def load(name, is_user_template = false)
+        template = IO.read(template_path(name, is_user_template))
+        yaml, haml = split_frontmatter(template)
+        params = YAML.load yaml
+        return params, haml
+      end
+
+      # Do HAML render.
+      # 
+      # Use ActionView instead of Haml::Engine because we need our Rails helpers.
+      # 
+      def render_template(name, is_user_template, render_params)
+        template_params, haml = load(name, is_user_template)
+        renderer.render(
+          inline: haml,
+          type: :haml,
+          locals: render_params.merge(@@locals))
+      end
+
+      # Filesystem utility
+      # 
+      def template_path(name, is_user_template)
+        template_dir = is_user_template ? @@user_template_dir : @@TEMPLATE_DIR
+        File.join template_dir, "#{name}.haml"
+      end
+
+      # HAML templates use Middleman-style YAML frontmatter. Separate it out.
+      # 
+      def split_frontmatter(text)
+        text.split("---\n").reject(&:empty?)
+      end
+
+      # Set config value, then reset cache.
+      # 
+      def user_template_dir=(user_template_dir)
+        @@user_template_dir = user_template_dir
+        scan_user_templates
+      end
+
+      # Set config value, then reset cache.
+      # 
+      def locals=(locals)
+        @@locals = locals
+      end
+
+      # Return an ActionView instance with helpers monkeypatched in.
+      # 
+      # https://gist.github.com/aliang/1022384
+      # 
+      def renderer
+        action_view = ActionView::Base.new(Rails.configuration.paths["app/views"])
+        action_view.class_eval do 
+          include Rails.application.routes.url_helpers
+          include ApplicationHelper
+
+          def protect_against_forgery?
+            false
+          end
+        end
+        return action_view
+      end
+    end
+
+  end
+end

data/lib/alongslide/treetop/parser.rb

@@ -0,0 +1,152 @@
+# 
+# parser.rb: Bootstrap templating engine using Treetop syntax.
+# 
+# Copyright 2013 Canopy Canopy Canopy, Inc.
+# Author Adam Florin
+# 
+require 'polyglot'
+require 'treetop'
+
+# Init
+# 
+Treetop.load File.expand_path("../../../grammar/panel", File.dirname(__FILE__))
+Treetop.load File.expand_path("../../../grammar/alongslide", File.dirname(__FILE__))
+
+module Treetop
+  module Runtime
+
+    # Root node of parse tree.
+    # 
+    class RootNode < SyntaxNode
+
+      # Render tree to HTML.
+      # 
+      def render
+        blocks.elements.map do |block_wrapper|
+          if block_wrapper.content.respond_to? :block
+            block_wrapper.content.block.render
+          elsif block_wrapper.content.respond_to? :template
+            block_wrapper.content.template.render
+          end
+        end.join
+      end
+    end
+
+    # Template node base class. Covers panels, panel templates, sections.
+    # 
+    class TemplateNode < SyntaxNode
+
+      # Load template and render it, with content, if applicable.
+      # 
+      def render
+        ::Alongslide::Templates::render_template template_name, is_user_template, render_params
+      end
+
+      # Sections and panels optionally implement generic "class_params",
+      # as well as required identifier.
+      # 
+      def render_params
+        params = {content: template_content || []}
+
+        classes = if respond_to? :class_params
+          class_params.elements.map do |item|
+            item.param.text_value
+          end
+        end
+        params[:classes] = (classes || []).join(" ")
+
+        if respond_to? :identifier
+          params[:identifier] = identifier.text_value
+        end
+
+        return params
+      end
+
+      # Template named in directive is what to look for in filesystem.
+      # 
+      def template_name
+        command.text_value
+      end
+
+      # If Node has "contents", prepare content for template's variable of the
+      # same name.
+      # 
+      # This may mean rendering another subtemplate, or simply some Markdown.
+      # 
+      def template_content
+        if respond_to? :contents and contents
+          contents.elements.map do |item|
+            if item.content.respond_to? :template
+              item.content.template.renderable.template.render
+            else
+              ::Alongslide::render item.text_value, plain: true
+            end
+          end
+        end
+      end
+
+      # Default.
+      # 
+      def is_user_template
+        false
+      end
+    end
+
+    # Panel.
+    # 
+    class PanelNode < TemplateNode
+      def template_name
+        "panel/#{super}"
+      end
+    end
+
+    # Templates which go inside panels.
+    # 
+    class UserTemplateNode < TemplateNode
+
+      # Params for panel content template.
+      # 
+      # Key/value pairs.
+      # 
+      # If value is a quoted string, strip quotes.
+      # 
+      def render_params
+        params = {}
+        if respond_to? :template_params
+          template_params.elements.map do |item|
+            key = item.param.key.text_value
+            value = item.param.value.text_value
+            params[key.to_sym] = unquote value
+          end
+        end
+        super.merge params
+      end
+
+      # 
+      # 
+      def is_user_template
+        true
+      end
+
+      private
+
+        # If string is quoted, unquote.
+        # 
+        def unquote(string)
+          if string =~ /^"/
+            string.gsub!(/^"|"$/, '').gsub(/\\"/, '"')
+          else
+            string
+          end
+        end
+    end
+
+    # A section is a block of flowing text.
+    # 
+    class SectionNode < TemplateNode
+      def template_name
+        "section/#{super}"
+      end
+    end
+  end
+end

data/lib/alongslide.rb

@@ -0,0 +1,81 @@
+# 
+# alongslide-redcarpet.rb: top-level bindings and entrypoint for Redcarpet
+# and Treetop.
+# 
+# Copyright 2013 Canopy Canopy Canopy, Inc.
+# Author Adam Florin
+# 
+require 'yaml'
+require 'haml'
+require "alongslide/engine"
+require "alongslide/templates"
+require "alongslide/redcarpet/render"
+require "alongslide/treetop/parser"
+require "alongslide/syntax_error"
+
+module Alongslide
+  @@parser = nil
+
+  class << self
+
+    # Accept configuration from initializer.
+    # 
+    def configure(&block)
+      Templates.configure &block
+    end
+
+    # Render HTML from Markdown.
+    # 
+    # @option locals - if present, stash locals in class config static variable.
+    #   NOTE! This is not threadsafe. but fine for general usage.
+    # @option plain - use secondary plain renderer
+    # 
+    def render(markdown, options={})
+      unless options[:locals].nil?
+        Templates.configure do |config|
+          config.locals = options[:locals]
+        end
+      end
+
+      (options[:plain] ? plain_renderer : renderer).render markdown
+    end
+
+    # Get Redcarpet renderer, init'ing if necessary.
+    # 
+    def renderer
+      Redcarpet::Markdown.new(Redcarpet::Render::Alongslide, :footnotes => true)
+    end
+
+    # Plain vanilla renderer for the Markdown blocks extracted by the first
+    # renderer. (Can't call render() on a renderer in the middle of rendering,
+    # or you'll get Abort Traps.)
+    # 
+    def plain_renderer
+      Redcarpet::Markdown.new Redcarpet::Render::HTML
+    end
+
+    # Get Treetop parser, init'ing if necessary.
+    # 
+    def parser
+      @@parser ||= Grammar::RootParser.new
+    end
+
+    # Given an indented block of Alongslide-flavored Markdown, parse and return
+    # rendered HTML including appropriate templates.
+    # 
+    # @param markdown raw Markdown containing directives and raw text.
+    # 
+    # @return HTML for display
+    # 
+    def render_block(markdown)
+      rootNode = parser.parse(markdown)
+      if rootNode
+        return rootNode.render
+      else
+        error_line = markdown.split("\n")[parser.failure_line-1]
+        raise SyntaxError.new "Alongslide syntax error around: \"#{error_line}\""
+      end
+    end
+
+  end
+end

data/lib/generators/alongslide_generator.rb

@@ -0,0 +1,13 @@
+# 
+# alongslide_generator.rb: Generate (copy) initializer for Rails app.
+# 
+# Copyright 2013 Canopy Canopy Canopy, Inc.
+# 
+
+class AlongslideGenerator < Rails::Generators::Base
+  source_root File.expand_path('../templates', __FILE__)
+
+  def copy_initializer_file
+    copy_file "alongslide.rb", "config/initializers/alongslide.rb"
+  end
+end

data/lib/generators/templates/alongslide.rb

@@ -0,0 +1,9 @@
+# 
+# alongslide.rb: Rails initializer for Alongslide Engine
+# 
+# Copyright 2013 Canopy Canopy Canopy, Inc.
+# 
+
+Alongslide.configure do |config|
+  config.user_template_dir = Rails.root.join("app/views/alongslide")
+end

data/spec/alongslide_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Alongslide do
+
+  describe "rendering" do
+    it "should render a whole document" do
+      html = Alongslide::render <<-MARKDOWN.strip_heredoc
+            + panel AnyPanel fullscreen
+
+        Body text.
+      MARKDOWN
+      html.should_not be_nil
+    end
+
+    it "should gracefully catch ALS syntax errors" do
+      expect {
+        Alongslide::render <<-MARKDOWN.strip_heredoc
+              + bogus
+
+          Body text.
+        MARKDOWN
+      }.to raise_error Alongslide::SyntaxError
+    end
+  end
+
+end

data/spec/fixtures/gallery.haml

@@ -0,0 +1,6 @@
+---
+greedy: true
+---
+.gallery
+  - for item in content
+    .item= item

data/spec/fixtures/image.haml

@@ -0,0 +1,9 @@
+---
+greedy: false
+---
+- url ||= ""
+- alt ||= ""
+- content ||= ""
+.image
+  %img{src: url, alt: alt}
+  .caption= content.join

data/spec/redcarpet/render_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Redcarpet::Render::Alongslide do
+  
+  before :all do
+    @markdown = Redcarpet::Markdown.new Redcarpet::Render::Alongslide
+  end
+
+  it "passes text through" do
+    @markdown.render("# Sweet jubilation").should be_a(String)
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require 'alongslide'
+
+# ActiveSupport monkeypatch modified to work with few requires.
+# 
+# http://apidock.com/rails/String/strip_heredoc
+# 
+class String
+  def strip_heredoc
+    indent = scan(/^[ \t]*(?=\S)/).min.send(:size) || 0
+    gsub(/^[ \t]{#{indent}}/, '')
+  end
+end

data/spec/treetop/parser_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe Alongslide::Grammar::RootParser do
+  
+  before :all do
+    Alongslide.configure do |config|
+      config.user_template_dir = File.expand_path("../fixtures", File.dirname(__FILE__))
+    end
+
+    @parser = Alongslide::Grammar::RootParser.new
+    @panel_name = "SomePanel"
+    @section_name = "SomeSection"
+  end
+
+  describe "panels" do
+    it "should show and unpin" do
+      parsed = @parser.parse <<-MARKDOWN.strip_heredoc
+        + panel #{@panel_name} pin bottom
+
+        + unpin #{@panel_name}
+      MARKDOWN
+      parsed.should_not be_nil
+      parsed.render.should include(@panel_name)
+    end
+
+    it "should support templateless panels" do
+      panel_text = "Some text directly in the panel."
+      parsed = @parser.parse <<-MARKDOWN.strip_heredoc
+        + panel #{@panel_name}
+
+        #{panel_text}
+      MARKDOWN
+      parsed.should_not be_nil
+      parsed.render.should include(panel_text)
+    end
+
+    describe "parameters" do
+      it "should pin" do
+        parsed = @parser.parse <<-MARKDOWN.strip_heredoc
+          + panel #{@panel_name} pin left
+        MARKDOWN
+        parsed.should_not be_nil
+        parsed.render.should_not be_nil
+      end
+
+      it "should fullscreen" do
+        parsed = @parser.parse <<-MARKDOWN.strip_heredoc
+          + panel #{@panel_name} fullscreen
+        MARKDOWN
+        parsed.should_not be_nil
+        parsed.render.should_not be_nil
+      end
+
+      it "should pin and fade" do
+        parsed = @parser.parse <<-MARKDOWN.strip_heredoc
+          + panel #{@panel_name} pin top fade-in
+        MARKDOWN
+        parsed.should_not be_nil
+        parsed.render.should_not be_nil
+      end
+    end
+
+    describe "panel templates" do
+      it "should nest templates within greedy templates" do
+        parsed = @parser.parse <<-MARKDOWN.strip_heredoc
+          + panel #{@panel_name}
+
+          + gallery
+
+          + image
+        MARKDOWN
+        parsed.should_not be_nil
+        parsed.render.should include("gallery")
+      end
+
+      it "should treat nongreedy templates as siblings" do
+        parsed = @parser.parse <<-MARKDOWN.strip_heredoc
+          + panel #{@panel_name}
+
+          + image
+
+          + image
+        MARKDOWN
+        parsed.should_not be_nil
+        parsed.render.should include("image")
+      end
+
+      it "should support nongreedy template (multiline) text contents" do
+        text_contents = "Some Text Contents"
+        parsed = @parser.parse <<-MARKDOWN.strip_heredoc
+          + panel a
+
+          + image
+
+          #{text_contents}
+          #{text_contents}
+        MARKDOWN
+        parsed.should_not be_nil
+        parsed.render.should include(text_contents)
+      end
+
+      it "should support template parameters" do
+        url = "http://some-image.com/over_there.jpg?q=999"
+        alt_text = "Some \\\"alternate\\\" text."
+        parsed = @parser.parse <<-MARKDOWN.strip_heredoc
+          + panel a
+
+          + image url "#{url}" alt "#{alt_text}"
+        MARKDOWN
+        parsed.should_not be_nil
+        parsed.render.should include(url)
+        parsed.render.should include(alt_text.gsub(/\\"/, '"'))
+      end
+    end
+  end
+
+  describe "sections" do
+    it "should enter and exit" do
+      parsed = @parser.parse <<-MARKDOWN.strip_heredoc
+        + section #{@section_name}
+
+        + exit #{@section_name}
+      MARKDOWN
+      parsed.should_not be_nil
+      parsed.render.should include(@section_name)
+    end
+
+    it "should support transitions" do
+      valid_transition_class = "fade-in"
+      parsed = @parser.parse <<-MARKDOWN.strip_heredoc
+        + section #{@section_name} #{valid_transition_class}
+      MARKDOWN
+      parsed.should_not be_nil
+      parsed.render.should include(valid_transition_class)
+    end
+  end
+
+  describe "bad syntax" do
+    it "should catch bad syntax" do
+      parsed = @parser.parse <<-MARKDOWN.strip_heredoc
+        + bogus
+      MARKDOWN
+      parsed.should be_nil
+    end
+  end
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: alongslide
+version: !ruby/object:Gem::Version
+  version: 0.9.0
+  prerelease: 
+platform: ruby
+authors:
+- Adam Florin
+- Anthony Tran
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: treetop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: polyglot
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Create dynamic web layouts with an extended Markdown syntax
+email: adam@canopycanopycanopy.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- lib/alongslide/engine.rb
+- lib/alongslide/redcarpet/render.rb
+- lib/alongslide/syntax_error.rb
+- lib/alongslide/templates.rb
+- lib/alongslide/treetop/parser.rb
+- lib/alongslide.rb
+- lib/generators/alongslide_generator.rb
+- lib/generators/templates/alongslide.rb
+- spec/alongslide_spec.rb
+- spec/fixtures/gallery.haml
+- spec/fixtures/image.haml
+- spec/redcarpet/render_spec.rb
+- spec/spec_helper.rb
+- spec/treetop/parser_spec.rb
+- README.md
+homepage: http://github.com/triplecanopy
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Create dynamic web layouts with an extended Markdown syntax
+test_files: []