bijou 0.1.0

data/examples/holiday/letterhead.txt

@@ -0,0 +1,4 @@
+
+Date: <%= Time.now.strftime("%x") %>
+
+<& content &>

data/examples/holiday/signature.txt

@@ -0,0 +1,9 @@
+<%args>
+	signed
+</%args>
+<%
+   options = ['Sincerely', 'Regards', 'Kind regards', 'Best regards', 'Warmly']
+   closing = options[rand(options.length)]
+%>
+<%= closing %>,
+<%= signed %>

data/examples/phishing/letter.txt

@@ -0,0 +1,29 @@
+<%! container='letterhead.txt' %>
+<%args>
+    name => 'to whom it may concern'
+</%args>
+
+Subject: With the complements of Mrs. former 1st lady
+
+Dear <%= name %>,
+
+Good day and compliments. I am writing you regarding an urgent matter. May I
+crave your indulgence to open this discussion by a formal letter of this sort. 
+I am making this contact on behalf of my sister, wife of the late general and
+former head of state of our republic. 
+
+Recently, due to unfortunate circumstances, we have had to consider the 
+option of moving her assets of One Hundred and Fifty-Three Millions United 
+States Dollars out of the country. We are seeking a business partner with 
+banking coordinates capable of accommodating such huge amounts. We have put 
+in place an instrument of payment for USD $<%= 30 + rand(15) %>M, which is 
+now in a dedicated account. If you agree to a business proposition, this amount
+will be transferred also into your account as remuneration for your assistance
+with our heartfelt thanks. I implore your consideration of this grave matter.
+
+I await your prompt response.
+
+<& signature.txt, signed => 'Solicitor R.U. Naeve' &>
+
+DISCLAIMER: This mock phishing letter is for demonstration purposes only.
+---- cut here ----

data/examples/phishing/letterhead.txt

@@ -0,0 +1,4 @@
+
+Date: <%= Time.now.strftime("%x") %>
+
+<& content &>

data/examples/phishing/phishing.rb

@@ -0,0 +1,21 @@
+
+$:.push '../../lib'
+
+require 'bijou'
+
+processor = Bijou::Processor.new
+
+context = processor.load('letter.txt');
+
+people = [ 'David', 'Richard', 'Tiffany' ]
+
+people.each { |who|
+  args = { 'name' => who }
+
+  context.render(args)
+
+  print context.output;
+
+  # We reuse the context, so clear the ouput buffers.
+  context.clear
+}

data/examples/phishing/signature.txt

@@ -0,0 +1,9 @@
+<%args>
+	signed
+</%args>
+<%
+   options = ['Sincerely', 'Regards', 'Kind regards', 'Best regards', 'Warmly']
+   closing = options[rand(options.length)]
+%>
+<%= closing %>,
+<%= signed %>

data/examples/profile/profile.rb

@@ -0,0 +1,46 @@
+
+$:.push '../..'
+
+require 'rubygems'
+require 'ruby-prof'
+require 'bijou/processor'
+
+RubyProf.start
+
+parser = Bijou::Parser.new
+
+class_name = "BirthdayView"
+
+how_many = 1000
+
+how_many.times {
+  class_text = parser.parse(class_name, <<EOS)
+<%args>
+    name => 'to whom it may concern'
+</%args>
+
+Dear <%= name %>,
+I\'m writing this letter today to send my best wishes for a happy birthday.
+
+Sincerely,
+Your boss
+
+---- cut here ----
+EOS
+
+  people = [ 'David' ]
+
+  people.each { |who|
+    args = { 'name' => who }
+    
+    context = Bijou::Context.new(Bijou::Config.new)
+    
+    letter = Bijou::Processor.execute(context, class_text, class_name, args)
+
+    # print letter
+  }
+}
+
+result = RubyProf.stop
+printer = RubyProf::GraphHtmlPrinter.new(result)
+printer.print(STDOUT, 0)

data/lib/bijou.rb

@@ -0,0 +1,15 @@
+#--
+#
+# Bijou - A web page templating framework for Ruby.
+#
+# Copyright (c) 2007-2008 Todd Lucas. All rights reserved.
+#
+# Author: Todd Lucas <tl@dogandponyshow.org>
+#
+#++
+#
+# :include: doc/README.rdoc
+# :title: Bijou - Web templates for Ruby
+#
+require 'bijou/component'
+require 'bijou/processor'

data/lib/bijou/backend.rb

