lilp 0.1.0

data/Gemfile

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

data/Rakefile

@@ -0,0 +1,10 @@
+require 'bundler'
+
+# This adds 'lib/' to the $LOAD_PATH
+Bundler::GemHelper.install_tasks
+
+task :default => :test
+
+task :test do
+  Dir["test/**_test.rb"].each{ |r| require_relative r }
+end

data/bin/lilp

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'lilp'
+
+options = Lilp::Option.new( ARGV.dup )
+options.parse
+
+runner  = Lilp::Runner.new
+runner.run( options.params, options.files )

data/lib/lilp.rb

@@ -0,0 +1,12 @@
+#  This file lists all the the dependencies of lilp.
+#  The `optparse` library is used to handle the command line options.
+#  The redcarpet library is a markdown parser with a very nice API.
+#  We are going to use it in order to create the lilp renderer.
+require "optparse"
+require 'redcarpet'
+
+#  Next, let's require our own files. They are located under the lilp/
+#  directory.
+require 'lilp/version'
+require 'lilp/base.rb'
+

data/lib/lilp/base.rb

@@ -0,0 +1,279 @@
+#  lilp is a literate programming pre-processor that allows you to write literate programs
+#  using Markdown. In its current state, it is mainly an experiment, a toy.
+#  This file is the main program file of the lilp application. Here is how we are going to
+#  decompose it.
+#  I propose we dive directly into the subject's by specifying how to parse and render source
+#  code from lilp files. After that, we'll see how to handle option parsing for our command
+#  line application. And lastly, we'll tie everything together.
+#  lilp files are simply files that end with a 'md' extension. They are valid markdown files.
+#  In order to simplify the parsing phase, I am using the `redcarpet` library. This library
+#  is easy to extend.
+#  What we want to do is to create a 'render'. A render is an object that outputs a stream.
+#  For that, it defines a number of hooks called by redcarpet's parser. What we need to do
+#  is to specify a valid 'render' object, and make it output a program. Let's do that now.
+#  _Literate Render_
+#  Let's define here our render. It is a class that inherite from Redcarpet::Render::Base
+#  class LiterateRender < Redcarpet::Render::Base
+#      COMMENT_SIGN = "#  "
+#  
+#  Now, redcarpet's parser will call a number of hook, depending on what has been found
+#  in the given lilp file. These hooks can be either `header`, `paragraph`, `block_code`
+#  or other. Here is the formal specification: 
+#    def preprocess(full_document)
+#      @macro = {}
+#      full_document
+#    end
+#  
+#    def header(text, header_level)
+#      if header_level == 3
+#        @macro[$1.to_sym] if text =~ /Call\: (.*)/
+#      end
+#    end
+#  
+#    def paragraph(text)
+#      text += "\n"
+#      text.gsub(/^/, COMMENT_SIGN)
+#    end
+#  
+#    def block_code(code, language)
+#      if @define_macro and @current_macro
+#        @macro[@current_macro] = code += "\n"
+#        code.gsub(/^/, COMMENT_SIGN)
+#      else
+#        code += "\n"
+#      end
+#    end
+#  
+#    def hrule()
+#      @define_macro  = ( not @define_macro )
+#      @current_macro = nil if @define_macro
+#    end
+#  
+#    def emphasis(text)
+#      @current_macro = text.to_sym if @define_macro
+#      nil
+#    end
+#  
+#  end
+#  
+#  The code above lists all the rules our render will live by. If there is anything to
+#  change in our render, it's in this part of the code.
+#  To a regular user, lilp is only a command he can invoke from the terminal. In order
+#  to work with it, we need to get some information from the user, such as the files
+#  he wants to preprocess, or the output directory where he wants the preprocessed files
+#  to go.
+#  For this, we use the `optparse` library. We create an Option object that uses that library's
+#  API.
+#  _The option parser_
+#  class Option
+#    attr_reader :files, :params
+#  
+#    def initialize( args )
+#      @params = {}
+#      @parser = OptionParser.new
+#      @args   = args
+#  
+#      @parser.banner = "Usage: lilp file_name.pl [other_file.pl] [-o output_dir]"
+#      @parser.on("-o", "--output D", String, "Output directory") { |val| @params[:output] = File.join('.', "#{val}") }
+#    end
+#  
+#    def parse
+#      begin
+#        @files = @parser.parse(@args)
+#        if @files.empty?
+#          puts "Missing file names"
+#          puts @parser
+#          exit
+#        end
+#      rescue OptionParser::InvalidOption => opt
+#        puts "Unknown option #{opt}"
+#        puts @parser
+#        exit
+#      rescue OptionParser::MissingArgument => opt
+#        puts opt
+#        puts @parser
+#        exit
+#      end
+#    end
+#  end
+#  
+#  We have a lilp render class, an option class that takes care of the command line
+#  options, now we need a way to tie the to together.
+#  To do this, let's create a third object. The class will be "Runner". It's goal
+#  is to render files passed to it while taking into account the options passed by
+#  the command line.
+#  _Runner class_
+#  class Runner
+#  
+#    def run( params, files_path )
+#      lilp_parser = Redcarpet::Markdown.new(LiterateRender, :fenced_code_blocks => true)
+#  
+#      files_path.each do |file_path|
+#        puts "#{file_path}: "
+#  
+#        if File.extname( file_path ) != '.md'
+#          puts 'Skipping (file must have a .lp extension)'
+#          next
+#        end
+#  
+#        output_path = String.new
+#        if params[:output]
+#          # Creates the output directory if it doesn't exist
+#          if File.exists?(params[:output])
+#            puts "Folder #{params[:output]} already exists"
+#          else
+#            puts "Creating folder #{params[:output]}"
+#            Dir.mkdir(params[:output])
+#          end
+#  
+#          file_name   = File.basename(file_path).chomp( File.extname(file_path) )
+#          output_path = File.join(params[:output], file_name)
+#        else
+#          output_path = file_path.chomp( File.extname(file_path) )
+#        end
+#  
+#        begin
+#          file = File.open( file_path, 'r' )
+#          out  = File.open( output_path, 'w' )
+#  
+#          out.write( lilp_parser.render( file.read ) )
+#  
+#          out.close
+#          file.close
+#  
+#          puts "Wrote #{output_path}"
+#  
+#        rescue
+#          puts "Error while parsing file '#{file_path}': #{$!}"
+#        end
+#      end
+#  
+#    end
+#  end
+#  
+#  Now, the last thing we need to do is to attach each of the parts in the correct order, under
+#  the Lilp module.
+module Lilp
+
+class Option
+  attr_reader :files, :params
+
+  def initialize( args )
+    @params = {}
+    @parser = OptionParser.new
+    @args   = args
+
+    @parser.banner = "Usage: lilp file_name.pl [other_file.pl] [-o output_dir]"
+    @parser.on("-o", "--output D", String, "Output directory") { |val| @params[:output] = File.join('.', "#{val}") }
+  end
+
+  def parse
+    begin
+      @files = @parser.parse(@args)
+      if @files.empty?
+        puts "Missing file names"
+        puts @parser
+        exit
+      end
+    rescue OptionParser::InvalidOption => opt
+      puts "Unknown option #{opt}"
+      puts @parser
+      exit
+    rescue OptionParser::MissingArgument => opt
+      puts opt
+      puts @parser
+      exit
+    end
+  end
+end
+
+class LiterateRender < Redcarpet::Render::Base
+    COMMENT_SIGN = "#  "
+
+  def preprocess(full_document)
+    @macro = {}
+    full_document
+  end
+
+  def header(text, header_level)
+    if header_level == 3
+      @macro[$1.to_sym] if text =~ /Call\: (.*)/
+    end
+  end
+
+  def paragraph(text)
+    text += "\n"
+    text.gsub(/^/, COMMENT_SIGN)
+  end
+
+  def block_code(code, language)
+    if @define_macro and @current_macro
+      @macro[@current_macro] = code += "\n"
+      code.gsub(/^/, COMMENT_SIGN)
+    else
+      code += "\n"
+    end
+  end
+
+  def hrule()
+    @define_macro  = ( not @define_macro )
+    @current_macro = nil if @define_macro
+  end
+
+  def emphasis(text)
+    @current_macro = text.to_sym if @define_macro
+    nil
+  end
+
+end
+
+class Runner
+
+  def run( params, files_path )
+    lilp_parser = Redcarpet::Markdown.new(LiterateRender, :fenced_code_blocks => true)
+
+    files_path.each do |file_path|
+      puts "#{file_path}: "
+
+      if File.extname( file_path ) != '.md'
+        puts 'Skipping (file must have a .lp extension)'
+        next
+      end
+
+      output_path = String.new
+      if params[:output]
+        # Creates the output directory if it doesn't exist
+        if File.exists?(params[:output])
+          puts "Folder #{params[:output]} already exists"
+        else
+          puts "Creating folder #{params[:output]}"
+          Dir.mkdir(params[:output])
+        end
+
+        file_name   = File.basename(file_path).chomp( File.extname(file_path) )
+        output_path = File.join(params[:output], file_name)
+      else
+        output_path = file_path.chomp( File.extname(file_path) )
+      end
+
+      begin
+        file = File.open( file_path, 'r' )
+        out  = File.open( output_path, 'w' )
+
+        out.write( lilp_parser.render( file.read ) )
+
+        out.close
+        file.close
+
+        puts "Wrote #{output_path}"
+
+      rescue
+        puts "Error while parsing file '#{file_path}': #{$!}"
+      end
+    end
+
+  end
+end
+
+end
+

data/lib/lilp/version.rb

@@ -0,0 +1,6 @@
+#  To keep up with the version, we declare it as a constant under
+#  the Lilp module.
+    module Lilp
+      VERSION = '0.1.0'
+    end
+

data/lilp.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "lilp/version"
+
+Gem::Specification.new do |s|
+  s.name        = "lilp"
+  s.version     = Lilp::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Michael Sokol"]
+  s.email       = ["mikaa123@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Lilp is lightweight literate programming}
+
+  s.add_dependency 'redcarpet'
+
+  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

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: lilp
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Michael Sokol
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-11-16 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: redcarpet
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: 
+email: 
+- mikaa123@gmail.com
+executables: 
+- lilp
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- Gemfile
+- Rakefile
+- bin/lilp
+- lib/lilp.rb
+- lib/lilp/base.rb
+- lib/lilp/version.rb
+- lilp.gemspec
+homepage: ""
+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.8
+signing_key: 
+specification_version: 3
+summary: Lilp is lightweight literate programming
+test_files: []
+