cadenza 0.7.0.rc1

data/lib/cadenza.rb

@@ -0,0 +1,57 @@
+require 'cadenza/token'
+require 'cadenza/lexer'
+require 'cadenza/parser'
+require 'cadenza/context'
+require 'cadenza/base_renderer'
+require 'cadenza/text_renderer'
+require 'cadenza/filesystem_loader'
+require 'cadenza/version'
+
+require 'stringio'
+
+# require all nodes
+Dir[File.join File.dirname(__FILE__), 'cadenza', 'nodes', '*.rb'].each {|f| require f }
+
+module Cadenza
+   BaseContext = Context.new
+
+   def self.render(template_text, scope=nil)
+      template = Parser.new.parse(template_text)
+
+      context = BaseContext.clone
+
+      context.push(scope) if scope
+
+      output = StringIO.new
+
+      TextRenderer.new(output).render(template, context)
+
+      output.string
+   end
+
+   def self.render_template(template_name, scope=nil)
+      context = BaseContext.clone
+
+      context.push(scope) if scope
+
+      template = context.load_template(template_name)
+
+      output = StringIO.new
+      
+      TextRenderer.new(output).render(template, context)
+
+      output.string
+   end
+end
+
+Dir[File.join File.dirname(__FILE__), 'cadenza', 'filters', '*.rb'].each do |filename|
+   Cadenza::BaseContext.instance_eval File.read(filename)
+end
+
+Dir[File.join File.dirname(__FILE__), 'cadenza', 'functional_variables', '*.rb'].each do |filename|
+   Cadenza::BaseContext.instance_eval File.read(filename)
+end
+
+Dir[File.join File.dirname(__FILE__), 'cadenza', 'blocks', '*.rb'].each do |filename|
+   Cadenza::BaseContext.instance_eval File.read(filename)
+end

data/lib/cadenza/base_renderer.rb

@@ -0,0 +1,24 @@
+module Cadenza
+   class BaseRenderer
+      attr_reader :output, :document
+
+      def initialize(output_io)
+         @output = output_io
+      end
+      
+      def render(node, context, blocks={})
+         @document ||= node
+
+         node_type = node.class.name.split("::").last
+
+         node_name = underscore(node_type).gsub!(/_node$/, '')
+
+         send("render_#{node_name}", node, context, blocks)
+      end
+
+      # very stripped down form of ActiveSupport's underscore method
+      def underscore(word)
+         word.gsub!(/([a-z\d])([A-Z])/,'\1_\2').downcase!
+      end
+   end
+end

data/lib/cadenza/blocks/standard_blocks.rb

@@ -0,0 +1,9 @@
+
+define_block :filter do |context, nodes, parameters|
+   filter = parameters.first.identifier
+
+   nodes.inject("") do |output, child|
+      node_text = Cadenza::TextRenderer.render(child, context)
+      output << context.evaluate_filter(filter, node_text)
+   end
+end

data/lib/cadenza/context.rb