@@ -0,0 +1,542 @@
+#
+# Copyright (c) 2007-2008 Todd Lucas. All rights reserved.
+#
+# backend.rb - Parser backend code generator
+#
+require 'bijou/common'
+require 'bijou/filters'
+
+module Bijou
+  module Parse
+
+#
+# A parser backend component for rendering the %args collection.
+#
+class ArgumentCollection
+  def initialize()
+    super()
+    @args = {}
+  end
+
+  attr_accessor :args
+
+  def add_argument(name, expression, filename, line)
+    # TODO: Args should preserver order; change to array.
+    @args[name] = [ expression, filename, line ]
+  end
+
+  def render_args(method, use_markers)
+    result = ''
+
+    @args.each { |key, value|
+      expression = value[0]
+      filename = value[1]
+      line = value[2]
+
+      # REVIEW: This is a bit verbose.
+      if expression
+        result << "#line #{line} #{filename}\n" if use_markers
+        result << "    #{key} = args.has_key?('#{key}') ? args['#{key}']" +
+          " : #{expression}\n"
+      else
+        result << "#line #{line} #{filename}\n" if use_markers
+        result << "    #{key} = args.has_key?('#{key}') ? args['#{key}']" +
+          " : @context.argument_exception('#{method}', '#{key}')\n"
+      end
+    }
+
+    return result
+  end
+end
+
+#
+# The base class for the backend code generator. Used to render a component
+# or a piece of a component.
+#
+class Target
+  def initialize
+    @output = ''
+    @args = nil
+  end
+
+  attr_accessor :args
+
+  # Escape text for embedding in a single-quoted string.
+  def escape_single(text)
+    # We use the block because \' has special meaning in substitution strings.
+    return text.gsub(/[\'\\]/) { |ch| "\\" + ch }
+  end
+  private :escape_single
+
+  def render_part(text) # print 'text'
+    if text.length > 0
+      text = escape_single(text)
+      @output << "    print '#{text}'\n"
+    end
+  end
+
+  def render_line(text) # puts  'text'
+    if text.length > 0
+      text = escape_single(text)
+      @output << "    puts  '#{text}'\n"
+    end
+  end
+
+  def render_expr(expr) # print expr
+    if expr.length > 0
+      @output << "    print #{expr}\n"
+    end
+  end
+
+  def render_code_(code) # code
+      @output << "#{code}"
+  end
+
+  def render_code(code) # code
+      @output << "#{code}\n"
+  end
+
+  #
+  # Render a Perl-oriented line marker comment , for use in generating stack
+  # traces at runtime. Any line information returned with an Exception object 
+  # will correspond to the source code that was generated from the component. 
+  # This line marker comment will allow the runtime to find the corresponding 
+  # line in the component's markup text.
+  #
+  def render_marker(line, filename)
+    render_code("#line #{line} #{filename}")
+  end
+
+  def render_args(method, use_markers)
+    result = ''
+    if @args
+      result << @args.render_args(method, use_markers)
+    end
+    return result
+  end
+end
+
+class Def < Target
+  def initialize(name)
+    super()
+    @name = name
+  end
+
+  attr_reader :name
+
+  def renderMethod
+    result = ''
+
+    result << "  def #{@name}\n"
+    result << @output
+    result << "  end\n"
+
+    return result
+  end
+end
+
+#
+# The class for the backend code generator that is used to render the
+# %method block. It may contain its own %args block.
+#
+class Method < Def
+  def initialize(name)
+    super(name)
+  end
+
+  def render_method(use_markers)
+    result = ''
+
+    if @name == 'fini'
+      result << "  def #{@name}()\n"
+    else
+      result << "  def #{@name}(args)\n"
+    end
+
+    if @name == 'init'
+      # For init, call super before derived code.
+      result << "    super\n"
+    end
+
+    result << render_args(@name, use_markers)
+    result << @output
+
+    if @name == 'fini'
+      # For fini, call super after derived code.
+      result << "    super\n"
+    end
+    result << "  end\n"
+
+    return result
+  end
+
+end
+
+#
+# The class for the backend code generator that is used to render an entire
+# component. It may contain a top-level %args block. This %args block is
+# replicated for the %init block.
+#
+class Component < Target
+  def initialize(use_markers)
+    @name = ''
+    @componentBase = 'Bijou::Component'
+    @componentName = ''
+    @output = ''
+    @defs = []
+    @directives = {}
+    @source_filename = nil
+    @cache_filename = nil
+    @use_markers = use_markers
+  end
+
+  attr_accessor :directives, :source_filename, :cache_filename
+
+  def add_method(d)
+    @defs.push(d)
+  end
+
+  def component=(componentName)
+    @componentName = componentName
+  end
+
+  def component_base=(componentBase)
+    @componentBase = componentBase
+  end
+
+  def require_list=(list)
+    @requireList = list
+  end
+
+  def to_s
+    result = ''
+
+    if @directives.has_key?('base')
+      @componentBase = @directives['base']
+    end
+
+    if @args
+      @defs.each {|d|
+        if d.name == 'init'
+          # NOTE: The init block has the same argument expansion as render.
+          d.args = @args.clone
+          break
+        end
+      }
+    end
+
+    result << "require 'bijou/component'\n"
+    if @requireList
+      @requireList.each {|path|
+        result << "require '#{path}'\n"
+      }
+    end
+    result << "class #{@componentName} < #{@componentBase}\n"
+    if @directives.has_key?('container')
+      result << "  def self.container\n"
+      result << "    '#{@directives['container']}'\n"
+      result << "  end\n"
+    end
+
+    # REVIEW: Do we need to escape? The filenames appear to always use
+    # forward slashes.
+    if @source_filename
+      result << "  def self.source_filename\n"
+      result << "    '#{@source_filename}'\n"
+      result << "  end\n"
+    end
+
+    if @cache_filename
+      result << "  def self.cache_filename\n"
+      result << "    '#{@cache_filename}'\n"
+      result << "  end\n"
+    end
+
+    result << "  def render(args)\n"
+    result << render_args('render', @use_markers)
+    result << @output;
+    result << "  end\n"
+    
+    @defs.each {|d|
+      result << d.render_method(@use_markers)
+    }
+
+    result << "end\n"
+
+    return result
+  end
+end
+
+#
+# The backend is used by the parser to generate a Ruby representation of a
+# Bijou component.
+#
+class Backend
+  class ParseContext
+    Normal = 1
+    MethodTag = 2
+  end
+
+  def initialize(diagnostics, trace, use_markers)
+    @trace = trace
+    @use_markers = use_markers
+
+    @buffer = ''
+    @parseContext = ParseContext::Normal
+    
+    @diagnostics = diagnostics
+
+    @currentComponent = @component = Bijou::Parse::Component.new(use_markers)
+    @argsCollection = nil
+    @isDefContext = false
+
+    # TODO: Make these installable.
+    @filters = {
+      'u' => Bijou::EncodeURL.new,
+      'h' => Bijou::EncodeHTML.new,
+      'a' => Bijou::EncodeAttributeValue.new,
+      't' => Bijou::EncodeTrim.new,
+      'w' => Bijou::EncodeWiki.new,
+    }
+  end
+
+  # Used to accumulate raw text from the parser.
+  def buffer(s)
+    @buffer << s
+  end
+
+  # Used to flush the buffer to the output stream with a newline
+  def puts_buffer()
+    if @isDefContext
+      @currentComponent.render_code(@buffer)
+    else
+      @currentComponent.render_line(@buffer)
+    end
+
+    @buffer = ''
+  end
+
+  # Flushes the buffer to the output stream without a newline. Often used
+  # before an inline tag <% ... %>.
+  def print_buffer()
+    if @isDefContext
+      @currentComponent.render_code_(@buffer)
+    else
+      @currentComponent.render_part(@buffer)
+    end
+
+    @buffer = ''
+  end
+
+  def message(s, line=nil, column=nil)
+    m = Bijou::Parse::Message.new
+    m.at(line, column)
+    m << s
+    @diagnostics.add_message(m)
+  end
+
+  def warning(s, line=nil, column=nil)
+    m = Bijou::Parse::Warning.new
+    m.at(line, column)
+    m << s
+    @diagnostics.add_warning(m)
+  end
+
+  def error(s, line=nil, column=nil)
+    m = Bijou::Parse::Error.new
+    m.at(line, column)
+    m << s
+    @diagnostics.add_error(m)
+  end
+
+  def trace(s)
+    puts s if @trace
+  end
+
+  #--
+  #
+  # Parser methods
+  #
+  #++
+
+  def render(component, source_filename=nil, cache_filename=nil, 
+             component_base=nil, require_list=nil)
+    @component.component = component
+    @component.source_filename = source_filename
+    @component.cache_filename = cache_filename
+    if component_base
+      @component.component_base = component_base
+    end
+    if require_list
+      @component.require_list = require_list
+    end
+    @component.to_s
+  end
+
+  def markup_section(buffer, filename, line)
+    @currentComponent.render_marker(line, filename) if @use_markers
+
+    if @isDefContext
+      @currentComponent.render_code(buffer)
+    else
+      @currentComponent.render_part(buffer)
+    end
+  end
+
+  def tag_open(tagStart)
+    print_buffer
+
+    trace "\nopentag: #{tagStart}" 
+  end
+
+  def named_start_tag(prefix, name, line, column)
+    case prefix
+    when 'method'
+      if @parseContext != ParseContext::Normal
+        error("method declared at nested scope", line, column)
+        return
+      end
+
+      @parseContext = ParseContext::MethodTag
+      @currentComponent = Bijou::Parse::Method.new(name)
+      @isDefContext = false
+
+    when 'init'
+      if @parseContext != ParseContext::Normal
+        error("init declared at nested scope", line, column)
+        return
+      end
+
+      @parseContext = ParseContext::MethodTag
+      @currentComponent = Bijou::Parse::Method.new(prefix)
+      @isDefContext = true
+
+    when 'fini'
+      if @parseContext != ParseContext::Normal
+        error("fini declared at nested scope", line, column)
+        return
+      end
+
+      @parseContext = ParseContext::MethodTag
+      @currentComponent = Bijou::Parse::Method.new(prefix)
+      @isDefContext = true
+
+    when 'args'
+      if @argsCollection
+        error("args may not be declared within another args section.", line, column)
+        return
+      end
+
+      # NOTE: We don't change parse context.
+      @argsCollection = Bijou::Parse::ArgumentCollection.new
+
+      if @currentComponent.args
+        warning("args section overrides previous args section.", line, column)
+      end
+
+      @currentComponent.args = @argsCollection
+    else
+      raise "unexpected named tag #{prefix}"
+    end
+  end
+
+  def named_end_tag(prefix)
+    if @argsCollection
+      @argsCollection = nil;
+      return
+    end
+
+    case @parseContext
+    when ParseContext::MethodTag;
+      @component.add_method(@currentComponent)
+      @currentComponent = @component
+      
+      @parseContext = ParseContext::Normal
+      @isDefContext = false
+    when 'args'
+      if !@argsCollection
+        error("unexpected args end tag", line, column)
+      end
+
+      @argsCollection = nil
+    else
+    end
+  end
+
+  def inline_tag(text, filename, line)
+    @currentComponent.render_marker(line, filename) if @use_markers
+    @currentComponent.render_code(text)
+  end
+
+  def output_tag(text, filters, filename, line)
+    filtered = "(#{text}).to_s"
+
+    if filters
+      filters.each{|filter|
+        if @filters.has_key? filter
+          filtered = @filters[filter].render(filtered)
+        else
+          warning("unrecognized output tag filter '#{filter}'", filename, line)
+        end
+      }
+    end
+
+    @currentComponent.render_marker(line, filename) if @use_markers
+    @currentComponent.render_expr(filtered)
+  end
+
+  def call_tag(identifier, args, indirect,  filename, line)
+    # Convert the argument list [[arg1, val1], [arg2, val2], ...] into
+    # a list of formatted string values.
+    list = []
+
+    args.each {|item|
+      list.push "'#{item[0]}' => #{item[1]}"
+    }
+
+    # Join the list of strings into a formatted hash.
+    text = "{#{list.join(', ')}}"
+
+    @currentComponent.render_marker(line, filename) if @use_markers
+
+    if indirect
+      # REVIEW: The indirection method currently shares the arguments with the
+      # method to be invoked. This may not be desirable. We would need an 
+      # different call syntax to do otherwise. If different arguments are 
+      # required, invoke may be called directly in a code block.
+      @currentComponent.render_code("    @context.invoke(#{identifier}(#{text}), #{text})")
+    else
+      @currentComponent.render_code("    @context.invoke('#{identifier}', #{text})")
+    end
+  end
+
+  def directive_tag(hash, line, column)
+    trace "\nDirectives:"
+    hash.each { |key, value|
+      trace "#{key} => #{value}"
+
+      if value =~ /^[\'\"](.*)[\'\"]$/
+        value = $1
+      end
+
+      if @component.directives.has_key?(key)
+        warning("directive '#{key}' overrides previous definition", line, column)
+      end
+      @component.directives[key] = value
+    }
+  end
+
+  def add_argument(argName, argValue, filename, line, column)
+    if @argsCollection
+      if @argsCollection.args.has_key?(argName)
+        error("argument '#{argName}' overrides previous delcaration", line, column)
+      end
+      @argsCollection.add_argument(argName, argValue, filename, line)
+    else
+      error("unexpected argument", line, column)
+    end
+  end
+end
+
+  end # module Parse
+end   # module Bijou