fold 0.5.0

data/README

@@ -0,0 +1,19 @@
+## Collin Miller claims authorship! $$$
+##### MIT license for all Earthlings ***
+#### http://www.opensource.org/licenses/mit-license.php ^^^
+## Martians and Moonlings pay extra ##
+ 
+#### You're in the Fold now! %%%
+
+Inspiration provided by http://haml.hamptoncatlin.com
+
+Example of a Fold language: 
+  http://github.com/collin/lucky7/tree/master/lib/jass.rb
+
+Example written in that mini-language: 
+  http://github.com/collin/lucky7/tree/master/lib/jsspec/example.html.jass
+
+And the rendered output for the html.jass file:
+  http://github.com/collin/lucky7/tree/master/vendor/js_spec/example.spec.html
+
+:D

data/Rakefile.rb

@@ -0,0 +1,46 @@
+require 'rubygems'
+require 'pathname'
+require 'spec'
+
+__DIR__ = Pathname.new(__FILE__).dirname
+
+
+task :default => 'spec:all'
+
+namespace :spec do
+
+  task :prepare do
+    @specs= Dir.glob("#{__DIR__}/rspec/**/*.rb").join(' ')
+  end
+
+  task :all => :prepare do
+    system "spec #{@specs}"
+  end
+  
+  task :doc => :prepare do
+    system "spec #{@specs} --format specdoc"
+  end
+end
+
+task :cleanup do 
+  Dir.glob("**/*.*~")+Dir.glob("**/*~").each{|swap|FileUtils.rm(swap, :force => true)}
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "fold"
+    gemspec.summary = "A toolkit for creating whitespace active mini-languages. Inspired by Haml, light on features."
+    # gemspec.description = "A different and possibly longer explanation of"
+    gemspec.email = "collintmiller@gmail.com"
+    gemspec.homepage = "http://github.com/collin/fold"
+    gemspec.authors = ["Collin Miller"]
+
+    gemspec.add_dependency('ruby2ruby', '1.2.4')
+    gemspec.add_dependency('ParseTree', '3.0.4')    
+    gemspec.add_dependency('metaid', '1.0')    
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.5.0

data/fold.gemspec