@@ -0,0 +1,192 @@
+
+module Cadenza
+   class TemplateNotFoundError < StandardError
+   end
+
+   class FilterNotDefinedError < StandardError
+   end
+
+   class FunctionalVariableNotDefinedError < StandardError
+   end
+
+   class BlockNotDefinedError < StandardError
+   end
+
+   class Context
+      attr_accessor :stack, :filters, :functional_variables, :blocks, :loaders
+      attr_accessor :whiny_template_loading
+
+      def initialize(initial_scope={})
+         @stack = []
+         @filters = {}
+         @functional_variables = {}
+         @blocks = {}
+         @loaders = []
+         @whiny_template_loading = false
+
+         push initial_scope
+      end
+
+      # creates a new instance of the context with the stack, loaders, filters,
+      # functional variables and blocks shallow copied.
+      def clone
+         copy = super
+         copy.stack = stack.dup
+         copy.loaders = loaders.dup
+         copy.filters = filters.dup
+         copy.functional_variables = functional_variables.dup
+         copy.blocks = blocks.dup
+
+         copy
+      end
+
+      def lookup(identifier)
+         @stack.reverse_each do |scope|
+            value = lookup_identifier(scope, identifier)
+
+            return value unless value.nil?
+         end
+         
+         nil
+      end
+
+      def assign(identifier, value)
+         @stack.last[identifier.to_sym] = value
+      end
+
+      # TODO: symbolizing strings is slow so consider symbolizing here to improve
+      # the speed of the lookup method (its more important than push)
+      # TODO: since you can assign with the #assign method then make the scope
+      # variable optional (assigns an empty hash)
+      def push(scope)
+         @stack.push(scope)
+      end
+
+      def pop
+         @stack.pop
+      end
+
+      def define_filter(name, &block)
+         @filters[name.to_sym] = block
+      end
+
+      def evaluate_filter(name, params=[])
+         filter = @filters[name.to_sym]
+         raise FilterNotDefinedError.new("undefined filter '#{name}'") if filter.nil?
+         filter.call(*params)
+      end
+
+      def define_functional_variable(name, &block)
+         @functional_variables[name.to_sym] = block
+      end
+
+      def evaluate_functional_variable(name, params=[])
+         var = @functional_variables[name.to_sym]
+         raise FunctionalVariableNotDefinedError.new("undefined functional variable '#{name}'") if var.nil?
+         var.call([self] + params)
+      end
+
+      def define_block(name, &block)
+         @blocks[name.to_sym] = block
+      end
+
+      def evaluate_block(name, nodes, parameters)
+         block = @blocks[name.to_sym]
+         raise BlockNotDefinedError.new("undefined block '#{name}") if block.nil?
+         block.call(self, nodes, parameters)
+      end
+
+      def add_loader(loader)
+         if loader.is_a?(String)
+            @loaders.push FilesystemLoader.new(loader)
+         else
+            @loaders.push loader
+         end
+      end
+
+      def clear_loaders
+         @loaders.reject! { true }
+      end
+
+      def load_source(template_name)
+         source = nil
+
+         @loaders.each do |loader|
+            source = loader.load_source(template_name)
+            break if source
+         end
+
+         if source.nil? and whiny_template_loading
+            raise TemplateNotFoundError.new(template_name)
+         else
+            return source
+         end
+      end
+
+      def load_source!(template_name)
+         load_source(template_name) || raise(TemplateNotFoundError.new(template_name))
+      end
+
+      def load_template(template_name)
+         template = nil
+
+         @loaders.each do |loader|
+            template = loader.load_template(template_name)
+            break if template
+         end
+         
+         if template.nil? and whiny_template_loading
+            raise TemplateNotFoundError.new(template_name)
+         else
+            return template
+         end
+      end
+
+      def load_template!(template_name)
+         load_template(template_name) || raise(TemplateNotFoundError.new(template_name))
+      end
+
+   private
+      def lookup_identifier(scope, identifier)
+         if identifier.index('.')
+            lookup_path(scope, identifier.split("."))
+         else
+            lookup_on_scope(scope, identifier)
+         end
+      end
+
+      def lookup_path(scope, path)
+         loop do
+            component = path.shift
+
+            scope = lookup_on_scope(scope, component)
+
+            return scope if path.empty?
+         end
+      end
+
+      def lookup_on_scope(scope, identifier)
+         sym_identifier = identifier.to_sym
+
+         # allow looking up array indexes with dot notation, example: alphabet.0 => "a"
+         if scope.respond_to?(:[]) and scope.is_a?(Array) and identifier =~ /\d+/
+            return scope[identifier.to_i]
+         end
+
+         # otherwise if it's a hash look up the string or symbolized key
+         if scope.respond_to?(:[]) and scope.is_a?(Hash) and (scope.has_key?(identifier) || scope.has_key?(sym_identifier))
+            return scope[identifier] || scope[sym_identifier]
+         end
+
+         # if the identifier is a callable method then call that
+         return scope.send(sym_identifier) if scope.respond_to?(sym_identifier)
+
+         # if a functional variable is defined matching the identifier name then return that
+         return @functional_variables[sym_identifier] if @functional_variables.has_key?(sym_identifier)
+         
+         nil
+      end
+
+   end
+
+end

data/lib/cadenza/filesystem_loader.rb

@@ -0,0 +1,28 @@
+
+module Cadenza
+   class FilesystemLoader
+      attr_accessor :path
+
+      def initialize(path)
+         @path = path
+      end
+
+      def load_source(template)
+         filename = File.join(path, template)
+
+         return unless File.file?(filename)
+
+         File.read filename
+      end
+
+      def load_template(template)
+         source = load_source(template)
+
+         if source
+            return Cadenza::Parser.new.parse(source)
+         else
+            return nil
+         end
+      end
+   end
+end

