luobo 0.0.1

data/README.rdoc

@@ -0,0 +1,7 @@
+= Luobo
+
+Luobo is a simple, easy to extend code generator.
+
+When you feed <tt>tuzi</tt> (bunny) with some luobo (carrot) script, it will produce sources base on your predefined rules.
+
+

data/Rakefile

@@ -0,0 +1,3 @@
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new('spec')
+

data/bin/tuzi

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+# vim syn=ruby
+
+$: << 'lib'
+
+require "luobo"
+
+# TODO: optparser and build-in drivers.
+file = ARGV[0]
+out = STDOUT
+
+Luobo::Base.new(file, out).process

data/example/parser.lub

@@ -0,0 +1,111 @@
+DRIVER: ast
+
+Raw line passed as it is.
+AST: Raw line passed as it is.
+
+## SPLIT: abc df
+AST: abc
+AST: df
+
+Raw line contains ->
+  fake block
+AST: Raw line contains -> ->
+AST: 2,fake block
+
+## SPEC: a spec blog ->
+  do that
+  do this
+  ## SPEC: nested spec ->
+    redo that
+    redo this
+  doing outside
+doing further outside
+AST: spec "a spec blog" do
+AST: 2,do that
+AST: 2,do this
+AST: end
+AST: 2,spec "nested spec" do
+AST: 4,redo that
+AST: 4,redo this
+AST: 2,end
+AST: 2,doing outside
+AST: doing further outside
+
+% =================
+Give me a loop for <%= loop_name %>
+SPEC: and has spec <%= loop_spec %> ->
+  specify a value as <%= value %>
+% -----
+% loop_name: looper
+% loop_spec: spec a loop
+% value: 89
+% -----
+% loop_name: looper again
+% loop_spec: spec a loop again
+% value: 899090
+AST: Give me a loop for looper
+AST: spec "and has spec spec a loop" do
+AST: 2,specify a value as 89
+AST: end
+AST: Give me a loop for looper again
+AST: spec "and has spec spec a loop again" do
+AST: 2,specify a value as 899090
+AST: end
+
+Test a loop inside a block argument
+AST: Test a loop inside a block argument
+
+SPEC: loop inside ->
+  % ========================
+  key value <%= store %>
+  % -----
+  % store: factory
+  % -----
+  % store: firm
+  % ------
+  % store: person
+
+AST: spec "loop inside" do
+AST: 2, key value factory
+AST: 2, key value firm
+AST: 2, key value person
+AST: end
+
+Pure raw test in indent
+  Indent with 1 level
+    Indent with 2 levels
+
+    Indent with 2 levels again
+Back!
+
+AST: Pure raw test in indent
+AST: 2,Indent with 1 level
+AST: 4,Indent with 2 levels
+AST: 4,Indent with 2 levels again
+AST: Back!
+
+UNKNOWN: unknown processor name treated as it is
+AST: UNKNOWN: unknown processor name treated as it is
+
+UNKBLOK: unknown with a block ->
+  This is quite strange!
+Send back.
+AST: UNKBLOK: unknown with a block -> ->
+AST: 2,This is quite strange!
+AST: Send back.
+
+HASH: key_name: value_name
+AST: key: key_name
+AST: value: value_name
+
+HASH: ->
+  blockkey: blockvalue
+  blockkey2: blockvalue2
+  blockkey3: blockvalue3
+
+AST: key: blockkey
+AST: value: blockvalue
+AST: key: blockkey2
+AST: value: blockvalue2
+AST: key: blockkey3
+AST: value: blockvalue3

data/lib/luobo.rb

@@ -0,0 +1,5 @@
+require "yaml"
+
+require "luobo/token"
+require "luobo/driver"
+require "luobo/base"

data/lib/luobo/base.rb