@@ -0,0 +1,65 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile.rb, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{fold}
+  s.version = "0.5.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Collin Miller"]
+  s.date = %q{2009-11-28}
+  s.email = %q{collintmiller@gmail.com}
+  s.extra_rdoc_files = [
+    "README"
+  ]
+  s.files = [
+    "README",
+     "Rakefile.rb",
+     "VERSION",
+     "fold.gemspec",
+     "lib/fold.rb",
+     "lib/fold/abstract_fold.rb",
+     "lib/fold/abstract_slice.rb",
+     "lib/fold/engine.rb",
+     "lib/fold/fold_factory.rb",
+     "lib/fold/precompiler.rb",
+     "lib/fold/slice_factory.rb",
+     "rspec/fixtures/fold/empty.target.fold",
+     "rspec/fixtures/fold/fixture.target.fold",
+     "rspec/fold/abstract_fold_spec.rb",
+     "rspec/fold/abstract_slice_spec.rb",
+     "rspec/fold/engine_spec.rb",
+     "rspec/fold/fold_factory_spec.rb",
+     "rspec/fold/precompiler_spec.rb",
+     "rspec/fold/slice_factory_spec.rb",
+     "rspec/fold_spec.rb",
+     "rspec/fold_spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/collin/fold}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{A toolkit for creating whitespace active mini-languages. Inspired by Haml, light on features.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<ruby2ruby>, ["= 1.2.4"])
+      s.add_runtime_dependency(%q<ParseTree>, ["= 3.0.4"])
+      s.add_runtime_dependency(%q<metaid>, ["= 1.0"])
+    else
+      s.add_dependency(%q<ruby2ruby>, ["= 1.2.4"])
+      s.add_dependency(%q<ParseTree>, ["= 3.0.4"])
+      s.add_dependency(%q<metaid>, ["= 1.0"])
+    end
+  else
+    s.add_dependency(%q<ruby2ruby>, ["= 1.2.4"])
+    s.add_dependency(%q<ParseTree>, ["= 3.0.4"])
+    s.add_dependency(%q<metaid>, ["= 1.0"])
+  end
+end
+

data/lib/fold.rb

@@ -0,0 +1,18 @@
+require 'pathname'
+require 'activesupport'
+require 'parse_tree'
+require 'parse_tree_extensions'
+require 'ruby2ruby'
+require 'metaid'
+
+module Fold
+  def self.root
+    @root ||= Pathname.new(__FILE__).dirname.expand_path
+  end
+  require root+'fold/engine'
+  require root+'fold/abstract_fold'
+  require root+'fold/abstract_slice'
+  require root+'fold/fold_factory'
+  require root+'fold/slice_factory'
+  require root+'fold/precompiler'
+end

data/lib/fold/abstract_fold.rb

@@ -0,0 +1,26 @@
+require 'ostruct'
+
+module Fold
+  class AbstractFold < OpenStruct
+    Regex= //
+    def initialize source={}
+      attrs= {
+        :text => '',
+        :children => [],
+        :tabs => -1
+      }.merge(source)
+
+      attrs[:text].gsub! self.class::Regex, '' if self.class.clear_match
+      
+      super attrs
+    end
+    
+    def render
+      text
+    end
+    
+    def render_children
+      children.map{|child| child.render}
+    end
+  end
+end

data/lib/fold/abstract_slice.rb

@@ -0,0 +1,6 @@
+require 'ostruct'
+
+module Fold
+  class AbstractSlice < OpenStruct
+  end
+end

data/lib/fold/engine.rb

@@ -0,0 +1,23 @@
+module Fold
+  class Engine
+    def initialize source
+      @source= source
+    end
+    
+    def lines
+      @source.split(/\n/).reject{|line| line.blank?}
+    end
+    
+    def render context
+      precompiler = precompiler_class.new
+      precompiler.fold(lines).children.map do |child| 
+        child.render(precompiler)
+      end
+    end
+    
+#    *** me hard
+    def precompiler_class
+      @precompiler||= instance_eval "#{self.class.to_s.split(/::/).first}::Precompiler"
+    end
+  end
+end

data/lib/fold/fold_factory.rb

@@ -0,0 +1,70 @@
+module Fold
+  module FoldFactory
+    Indent= 2
+    class IndentationError < StandardError; end
+    
+    def self.included klass
+      klass.extend ClassMethods
+    end
+    
+    def produce line=''
+      tabs = count_soft_tabs(line)
+      line = line.sub(/^[ ]+/, '')
+      attrs= {
+        :text => line, 
+        :tabs => tabs
+      }
+
+# This all happens because I need to access Precompiler attributes
+# from within AbstractFold render methods
+# Pretty much needs a nice refactor, but don't have the time.
+# PS: thx ruby   
+      fold = if klass= detect_class(line)
+        klass.new attrs
+      else
+        AbstractFold.new attrs.merge(:tabs => -1)
+      end
+      
+      instance_variables.each do |var|
+        fold.instance_variable_set var, instance_variable_get(var)
+  
+        fold.metaclass.send :attr_accessor, var.gsub('@', '')
+      end
+      that = self
+      fold.meta_def :method_missing do |meth, *args|
+        return that.send(meth, *args) if that.respond_to?(meth)
+        super
+      end
+
+      fold
+    end
+    
+    def detect_class line
+      return nil if line.blank?
+      self.class.defined_folds.reverse.detect {|fold| fold::Regex and fold::Regex.match(line)}
+    end
+    
+    def count_soft_tabs line
+      spaces= line.index(/([^ ]|$)/)
+      raise IndentationError if spaces.odd?
+      spaces / Indent
+    end
+    
+    module ClassMethods
+      def folds id, regex=AbstractFold::Regex, clear_match=true, &block
+        fold= Class.new(AbstractFold)
+        fold.const_set :Regex, regex
+        
+        fold.send :define_method, :render, &block if block_given?
+        fold.class.send :define_method, :clear_match do; clear_match end
+        
+        const_set id, fold
+        defined_folds << fold
+      end
+      
+      def defined_folds
+        @folds||= []
+      end
+    end
+  end
+end

data/lib/fold/precompiler.rb

@@ -0,0 +1,58 @@
+module Fold
+  class Precompiler
+    include Fold::FoldFactory
+    include Fold::SliceFactory
+  
+    def fold lines
+      last_line= produce
+
+      return last_line if lines.empty?
+
+      parent_line= nil
+      
+      parent_stack= []
+
+      lines.each do |text|
+        line = produce process(text)
+
+        indent = line.tabs - last_line.tabs
+
+        raise IndentationError if indent > 1 
+        
+        if step_in? indent
+          parent_line = last_line
+          parent_line.children << line
+          parent_stack << parent_line
+        end
+      
+        if step_aside? indent
+          parent_line.children << line 
+        end
+        
+        if step_out? indent
+          parent_stack= parent_stack.slice 0, parent_stack.length + indent
+          parent_line = parent_stack.last
+          parent_line.children << line
+        end
+
+        line.parent = parent_line unless parent_line.nil?
+
+        last_line= line
+      end
+      
+      parent_stack.first
+    end
+    
+    def step_in? indent
+      indent == 1
+    end
+    
+    def step_out? indent
+      indent < 0
+    end
+    
+    def step_aside? indent
+      indent == 0
+    end
+  end
+end

data/lib/fold/slice_factory.rb

@@ -0,0 +1,63 @@
+module Fold
+  module SliceFactory
+    def self.included klass
+      klass.extend ClassMethods
+    end
+    
+    def process line=''
+      self.class.defined_slices.each do |slice|
+        line.gsub! slice::Regex do |match|
+          text = $1
+          eval(slice::Block.to_ruby).call
+        end
+      end
+      line
+    end
+
+#     def produce line=''
+# # This all happens because I need to access Precompiler attributes
+# # from within AbstractFold render methods
+# # Pretty much needs a nice refactor, but don't have the time.
+# # PS: thx ruby   
+#       fold = if klass= detect_class(line)
+#         klass.new attrs
+#       else
+#         AbstractFold.new attrs.merge(:tabs => -1)
+#       end
+#       
+#       instance_variables.each do |var|
+#         fold.instance_variable_set var, instance_variable_get(var)
+#   
+#         fold.metaclass.send :attr_accessor, var.gsub('@', '')
+#       end
+#       that = self
+#       fold.meta_def :method_missing do |meth, *args|
+#         return that.send(meth, *args) if that.respond_to?(meth)
+#         super
+#       end
+# 
+#       fold
+#     end
+    
+    def detect_slice_class line
+      return nil if line.blank?
+      self.class.defined_slices.reverse.detect {|slice| slice::Regex and slice::Regex.match(line)}
+    end
+    
+    module ClassMethods
+      def slices id, regex=AbstractSlice::Regex, &block
+        slice= Class.new(AbstractSlice)
+
+        slice.const_set :Regex, regex
+        slice.const_set :Block, block
+        
+        const_set id, slice
+        defined_slices << slice
+      end
+      
+      def defined_slices
+        @slices||= []
+      end
+    end
+  end
+end

data/rspec/fixtures/fold/fixture.target.fold

@@ -0,0 +1,9 @@
+family Modena
+  father Dave
+  mother Catherine
+  son Carl
+  daughter Tena
+  
+family Tarelo
+  father Tyson
+  mother Rheida

data/rspec/fold/abstract_fold_spec.rb

@@ -0,0 +1,69 @@
+require "ostruct"
+require 'rspec/fold_spec_helper'
+
+describe Fold::AbstractFold do
+  it "inherits OpenStruct" do
+    Fold::AbstractFold.superclass.should == OpenStruct
+  end
+end
+
+describe Fold::AbstractFold, ".initialize" do
+  it "and sets the regex" do
+    Fold::Precompiler.folds :What, /what/
+    Fold::Precompiler::What::Regex.should == /what/
+  end
+
+  it "and specifies whether or not to rip the match from the source" do
+    Fold::Precompiler.folds :Whatever, /whatever/, false
+    Fold::Precompiler::Whatever.clear_match.should == false
+  end
+end
+
+describe Fold::AbstractFold, ".render" do
+  it "renders cleanly" do
+    fold= Fold::AbstractFold.new(:text=>"LINE")
+    fold.render.should == "LINE"
+  end
+  
+  it "renders from block" do
+    Fold::Precompiler.folds :What, /what/ do
+      "#{text}?"
+    end
+    
+    what= Fold::Precompiler::What.new(:text=>'whatever')
+    what.render.should== "ever?"
+  end
+
+  it "doesn't clear match text if clear_match is false" do
+    Fold::Precompiler.folds :Dirty, /dirty/, false
+    dirty = Fold::Precompiler::Dirty.new(:text=>"dirty bird")
+    dirty.render.should == "dirty bird"
+  end
+  
+  it "renders children" do
+    Fold::Precompiler.folds :Parent, /^parent / do
+      "Hey, #{text} here, my children are: #{render_children.join(', ')}"
+    end
+
+    Fold::Precompiler.folds :Child, /^child /
+    
+    will= Fold::Precompiler::Parent.new(:text=>"Will")
+    will.children << Fold::Precompiler::Child.new(:text=>"Tony")
+    will.children << Fold::Precompiler::Child.new(:text=>"Ace")
+    
+    will.render.should == "Hey, Will here, my children are: Tony, Ace"
+  end
+end
+
+describe Fold::AbstractFold, ".render_children" do
+  it "renders cleanly" do
+    Fold::Precompiler.folds :Parent, /^parent /
+    Fold::Precompiler.folds :Child, /^child /
+    
+    will= Fold::Precompiler::Parent.new(:text=>"Will")
+    will.children << Fold::Precompiler::Child.new(:text=>"Tony")
+    will.children << Fold::Precompiler::Child.new(:text=>"Ace")
+    
+    will.render_children.should == ["Tony", "Ace"]
+  end 
+end

data/rspec/fold/abstract_slice_spec.rb

@@ -0,0 +1,8 @@
+require "ostruct"
+require 'rspec/fold_spec_helper'
+
+describe Fold::AbstractSlice do
+  it "inherits OpenStruct" do
+    Fold::AbstractSlice.superclass.should == OpenStruct
+  end
+end

data/rspec/fold/engine_spec.rb

@@ -0,0 +1,45 @@
+require 'rspec/fold_spec_helper'
+
+describe Fold::Engine do
+  before(:each) do
+    @fixture = Pathname.new(FoldFixtureRoot)
+    @path= @fixture +"fixture.target.fold"
+    @engine= Fold::Engine.new @path.read  
+
+#     @empty = @fixture + "empty.target.fold"
+#     @empty_engine = Fold::Engine.new @empty.read
+  end
+
+  it "inherits Module" do
+    Fold::Engine.class.should == Class
+  end
+
+  describe "#initialize" do
+    it "sets fold content" do
+      @engine.instance_variable_get(:@source).should == File.read(@path)
+    end
+  end
+  
+  describe "#lines" do
+    it "splits on line breaks" do
+      lines= 10
+      src= "LINE\n" * lines
+      en= Fold::Engine.new src
+      en.lines.length.should == lines
+    end
+    
+    it "rejects whitespace only lines" do
+      src= "LINE\n   \nLINE\n\t\n\t\nwhatup?"
+      en= Fold::Engine.new src
+      en.lines.length.should == 3
+    end
+  end
+  
+  describe "#render" do
+    it "renders spec" do
+      Fold::Precompiler.folds :Line, //
+      source= File.read "#{FoldFixtureRoot}/fixture.target.fold"
+      en= Fold::Engine.new source
+    end
+  end
+end

data/rspec/fold/fold_factory_spec.rb

@@ -0,0 +1,85 @@
+require 'rspec/fold_spec_helper'
+
+class Included
+  include Fold::FoldFactory 
+  def initialize
+    @instance_variable = []
+  end
+
+  def passed
+    :passed
+  end
+end
+
+describe Fold::FoldFactory do
+  it "inherits module" do
+    Fold::FoldFactory.class.should == Module
+  end
+end
+
+describe Fold::FoldFactory, ".count_soft_tabs" do
+  before(:each) {@it= Included.new}
+  
+  it "counts one soft tabs" do
+    @it.count_soft_tabs("  LINE").should == 1
+  end
+  
+  it "counts tree soft tabs" do
+    @it.count_soft_tabs("  " * 3 + "LINE").should == 3
+  end
+  
+  it "raises IndentationError on odd spaced indentation" do
+    lambda {
+      @it.count_soft_tabs(" LINE")
+    }.should raise_error(Fold::Precompiler::IndentationError)
+  end
+end
+
+describe Fold::FoldFactory, ".produce" do
+  before(:each) {@it= Included.new}
+  
+  it "folds abstractly" do
+    @it.produce.is_a?(Fold::AbstractFold).should == true
+  end
+  
+  it "folds other folds" do
+    Included.folds :Location, /^\@/
+    @it.produce('@LINE').is_a?(Included::Location).should == true  
+  end
+
+  it "passes along instance variables" do
+    @it.produce.instance_variables.should include("@instance_variable")
+  end
+
+  it "methods fall through" do
+    @it.produce.passed.should == :passed
+  end
+
+  it "and sets up attribute accessors for them" do
+    @it.produce.instance_variable.should === []
+  end
+end
+
+#describe Fold::Precompiler::Action::Regex do
+#  it "matches !LINE" do
+#    Fold::Precompiler::Action::Regex.should match("!LINE")
+#  end
+#end
+#
+#describe Fold::Precompiler::Selector::Regex do
+#  it "matches ?LINE" do
+#    Fold::Precompiler::Selector::Regex.should match("?LINE")
+#  end
+#end
+#
+#describe Fold::Precompiler::Group::Regex do
+#  it "matches describe LINE" do
+#    Fold::Precompiler::Group::Regex.should match("describe LINE")
+#  end
+#end
+#
+#describe Fold::Precompiler::Example::Regex do
+#  it "matches it LINE" do
+#    Fold::Precompiler::Example::Regex.should match("it LINE")
+#  end
+#end

data/rspec/fold/precompiler_spec.rb

@@ -0,0 +1,132 @@
+require 'rspec/fold_spec_helper'
+
+describe Fold::Precompiler do
+  it "inherits module" do
+    Fold::Precompiler.class.should == Class
+  end
+end
+
+class Confused < Fold::Precompiler
+  folds :Line, //
+  folds :What, /what/
+
+  slices :Octothorp, /#([\w]+)/ do
+    "octothorpedo:#{text}"
+  end
+end  
+
+describe Fold::Precompiler, ".folds" do
+  it "generates AbstractFold subclasses" do
+    Confused::What.superclass.should == Fold::AbstractFold
+  end
+  
+  it "in the appropriate namespace" do
+    Confused::What.should_not be_nil
+  end
+  
+  it "pushes to defined_folds" do
+    Confused.defined_folds.should include(Confused::What)
+  end
+end
+
+describe Fold::Precompiler, ".fold" do
+  before(:each) do
+    @it= Confused.new
+  end
+  
+  it "has notion of top level" do
+    en= Fold::Engine.new %{
+LINE 1
+  LINE 2
+  LINE 3
+LINE 4
+  LINE 5
+  LINE 6
+  
+LINE 7
+  LINE 8
+    LINE 9
+    }
+    @it.fold(en.lines).children.length.should == 3
+  end
+
+  it "children can be orphans" do
+    en = Fold::Engine.new "LINE 1"
+    @it.fold(en.lines).parent.should == nil
+  end
+
+  it "lets children know about their parents" do
+    en = Fold::Engine.new %{
+Line 1
+  Line 2
+  Line 3
+}
+  
+    folded = @it.fold(en.lines)
+    folded.children.first.parent.should == folded
+  end
+  
+  it "barfs on innappropriate indentation" do
+    en= Fold::Engine.new %{
+LINE 1
+    LINE 2
+    }
+    lambda {
+      @it.fold(en.lines)
+    }.should raise_error(Confused::IndentationError)
+  end
+
+  it "doesn't choke with empty source" do
+    @it.fold([]).should_not be_nil
+  end
+end
+
+describe Fold::Precompiler, ".step_in?" do
+  before(:each) do
+    @it= Confused.new
+  end
+  
+  it "must indent 1" do
+    @it.step_in?(1).should == true
+  end
+
+  it "no more" do
+    @it.step_in?(2).should == false
+  end
+  
+  it "no less" do
+    @it.step_in?(0).should == false
+  end
+end
+
+describe Fold::Precompiler, ".step_out?" do
+  before(:each) do
+    @it= Confused.new
+  end
+  
+  it "must indent < 0" do
+    @it.step_out?(-1).should == true
+  end
+  
+  it "cannot indent > 0" do
+    @it.step_out?(0).should == false
+  end
+end
+
+describe Fold::Precompiler, ".step_aside?" do
+  before(:each) do
+    @it= Confused.new
+  end
+  
+  it "must indent 0" do
+    @it.step_aside?(0).should == true
+  end
+
+  it "no more" do
+    @it.step_aside?(1).should == false
+  end
+  
+  it "no less" do
+    @it.step_aside?(-1).should == false
+  end
+end

data/rspec/fold/slice_factory_spec.rb

@@ -0,0 +1,40 @@
+require 'rspec/fold_spec_helper'
+
+class Included
+  include Fold::FoldFactory
+  include Fold::SliceFactory
+
+  slices :Interpolation, /#\{(.*?)\}/ do
+    text
+  end
+
+  def initialize
+    @instance_variable = []
+  end
+
+  def passed
+    :passed
+  end
+end
+
+describe Fold::SliceFactory do
+  it "inherits module" do
+    Fold::SliceFactory.class.should == Module
+  end
+
+  before(:each) do
+    @it = Included.new
+  end
+
+  it "has list of included slices" do
+    Included.defined_slices.should include(Included::Interpolation)
+  end
+
+  it "generates constant" do
+    Included::Interpolation.should_not be_nil
+  end
+
+  it "replaces items in a string" do
+    @it.process('#{hey} whats #{up}').should == "hey whats up"
+  end
+end

data/rspec/fold_spec.rb

@@ -0,0 +1,15 @@
+require 'rspec/fold_spec_helper'
+
+describe Fold do
+  it "inherits Module" do
+    Fold.class.should == Module
+  end
+  
+  it "has an Engine Class" do
+    Fold.constants.should include("Engine")
+  end
+  
+  it "has a precompiler class" do
+    Fold.constants.should include("Precompiler")
+  end
+end

data/rspec/fold_spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+__DIR__ = File.dirname(__FILE__)
+$LOAD_PATH << "#{__DIR__}/.." unless $LOAD_PATH.include?("#{__DIR__}/..")
+FoldFixtureRoot= File.expand_path("#{__DIR__}/fixtures/fold")
+
+require "lib/fold"
+require 'pathname'

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification 
+name: fold
+version: !ruby/object:Gem::Version 
+  version: 0.5.0
+platform: ruby
+authors: 
+- Collin Miller
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-28 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ruby2ruby
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 1.2.4
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: ParseTree
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 3.0.4
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: metaid
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+    version: 
+description: 
+email: collintmiller@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- README
+- Rakefile.rb
+- VERSION
+- fold.gemspec
+- lib/fold.rb
+- lib/fold/abstract_fold.rb
+- lib/fold/abstract_slice.rb
+- lib/fold/engine.rb
+- lib/fold/fold_factory.rb
+- lib/fold/precompiler.rb
+- lib/fold/slice_factory.rb
+- rspec/fixtures/fold/empty.target.fold
+- rspec/fixtures/fold/fixture.target.fold
+- rspec/fold/abstract_fold_spec.rb
+- rspec/fold/abstract_slice_spec.rb
+- rspec/fold/engine_spec.rb
+- rspec/fold/fold_factory_spec.rb
+- rspec/fold/precompiler_spec.rb
+- rspec/fold/slice_factory_spec.rb
+- rspec/fold_spec.rb
+- rspec/fold_spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/collin/fold
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A toolkit for creating whitespace active mini-languages. Inspired by Haml, light on features.
+test_files: []
+