data/lib/cadenza/filters/standard_filters.rb

@@ -0,0 +1,97 @@
+require 'cgi'
+
+# adds slashes to \, ', and " characters in the given string
+define_filter :addslashes do |string|
+   word = string.dup
+   word.gsub!(/\\/, "\\\\\\\\")
+   word.gsub!(/'/, "\\\\'")
+   word.gsub!(/"/, "\\\"")
+   word
+end
+
+# capitalizes the first letter of the string
+define_filter :capitalize, &:capitalize
+
+# centers the string in a fixed width field with the given padding
+define_filter :center do |string, length, *args|
+   padding = args.first || ' ' # Ruby 1.8.x compatibility
+   string.center(length, padding)
+end
+
+# removes all instances of the given string from the string
+define_filter :cut do |string, value|
+   string.gsub(value, '')
+end
+
+# formats the given date object with the given format string
+define_filter :date do |date, *args|
+   format = args.first || '%F' # Ruby 1.8.x compatibility
+   date.strftime(format)
+end
+
+# returns the given value if the input is falsy or is empty
+define_filter :default do |input, default|
+   if input.respond_to?(:empty?) and input.empty?
+      default
+   else
+      input || default
+   end
+end
+
+# escapes the HTML content of the value
+define_filter :escape do |input|
+   CGI::escapeHTML(input)
+end
+
+# returns the first item of an iterable
+define_filter :first do |input|
+   if input.respond_to?(:[])
+      RUBY_VERSION =~ /^1.8/ && input.is_a?(String) ? input[0].chr : input[0]
+   else
+      input.first
+   end
+end
+
+# returns the last item of an iterable
+define_filter :last do |input|
+   if input.respond_to?(:[])
+      RUBY_VERSION =~ /^1.8/ && input.is_a?(String) ? input[-1].chr : input[-1]
+   else
+      input.last
+   end
+end
+
+# glues together elements of the input with the glue string
+define_filter :join do |input, glue|
+   input.join(glue)
+end
+
+# returns the length of the input
+define_filter :length, &:length
+
+# returns the string left justified with the given padding character
+define_filter :ljust do |input, length, *args|
+   padding = args.first || ' '  # Ruby 1.8.x compatibility
+   input.ljust(length, padding)
+end
+
+# returns the string right justified with the given padding character
+define_filter :rjust do |input, length, *args|
+   padding = args.first || ' '  # Ruby 1.8.x compatibility
+   input.rjust(length, padding)
+end
+
+# returns the string downcased
+define_filter :lower, &:downcase
+
+# returns the string upcased
+define_filter :upper, &:upcase
+
+# returns the given words wrapped to fit inside the given column width.  Wrapping
+# is done on word boundaries so that no word cutting is done.
+# source: http://www.java2s.com/Code/Ruby/String/WordwrappingLinesofText.htm
+define_filter :wordwrap do |input, length, *args|
+   linefeed = args.first || "\n" # Ruby 1.8.x compatibility
+   input.gsub(/(.{1,#{length}})(\s+|\Z)/, "\\1#{linefeed}")
+end
+

data/lib/cadenza/functional_variables/standard_functional_variables.rb

@@ -0,0 +1,14 @@
+
+define_functional_variable :load do |context, template|
+   context.load_source(template)
+end
+
+define_functional_variable :render do |context, template|
+   template = context.load_template(template)
+
+   if template
+      Cadenza::TextRenderer.render(template, context)
+   else
+      ""
+   end
+end

data/lib/cadenza/lexer.rb

@@ -0,0 +1,191 @@
+require 'strscan'
+
+module Cadenza
+
+  class Lexer
+    def initialize
+      @line = 0
+      @column = 0
+    end
+
+    def source=(source)
+      @scanner = ::StringScanner.new(source || "")
+
+      @line = 1
+      @column = 1
+
+      @context = :body
+    end
+
+    def position
+      [@line, @column]
+    end
+
+    def next_token
+      if @scanner.eos?
+        [false, false]
+      else
+        send("scan_#{@context}")
+      end
+    end
+
+    def remaining_tokens
+      result = []
+
+      loop do
+        result.push next_token
+        break if result.last == [false, false]
+      end
+
+      result
+    end
+
+  private
+
+    #
+    # Updates the line and column counters based on the given text.
+    #
+    def update_counter(text)
+      number_of_newlines = text.count("\n")
+
+      if number_of_newlines > 0
+        @line += text.count("\n")
+        @column = text.length - text.rindex("\n")
+      else
+        @column += text.length
+      end
+    end
+
+    #
+    # Creates and returns a token with the line and column number from the end of
+    # the previous token.  Afterwards updates the counter based on the contents
+    # of the text.  The value of the token is determined by the text given and 
+    # the type of the token.
+    #
+    def token(type, text)
+      value = case type
+        when :INTEGER then text.to_i
+        when :REAL then text.to_f
+        when :STRING then text[1..-2]
+        else text
+      end
+
+      token = Token.new(value, text, @line, @column)
+
+      update_counter(token.source)
+
+      [type, token]
+    end
+
+    #
+    # Scans the next characters based on the body context (the context the lexer
+    # should initially be in), which will attempt to match the opening tokens
+    # for statements.  Failing that it will parse a text block token.
+    #
+    def scan_body
+      case
+        when text = @scanner.scan(/\{\{/) 
+          @context = :statement
+          token(:VAR_OPEN, text)
+
+        when text = @scanner.scan(/\{%/)
+          @context = :statement
+          token(:STMT_OPEN, text)
+
+        when text = @scanner.scan(/\{#/)
+          # scan until the end of the comment bracket, ignore the text for all
+          # purposes except for advancing the counters appropriately
+          comment = @scanner.scan_until(/#\}/)
+
+          # increment the counters based on the content of the counter
+          update_counter(text + comment)
+
+          # scan in the body context again, since we're not actually returning a
+          # token from the comment.  Don't scan if we're at the end of the body,
+          # just return a terminator token.
+          if @scanner.eos?
+            [false, false]
+          else
+            scan_body
+          end
+
+        else
+          # scan ahead until we find a variable opening tag or a block opening tag
+          text = @scanner.scan_until(/\{[\{%#]/)
+
+          # if there was no instance of an opening block then just take what remains 
+          # in the scanner otherwise return the pointer to before the block
+          if text
+            text = text[0..-3]
+            @scanner.pos -= 2
+          else
+            text = @scanner.rest
+            @scanner.terminate
+          end
+
+          token(:TEXT_BLOCK, text)
+      end
+    end
+
+    #
+    # Scans the next characters based on the statement context, which will ignore
+    # whitespace and look for tokens you would expect to find inside any kind
+    # of statement.
+    #
+    def scan_statement
+      # eat any whitespace at the start of the string
+      whitespace = @scanner.scan_until(/\S/)
+
+      if whitespace
+        @scanner.pos -= 1
+        update_counter(whitespace[0..-2])
+      end
+
+      # look for matches
+      case
+        when text = @scanner.scan(/\}\}/)
+          @context = :body
+          token(:VAR_CLOSE, text)
+        
+        when text = @scanner.scan(/%\}/)
+          @context = :body
+          token(:STMT_CLOSE, text)
+
+        when text = @scanner.scan(/[=]=/) # i've added the square brackets because syntax highlighters dont like /=
+          token(:OP_EQ, text)
+
+        when text = @scanner.scan(/!=/)
+          token(:OP_NEQ, text)
+
+        when text = @scanner.scan(/>=/)
+          token(:OP_GEQ, text)
+
+        when text = @scanner.scan(/<=/)
+          token(:OP_LEQ, text)
+
+        when text = @scanner.scan(/(if|unless|else|endif|endunless|for|in|endfor|block|endblock|extends|end|and|or|not)[\W]/)
+          keyword = text[0..-2]
+          @scanner.pos -= 1
+
+          token(keyword.upcase.to_sym, keyword)
+
+        when text = @scanner.scan(/[+\-]?[0-9]+\.[0-9]+/)
+          token(:REAL, text)
+
+        when text = @scanner.scan(/[+\-]?[1-9][0-9]*|0/)
+          token(:INTEGER, text)
+        
+        when text = @scanner.scan(/['][^']*[']|["][^"]*["]/)
+          token(:STRING, text)
+
+        when text = @scanner.scan(/[A-Za-z_][A-Za-z0-9_\.]*/)
+          token(:IDENTIFIER, text)
+
+        else
+          next_character = @scanner.getch
+          token(next_character, next_character)
+      end
+    end
+  end
+
+end