literate_ruby 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.infinity_test

@@ -0,0 +1,11 @@
+infinity_test do
+  use :rubies => %w(ruby-1.9.2 ruby-1.8.7), :app_framework => :rubygems, :verbose => true
+  
+  notifications :growl do
+    show_images :mode => :fuuu
+  end
+  
+  before_run do
+    clear :terminal
+  end
+end

data/Gemfile

@@ -0,0 +1,12 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in literate_ruby.gemspec
+gemspec
+
+group :test do
+  gem 'pry_debug'
+  gem 'method_source'
+  gem 'minitest'
+  gem 'wrong'
+  gem 'infinity_test'
+end

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2011 by Andrew O'Brien <obrien.andrew@gmail.com>
+
+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.textile

@@ -0,0 +1,73 @@
+h1. Literate Ruby
+
+This library is the first step towards a more literate Ruby syntax, similar to Haskell's (admittedly semi-literate syntax).
+
+Applications include: documentation files where there's more text than code (e.g. like READMEs!), blog entries, or a minimalist story runnner.
+
+h2. Usage
+
+h3. Single lines code
+
+<pre><code>
+> puts "This is inline code."
+> puts "But this will be part of the same code block."
+</code></pre>
+
+h3. Block code
+
+<pre><code>
+=begin_code
+def describe_block_code
+  puts "This will all be part of the same code block."
+end
+
+describe_block_code
+=end_code
+</code></pre>
+
+h3. Loading
+
+<pre><code>
+=begin_code
+require 'pp'
+require './lib/literate_ruby'
+
+lines = LiterateRuby.load("test/fixtures/fixture.lrb")
+
+pp lines
+
+pp "FOO: #{FOO}"
+pp "foo (method): #{foo()}"
+=end_code
+</code></pre>
+
+h3. Parsing
+
+If you just want access to the raw tree without eval'ing the code, do this:
+
+<pre><code>
+=begin_code
+require 'pp'
+require './lib/literate_ruby'
+
+lines = LiterateRuby.parse(File.new("test/fixtures/fixture.lrb"))
+
+pp lines
+
+=end_code
+</code></pre>
+
+h2. This file is like, so self-referential, or whatever
+
+Aim your shells thusly for great justice:
+
+<pre><code>
+$ ruby -r./lib/literate_ruby -e "LiterateRuby.load('README.textile')"
+</code></pre>
+
+(from this directory)
+
+h2. TODOS
+
+* Figure out if we need/how best to finish off the LiterateRuby.require method. So someone could write library code if they so desired.
+* Possibly change or make the inline & block delimiters configurable to support different markdown languages' code syntax.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/literate_ruby.rb

@@ -0,0 +1,124 @@
+module LiterateRuby
+  # See comment in the test file
+  # def self.require(path)
+  #   full_path = path + ".lrb"
+  #   if $".include?(full_path)
+  #     false
+  #   else
+  #     if load(full_path)
+  #       $" << full_path
+  #     else
+  #       raise LoadError
+  #     end
+  #   end
+  # end
+  
+  def self.load(path)
+    lines = parse(File.new(path))
+
+    lines.find_all {|(type, line_group)| type == :code && !line_group.empty?}.each do |(_, line_group)|
+      Kernel.eval(
+        line_group.map {|(line_no, line)| line}.join(""), 
+        TOPLEVEL_BINDING, 
+        path, 
+        line_group[0][0]
+      )
+    end
+
+    lines
+  end
+
+  def self.parse(io)
+    state = :open
+    lines = []
+    buffer = nil
+    
+    io.readlines.each_with_index do |line, i|
+      case line
+      when /^>/
+        clean_line = line.sub(/^>/, "")
+        case state
+        when :open
+          state = :in_code
+          buffer = []
+          buffer << [i + 1, clean_line]
+        when :in_code
+          buffer << [i + 1, clean_line]
+        when :in_code_block
+          buffer << [i + 1, clean_line]
+        when :in_data
+          lines << [:data, buffer]
+          buffer = []
+          
+          state = :in_code
+          buffer << [i + 1, clean_line]
+        end
+      when /^=begin_code/
+        case state
+        when :open
+          buffer = []
+        when :in_code
+          lines << [:code, buffer]
+          buffer = []
+        when :in_code_block
+          buffer << [i + 1, line]
+        when :in_data
+          lines << [:data, buffer]
+          buffer = []
+        end
+        state = :in_code_block
+      when /^=end_code/
+        case state
+        when :open
+          buffer = []
+          state = :in_data
+        when :in_code
+          lines << [:code, buffer]
+          buffer = []
+          
+          state = :in_data
+        when :in_code_block
+          lines << [:code, buffer]
+          buffer = []
+          
+          state = :in_data
+        when :in_data
+          # no-op
+        end
+      else
+        case state
+        when :open
+          buffer = []
+          state = :in_data
+          buffer << [i + 1, line]
+        when :in_code
+          lines << [:code, buffer]
+          buffer = []
+          
+          state = :in_data
+          buffer << [i + 1, line]
+        when :in_code_block
+          buffer << [i + 1, line]
+        when :in_data
+          buffer << [i + 1, line]
+        end
+      end
+    end
+
+    case state
+    when :open
+      # no-op
+    when :in_code
+      lines << [:code, buffer] unless buffer.empty?
+      buffer = nil
+    when :in_code_block
+      lines << [:code, buffer] unless buffer.empty?
+      buffer = nil
+    when :in_data
+      lines << [:data, buffer] unless buffer.empty?
+      buffer = nil
+    end
+
+    lines
+  end
+end