@@ -0,0 +1,211 @@
+# encoding: utf-8
+
+require "erubis"
+
+module Luobo
+  ## entry class for the carrot module
+  class Base    
+    attr_accessor :driver
+    def initialize file, output
+      @source_file = file
+      
+      @output = output.is_a?(IO) ? output : File.open(output, "w")
+      
+      # initialize:
+      @token_stack = Array.new
+
+      # initialize loop template and examples
+      self.reset_loop
+    end
+
+    # initialize the holders for a example based loop,
+    # or reset after a loop expansion
+    def reset_loop
+      @loop_start_ln = 0
+      @loop_template = nil
+      @loop_examples = Array.new
+    end
+
+    # extend a loop be examples
+    def expand_loop
+      raise "no examples found for loop start on line #{@loop_start_ln}" unless @loop_examples.size > 0
+      loop_n = 0
+      @loop_examples.each do |exa|
+        loop_n += 1
+        vars = YAML.load(exa)
+        # erubie the template
+        rslt = Erubis::Eruby.new(@loop_template).result(vars)
+        li = 0
+        rslt.split("\n").each do |line|
+          li += 1
+          self.process_line line, @loop_start_ln + li, loop_n
+        end
+      end
+      
+      # clear up holders
+      self.reset_loop
+    end
+
+    def dump contents
+      @output.print contents if contents
+    end
+
+    # travel up through the token stack, close all token with
+    # indent level larger or equal to the parameter
+    def close_stack indent_level
+      source = ''
+      while @token_stack.size > 0 and @token_stack[-1].indent_level >= indent_level
+        if @token_stack.size > 1 
+          @token_stack[-2].add_block_code @driver.convert(@token_stack[-1])
+        else # this is the last token in the stack
+          self.dump(@driver.convert(@token_stack[-1]))
+        end
+        @token_stack.pop
+      end
+    end
+
+    # add a new line to the existing token if it requires block codes
+    # or write the last token out before a new token
+    # this function invokes after a loop expansion.
+    def process_line line, ln, loop_n = 0
+      indent_level = 0
+      if /^(?<head_space_>\s+)/ =~ line
+        indent_level = head_space_.size
+      end
+      
+      # try to close stack if applicable
+      self.close_stack indent_level
+
+      # starts a named_processor or starts a raw_processor 
+      processor_name = '_raw'
+      line_code = line.gsub(/^\s*/,"")
+      block_code = nil
+      if matches = /#{regex_proc_line}/.match(line) 
+        processor_name = matches["proc_name_"]
+        line_code = matches["line_code_"]
+        block_code = '' if line_code.gsub!(/#{regex_block_start}/, '')
+      end
+      
+      @token_stack << Token.new(ln, line, indent_level, processor_name, line_code, block_code)
+
+      # unless it opens for block code close it soon, 
+      # (dedicate the dump function to close_stack())
+      self.close_stack indent_level unless block_code
+    end
+
+    # add a new line to the example, separate examples to array
+    def add_example_line line
+      if /#{regex_new_example}/.match(line)
+        # start a new loop example with a placeholder nil        
+        @loop_examples << nil
+      else
+        raise "you need use '#{regex_new_example}' to start a loop example" unless @loop_examples.size > 0
+        line.gsub!(/#{regex_example_head}/, '')
+        @loop_examples[-1] = @loop_examples[-1] ? @loop_examples[-1] + "\n" + line : line
+      end
+    end
+
+    # regex configurations
+    # match characters before a processor keyword
+    def regex_proc_head
+      "\s*(\#{2,}|\-{2,}|\/{2,})?\s*"
+    end
+
+    def regex_proc_name
+      "(?<proc_name_>[A-Z][A-Z0-9_]+)"
+    end
+
+    def regex_proc_end
+      "\s*\:?\s*"
+    end
+
+    def regex_proc_line
+      "^" + regex_proc_head + regex_proc_name + regex_proc_end + "(?<line_code_>.+)"
+    end
+
+    def regex_block_start
+      "\s*(?<block_start_>\-\>)?\s*$"
+    end
+
+    def regex_loop_line
+      "^" + regex_proc_head + "\%\s*\=\=\=\=+\s*"
+    end
+
+    def regex_new_example
+      "^" + regex_proc_head + "\%\s*\-\-\-\-+\s*"
+    end
+
+    def regex_example_head
+      "^" + regex_proc_head + "\%\s*"
+    end
+
+    def regex_example_line
+      "^" + regex_proc_head + "\%\s*(?<example_>.+)\s*"
+    end
+
+    # parse the file, whenever found a token, use driver to convert
+    # it and send to output
+    def process
+      in_loop = false
+      in_example = false
+
+      fh = File.open(@source_file, 'r:utf-8')
+      fh.each do |line|
+        line.chomp!
+        line.gsub!("\t", "  ") # convert tab to 2 spaces
+        
+        # ensure first line as driver definition
+        unless @driver
+          if matches = /^#{regex_proc_head}DRIVER#{regex_proc_end}(?<dname_>\w+)\s*$/.match(line)
+            @driver = Driver.create(matches["dname_"])
+            self.dump(@driver.setup)
+            next
+          else
+            raise "You must specify a driver on the first line"
+          end
+        end
+        
+        # interrupt for loops
+        if matches = /#{regex_loop_line}/.match(line)
+          in_loop = true
+          @loop_start_ln = $.
+          next
+        end
+
+        # expand and end current loop 
+        if in_example
+          unless /#{regex_example_head}/.match(line)
+            self.expand_loop
+            in_example = false
+            in_loop = false
+          end
+        end
+
+        # end a loop template and start a loop example
+        if in_loop
+          in_example = true if /#{regex_example_head}/.match(line)
+        end
+
+        # dispatch the current line to different holders
+        if in_example
+          self.add_example_line line
+        elsif in_loop
+          @loop_template = @loop_template ? @loop_template + "\n" + line : line
+        else
+          self.process_line line, $.
+        end
+      end
+      fh.close
+
+      # do not forget expand last loop if it reaches over EOF.
+      self.expand_loop if @loop_start_ln > 0
+
+      # close all remain stacks
+      self.close_stack 0
+
+      self.dump(@driver.exit)
+      @output.close
+      self
+    end
+  end
+end

data/lib/luobo/driver.rb

@@ -0,0 +1,46 @@
+
+
+module Luobo
+  class Driver 
+    
+    ## implements the factory pattern
+    @@drivers = {}
+
+    def self.create type
+      c = @@drivers[type.to_sym]
+      raise "No registered driver for type #{type.to_s}" unless c
+      c.new
+    end
+  
+    def self.register_driver type
+      raise "Driver for #{type.to_s} already registed." if @@drivers[type.to_sym]
+      @@drivers[type.to_sym] = self
+    end
+
+    ## cross-drivers methods and callbacks
+    def convert token
+      pname = "do_" + token.processor_name.downcase
+      if self.respond_to?(pname)
+        self.send(pname.to_sym, token)
+      else
+        self.do__missing(token)
+      end
+    end
+
+    def exit; end
+    def setup; end
+
+    def indent token
+      " " * token.indent_level
+    end
+
+    def do__raw token
+      indent(token) + token.line_code.gsub(/^\s*/, "") + "\n"
+    end
+
+    def do__missing token
+      src = indent(token) + token.line
+      src += token.block_code + "\n" if token.block_code
+    end
+  end
+end

data/lib/luobo/token.rb

@@ -0,0 +1,28 @@
+module Luobo
+  ## this class holds a block of carrot source code tokenized by the parser.
+  class Token
+    attr_accessor :ln, :line, :indent_level, :processor_name, :line_code, :block_code
+
+    def initialize ln, line, indent_level, processor_name, line_code, block_code
+      @ln, @line, @indent_level, @processor_name, @line_code, @block_code = ln, line, indent_level, processor_name, line_code, block_code
+    end
+  
+    # add a line to current block args, separate each line with "\n"
+    def add_block_code line
+      line.chomp!
+      if self.block_code 
+        self.block_code += "\n" + line
+      else
+        self.block_code = line
+      end
+    end
+
+    def block_args
+      YAML.load(block_code)
+    end
+
+    def line_args
+      YAML.load(line_code)
+    end
+  end
+end

data/lib/luobo/version.rb

@@ -0,0 +1,4 @@
+module Luobo
+  VERSION = '0.0.1'
+end
+

data/luobo.gemspec

@@ -0,0 +1,18 @@
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+require 'luobo/version'
+
+Gem::Specification.new 'luobo', Luobo::VERSION do |s|
+  s.description       = "Luobo is a simple, easy to extend code generator."
+  s.summary           = "Easy to extend code generator"
+  s.authors           = ["Huang Wei"]
+  s.email             = "huangw@pe-po.com"
+  s.homepage          = "https://github.com/huangw/luobo-gem"
+  s.executables       << "tuzi"
+  s.files             = `git ls-files`.split("\n") - %w[.gitignore]
+  s.test_files        = Dir.glob("{spec,test}/**/*.rb")
+  s.rdoc_options      = %w[--line-numbers --inline-source --title Luobo --main README.rdoc --encoding=UTF-8]
+
+  s.add_development_dependency 'rspec', '~> 2.5'
+  s.add_dependency 'erubis'
+end
+

data/spec/driver_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+describe Luobo::Driver do
+  class TestDriver < Luobo::Driver 
+    def do_test_met(tk) 
+      "test method" 
+    end
+    register_driver :test_driver
+  end
+
+  describe "create test driver" do
+    subject(:test_driver) do
+      Luobo::Driver.create(:test_driver)
+    end
+
+    it "is a test driver object" do
+      test_driver.is_a?(TestDriver).should be_true
+    end
+
+    its :class do
+      should eq(TestDriver)
+    end
+
+    it "inherit driver methods" do
+      tk = Luobo::Token.new(1, '', 1, 'test_met', '', '')
+      test_driver.convert(tk).should eq("test method")
+    end
+  end
+
+end

data/spec/parser_spec.rb

@@ -0,0 +1,78 @@
+require "spec_helper"
+
+describe Luobo::Base do
+  class OutputHolder < IO
+    attr_accessor :text
+    def initialize; @text = {} end
+    def print(str)
+      str.split("\n").each {|t| @text[t] = true}
+    end
+    def close; end
+  end
+
+  class AstDriver < Luobo::Driver
+    attr_accessor :asserts
+    def initialize
+      super()
+      @asserts = []
+    end
+
+    def do_ast token
+      str = ''
+      if /(?<ident_>\d+),\s*(?<rm_>.+)/ =~ token.line_code
+        str = " "*ident_.to_i + rm_
+      else
+        str = token.line_code
+      end
+      @asserts << str
+      nil
+    end
+
+    def do_split token
+      src = ""
+      token.line_code.split(/\s+/).each do |line|
+        src += line + "\n"
+      end
+      src
+    end
+    
+    def do_spec token
+      src = indent(token) + "spec \"#{token.line_code}\" do"
+      src += token.block_code ? token.block_code : ""
+      src += "\n" + indent(token) + "end\n"
+      src
+    end
+
+    def do_hash token
+      hash = token.line_args if token.line_code.size > 0
+      if token.block_code.size > 0
+        hash = hash.is_a?(Hash) ? hash.merge(token.block_args) : token.block_args
+      end
+      src = ""
+      hash.each do |k,v|
+        src += indent(token) + "key: #{k}\n"
+        src += indent(token) + "value: #{v}\n"
+      end
+      src
+    end
+    
+    register_driver :ast
+  end
+
+  describe "convert" do
+    oh = OutputHolder.new
+    base = Luobo::Base.new("example/parser.lub", oh).process
+
+    it "base should have a AstDriver" do
+      base.driver.is_a?(AstDriver)
+      p oh.text
+    end
+
+    base.driver.asserts.each do |line|
+      it "can parse #{line}" do
+        oh.text[line].should be_true
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rspec'
+require 'luobo'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.formatter     = 'documentation'
+end

data/spec/token_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+
+describe Luobo::Token do
+  subject (:token) do
+    Luobo::Token.new(1, "line", 4, "Echo", "same: hash", "['block', 'in', 'array']") 
+  end
+
+  its :ln do 
+    should eq(1) 
+  end
+
+  its :line do
+    should eq("line")
+  end
+
+  its :indent_level do
+    should eq(4)
+  end
+
+  its :processor_name do
+    should eq("Echo")
+  end
+
+  its :line_args do
+    token.line_args["same"].should eq("hash")
+  end
+
+  its :block_args do
+    token.block_args[2].should eq("array")
+  end
+
+end

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: luobo
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Huang Wei
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: erubis
+  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'
+description: Luobo is a simple, easy to extend code generator.
+email: huangw@pe-po.com
+executables:
+- tuzi
+extensions: []
+extra_rdoc_files: []
+files:
+- README.rdoc
+- Rakefile
+- bin/tuzi
+- example/parser.lub
+- lib/luobo.rb
+- lib/luobo/base.rb
+- lib/luobo/driver.rb
+- lib/luobo/token.rb
+- lib/luobo/version.rb
+- luobo.gemspec
+- spec/driver_spec.rb
+- spec/parser_spec.rb
+- spec/spec_helper.rb
+- spec/token_spec.rb
+homepage: https://github.com/huangw/luobo-gem
+licenses: []
+post_install_message: 
+rdoc_options:
+- --line-numbers
+- --inline-source
+- --title
+- Luobo
+- --main
+- README.rdoc
+- --encoding=UTF-8
+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.24
+signing_key: 
+specification_version: 3
+summary: Easy to extend code generator
+test_files:
+- spec/driver_spec.rb
+- spec/parser_spec.rb
+- spec/spec_helper.rb
+- spec/token_spec.rb