collin-fold 0.0.1

data/Rakefile.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'spec'
+
+namespace :spec do
+  task :prepare do
+    path = File.dirname(__FILE__)
+    p path
+    @specs= Dir.glob("#{path}/rspec/**/*.rb").join(' ')
+  end
+
+  task :all => :prepare do
+    system "spec #{@specs}"
+  end
+  
+  task :doc => :prepare do
+    system "spec #{@specs} --format specdoc"
+  end
+end

data/lib/fold.rb

@@ -0,0 +1,8 @@
+require 'facets'
+
+module Fold
+  require 'fold/engine'
+  require 'fold/abstract_fold'
+  require 'fold/fold_factory'
+  require '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, ''
+      
+      super attrs
+    end
+    
+    def render
+      text
+    end
+    
+    def render_children
+      children.map{|child| child.render}
+    end
+  end
+end

data/lib/fold/engine.rb

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

data/lib/fold/fold_factory.rb

@@ -0,0 +1,52 @@
+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
+      }
+    
+      if klass= detect_class(line)
+        klass.new attrs
+      else
+        AbstractFold.new attrs.merge(:tabs => -1)
+      end
+    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, &block
+        fold= Class.new(AbstractFold)
+        fold.const_set :Regex, regex
+        
+        fold.send :define_method, :render, &block if block_given?
+        
+        const_set id, fold
+        defined_folds << fold
+      end
+      
+      def defined_folds
+        @folds||= []
+      end
+    end
+  end
+end

data/lib/fold/precompiler.rb

@@ -0,0 +1,52 @@
+module Fold
+  class Precompiler
+    include Fold::FoldFactory
+  
+    def fold lines
+      last_line= produce
+
+      parent_line= nil
+      
+      parent_stack= []
+
+      lines.each do |text|
+        line = produce 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
+     
+        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/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,58 @@
+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
+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 "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/engine_spec.rb

@@ -0,0 +1,52 @@
+require 'rspec/fold_spec_helper'
+
+describe Fold::Engine do
+  it "inherits Module" do
+    Fold::Engine.class.should == Class
+  end
+
+  describe "#initialize" do
+    before(:each) do
+      @path= "#{FoldFixtureRoot}/fixture.target.fold"
+      @engine= Fold::Engine.new File.read(@path)  
+    end
+  
+    it "sets fold content" do
+      @engine.instance_variable_get(:@source).should == File.read(@path)
+    end
+  end
+  
+  describe "#prepare_fold" do
+    before(:each) do
+      @path= "#{FoldFixtureRoot}/fixture.target.fold"
+      @engine= Fold::Engine.new File.read(@path)  
+    end
+    
+    it "prepares fold content" do
+      @engine.instance_variable_get(:@prepared_source).should_not be_nil
+    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,66 @@
+require 'rspec/fold_spec_helper'
+
+class Included; include Fold::FoldFactory 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
+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,108 @@
+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/
+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 "barfs on innappropriate indentation" do
+    en= Fold::Engine.new %{
+LINE 1
+    LINE 2
+    }
+    lambda {
+      @it.fold(en.lines)
+    }.should raise_error(Confused::IndentationError)
+  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_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,4 @@
+require 'rubygems'
+path = File.dirname(__FILE__)
+FoldFixtureRoot= File.expand_path("#{path}/fixtures/fold")
+require "#{path}/../lib/fold"

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification 
+name: collin-fold
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Collin Miller
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-25 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rake
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A toolkit for creating whitespace active mini-languages. Inspired by Haml, light on features.
+email: collintmiller@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README
+- Rakefile.rb
+- lib/fold
+- lib/fold/fold_factory.rb
+- lib/fold/precompiler.rb
+- lib/fold/engine.rb
+- lib/fold/abstract_fold.rb
+- lib/fold.rb
+- rspec/fold
+- rspec/fold/precompiler_spec.rb
+- rspec/fold/abstract_fold_spec.rb
+- rspec/fold/engine_spec.rb
+- rspec/fold/fold_factory_spec.rb
+- rspec/fixtures
+- rspec/fixtures/fold
+- rspec/fixtures/fold/fixture.target.fold
+- rspec/fold_spec.rb
+- rspec/fold_spec_helper.rb
+has_rdoc: false
+homepage: http://github.com/collin/fold
+post_install_message: 
+rdoc_options: []
+
+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.2.0
+signing_key: 
+specification_version: 2
+summary: A toolkit for creating whitespace active mini-languages. Inspired by Haml, light on features.
+test_files: []
+