data/lib/literate_ruby/version.rb

@@ -0,0 +1,3 @@
+module LiterateRuby
+  VERSION = "0.0.1"
+end

data/literate_ruby.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "literate_ruby/version"
+
+Gem::Specification.new do |s|
+  s.name        = "literate_ruby"
+  s.version     = LiterateRuby::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Andrew O'Brien"]
+  s.email       = ["obrien.andrew@gmail.com"]
+  s.homepage    = "http://github.com/AndrewO/literate_ruby"
+  s.summary     = %q{Don't comment your code. Code your comments.}
+  s.description = %q{Literate Ruby is a small preprocessor that allows embedding code within text files and then loading them as programs.}
+
+  s.rubyforge_project = "literate_ruby"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/test/fixtures/fixture.lrb

@@ -0,0 +1,15 @@
+FOO is declared to be 123
+Let's test multines
+
+And paragraph breaks
+> FOO = 123
+> def foo
+>  1 + 1
+> end
+
+BAR is 456
+
+=begin_code
+BAR = 
+  456
+=end_code

data/test/fixtures/require_fixture.lrb

@@ -0,0 +1,10 @@
+BAZ is 678
+
+=begin_code
+BAZ = 
+  678
+=end_code
+
+> def bar
+>  45 + 35
+> end

data/test/literate_ruby_test.rb

@@ -0,0 +1,79 @@
+require 'rubygems'
+require 'bundler'
+Bundler.require(:default, :test)
+
+require 'minitest/spec'
+require 'minitest/autorun'
+
+require 'wrong/adapters/minitest'
+
+$:.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+require "literate_ruby"
+
+FIXTURE_DIR = File.join(File.dirname(__FILE__), "fixtures")
+
+describe LiterateRuby do
+  it "parses literate ruby files returning annotated lines" do
+    lines = LiterateRuby.parse(File.new(File.join(FIXTURE_DIR, "fixture.lrb")))
+
+    assert_fixture_parses(lines)
+  end
+  
+  it "loads a literate Ruby file returning annotated lines" do
+    lines = LiterateRuby.load(File.join(FIXTURE_DIR, "fixture.lrb"))
+
+    assert_fixture_parses(lines)
+
+    assert { FOO == 123 }
+    assert { foo() == 2 }
+    assert { BAR == 456 }
+  end
+
+  # Leaving this out for now. It works, but until I see someone trying to write libs in lrb, it might not be worth it to
+  # rewrite Ruby's load path searching, especially since that's changing.
+  # it "requires a literate Ruby file" do
+  #   LiterateRuby.require(File.join(FIXTURE_DIR, "require_fixture"))
+  # 
+  #   assert { bar() == 80 }
+  #   assert { BAZ == 678 }
+  #   assert { $".grep(/require_fixture.lrb$/) }
+  #   
+  #   deny { LiterateRuby.require(File.join(FIXTURE_DIR, "require_fixture")) }
+  # end
+
+  def assert_fixture_parses(lines)
+    expected = [
+      [:data, 
+        [
+          [1, "FOO is declared to be 123\n"],
+          [2, "Let's test multines\n"],
+          [3, "\n"],
+          [4, "And paragraph breaks\n"]
+        ]
+      ],
+     [:code, 
+       [
+         [5, " FOO = 123\n"], 
+         [6, " def foo\n"], 
+         [7, "  1 + 1\n"], 
+         [8, " end\n"]
+        ]
+      ],
+      [:data, 
+        [
+          [9, "\n"], 
+          [10, "BAR is 456\n"], 
+          [11, "\n"]
+        ]
+      ],
+      [:code, 
+        [
+          [13, "BAR = \n"], 
+          [14, "  456\n"]
+        ]
+      ]
+    ]
+    
+    assert { lines == expected}
+  end
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: literate_ruby
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Andrew O'Brien
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-24 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: Literate Ruby is a small preprocessor that allows embedding code within text files and then loading them as programs.
+email: 
+- obrien.andrew@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .infinity_test
+- Gemfile
+- LICENSE
+- README.textile
+- Rakefile
+- lib/literate_ruby.rb
+- lib/literate_ruby/version.rb
+- literate_ruby.gemspec
+- test/fixtures/fixture.lrb
+- test/fixtures/require_fixture.lrb
+- test/literate_ruby_test.rb
+has_rdoc: true
+homepage: http://github.com/AndrewO/literate_ruby
+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: literate_ruby
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: Don't comment your code. Code your comments.
+test_files: 
+- test/fixtures/fixture.lrb
+- test/fixtures/require_fixture.lrb
+- test/literate_ruby_test.rb