ruty 0.0.1

data/lib/ruty/context.rb

@@ -0,0 +1,148 @@
+# = Ruty Context Class
+#
+# Author:: Armin Ronacher
+# 
+# Copyright (c) 2006 by Armin Ronacher
+#
+# You can redistribute it and/or modify it under the terms of the BSD license.
+
+
+module Ruty
+
+  # represents the internal namespace used by ruty
+  # It basically works like a hash just that it has
+  # multiple layers which can be pushed and popped.
+  # That feature is used by the template engine in
+  # loops, blocks and other block elements which set
+  # variables.
+  class Context
+    include Enumerable
+
+    # create a new context instance. initial can be
+    # a hash which represents the initial root stack
+    # which cannot be popped.
+    def initialize initial=nil
+      @stack = [initial || {}]
+    end
+
+    # push a new empty or given hash to the stack.
+    def push hash=nil
+      @stack << (hash or {})
+    end
+
+    # pop the outermost hash from the stack and return
+    # it. The root hash is never popped, in that case
+    # the method returns nil.
+    def pop
+      @stack.pop if @stack.size > 1
+    end
+
+    # manipulate the outermost hash.
+    def []= name, value
+      @stack[-1][name] = value
+    end
+
+    # start a recursive lookup for name.
+    def [] name
+      @stack.each do |hash|
+        val = hash[name]
+        return val if not val.nil?
+      end
+      nil
+    end
+
+    # checks if the key exists in one of the hashes.
+    def has_key? key
+      not send(:[], key).nil?
+    end
+
+    # call a block for each item in the context. if an item
+    # exists in two layers, only the item from the higher
+    # layer is yielded.
+    def each &block
+      found = {}
+      @stack.reverse_each do |hash|
+        hash.each do |key, value|
+          next if found.include?(key)
+          found[key] = hash
+          block.call(key, value)
+        end
+      end
+    end
+
+    # overrides pretty print so that the output for the debug
+    # tag looks nicer
+    def pretty_print q
+      t = {}
+      each do |key, value|
+        t[key] = value
+      end
+      q.pp_hash(t)
+    end
+
+    # method that resolves dotted names. Internal it first
+    # tries to access hash keys, later array indices and if
+    # this also does not work it looks for a ruty_safe?
+    # function on the object, calls it with the current part
+    # of the dotted name, and if it returns true it calls it
+    # without arguments and uses the output as new object for
+    # the next part.
+    #
+    #   {{ foo.bar.blah.42 }}
+    #
+    # could for example resolve this:
+    #
+    #   {{ foo['bar']['blah'][42] }}
+    # 
+    # call this method only with symbols, numbers and strings
+    # are meant to be catched somewhere first.
+    def resolve path
+      # start a recursive lookup#
+      current = self
+      path.to_s.split(/\./).each do |part|
+        part_sym = part.to_sym
+        # try hash like objects (with has_key? and [])
+        if current.respond_to?(:has_key?) and tmp = current[part_sym]
+          current = tmp
+        # try hash like objects with integers and array. If this
+        # fails we don't try any longer because method names which
+        # start with numbers are illegal.
+        elsif part =~ /^-?\d+$/
+          if current.respond_to?(:fetch) or current.respond_to?(:has_key?) \
+             and tmp = current[part.to_i]
+            current = tmp
+          else
+            return nil
+          end
+        # try method calls on objects with ruty_safe? methods
+        elsif current.respond_to?(:ruty_safe?) and
+              current.ruty_safe?(part_sym)
+          current = current.send(part_sym)
+        # fail with nil in all other cases.
+        else
+          return nil
+        end
+      end
+      
+      current
+    end
+
+    # apply filters on a value
+    def apply_filters value, filters
+      filters.each do |filter|
+        name, args = filter[0], filter[1..-1]
+        filter = Filters[name]
+        raise TemplateRuntimeError, "filter '#{name}' missing" if filter.nil?
+        args.map! do |arg|
+          if arg.kind_of?(Symbol)
+            resolve(arg)
+          else
+            arg
+          end
+        end
+        value = filter.call(self, value, *args)
+      end
+      value
+    end
+  end
+end

data/lib/ruty/datastructure.rb

@@ -0,0 +1,180 @@
+# = Ruty Data Structure
+#
+# Author:: Armin Ronacher
+# 
+# Copyright (c) 2006 by Armin Ronacher
+#
+# You can redistribute it and/or modify it under the terms of the BSD license.
+
+require 'stringio'
+
+module Ruty::Datastructure
+
+  # baseclass for all nodes
+  class Node
+    
+    # render the block and call the block for each return value
+    def render_node context, stream
+    end
+  end
+
+  # node list class. can store multiple nodes
+  class NodeList < Node
+    include Enumerable
+    attr_reader :parser
+    
+    def initialize initial=nil, parser=nil
+      @nodes = initial || []
+      @parser = parser
+    end
+
+    def << node
+      @nodes << node
+    end
+
+    def each &block
+      @nodes.each(&block)
+    end
+
+    def render_node context, stream
+      @nodes.each do |node|
+        node.render_node(context, stream)
+      end
+      nil
+    end
+  end
+
+  # a node that stores text data
+  class TextNode < Node
+    
+    def initialize text
+      @text = text
+    end
+
+    def render_node context, stream
+      stream << @text
+      nil
+    end
+  end
+
+  # a node that stores a variable plus filters
+  class VariableNode < Node
+    
+    def initialize name, filters
+      @name = name
+      @filters = filters
+    end
+
+    def render_node context, stream
+      value = context.apply_filters(context.resolve(@name), @filters).to_s
+      stream << value if not value.empty?
+      nil
+    end
+  end
+
+  # stream class. Some kind of write only array which just
+  # accepts nodes and can be converted into a nodelist afterwards.
+  class NodeStream
+    def initialize parser
+      @parser = parser
+      @stream = []
+      @nodelist = nil
+    end
+
+    # add a new node to the stream
+    def << node
+      raise RuntimeError, 'cannot write to closed stream' if @nodelist
+      @stream << node
+    end
+
+    # convert the streamed data into a nodelist. This
+    # automatically closes the stream, you can't write
+    # to it later.
+    def to_nodelist
+      @nodelist = NodeList.new(@stream, @parser) if not @nodelist
+      @nodelist
+    end
+  end
+
+  # stream for the tokenize function
+  class TokenStream
+
+    def initialize
+      @stream = []
+      @closed = false
+      @pushed = []
+    end
+
+    def next
+      if not @pushed.empty?
+        @pushed.pop
+      else
+        @stream.pop
+      end
+    end
+
+    def eos?
+      @stream.empty?
+    end
+
+    # push a token to a closed or nonclosed stream.
+    # pushed tokens are always processed first in
+    # reverse order
+    def push token
+      @pushed << token
+    end
+
+    # add one token to a non closed stream
+    # once the stream is closed you can still add tokens
+    # to the stream but by pushing back which you can do
+    # by calling push.
+    def << token
+      raise RuntimeError, 'cannot write to closed stream' if @closed
+      @stream << token
+    end
+
+    # close the stream and return self
+    def close
+      raise RuntimeError, 'cannot close closed token stream' if @closed
+      @closed = true
+      @stream.reverse!
+      self
+    end
+  end
+
+  # special class that is used by some ruty tags to
+  # provide data for the context that requires calculation
+  # or rendering and is optional (for example block.super)
+  class Deferred
+    
+    def initialize callables=nil
+      @callables = callables || {}
+    end
+
+    def add_deferred name, &block
+      @callables[name] = block
+    end
+
+    def ruty_safe? name
+      @callables.include?(name)
+    end
+
+    def method_missing name
+      @callables[name].call if @callables.include?(name)
+    end
+
+    # override the pretty print callback function so that we
+    # get values instead of just a lot of proc inspect outputs.
+    def pretty_print q
+      unknown = (Class.new{
+        define_method(:inspect) { '?' }
+      }).new
+      t = {}
+      @callables.each do |name, callable|
+        t[name] = callable.call rescue unknown
+      end
+      q.pp_hash(t)
+    end
+  end
+
+end

data/lib/ruty/filters.rb

@@ -0,0 +1,188 @@
+# = Ruty Builtin Tags
+#
+# Author:: Armin Ronacher
+# 
+# Copyright (c) 2006 by Armin Ronacher
+#
+# You can redistribute it and/or modify it under the terms of the BSD license.
+
+require 'uri'
+
+module Ruty
+
+  # default class for all filter collections
+  class FilterCollection
+
+    # iterate over all filters, used by Filters to
+    # register them.
+    def self.each_filter &block
+      instance = self.new
+      instance_methods(false).each do |method_name|
+        name = method_name.to_sym
+        filter = instance.method(name).to_proc
+        block.call(name, filter)
+      end
+    end
+  end
+
+  # builtin filter collection
+  class StandardFilters < FilterCollection
+
+    # convert a string to lowercase
+    def lower context, value
+      value.to_s.downcase
+    end
+
+    # convert a string to uppercase
+    def upper context, value
+      value.to_s.upcase
+    end
+
+    # capitalize a string
+    def capitalize context, value
+      value.to_s.capitalize
+    end
+
+    # truncate a string down to n characters
+    def truncate context, value, n=80, ellipsis='...'
+      if value
+        if (value = value.to_s).length > n
+          value[0...n] + ellipsis
+        else
+          value
+        end
+      else
+        ''
+      end
+    end
+
+    # join an array with a string between the array elements
+    def join context, value, char=''
+      if value.respond_to?(:join)
+        value.join(char)
+      else
+        value
+      end
+    end
+
+    # replace a substring with another
+    # if the replacement string isn't given it replaces it with
+    # an empty value.
+    def replace context, value, search, repl=''
+      value.to_s.gsub(search.to_s, repl.to_s)
+    end
+
+    # return a sorted version of an array or object that
+    # supports sorting. If it does not this function returns
+    # the value unchanged.
+    def sort context, value
+      if value.respond_to?(:sort)
+        value.sort
+      else
+        value
+      end
+    end
+
+    # reverse an item that supports reversing. else return
+    # the item unchanged
+    def reverse context, value
+      if value.respond_to?(:reverse)
+        value.reverse
+      else
+        value
+      end
+    end
+
+    # get the first item of an array
+    def first context, value
+      if value.respond_to?(:first)
+        value.first
+      elsif value.respond_to?(:[])
+        value[0] || value
+      else
+        value
+      end
+    end
+
+    # get the last item of an array
+    def last context, value
+      if value.respond_to?(:last)
+        value.last
+      elsif value.respond_to?(:[])
+        value[-1] || value
+      else
+        value
+      end
+    end
+
+    # xml escape a string
+    def escape context, value, attribute=false
+      value = value.to_s.gsub(/&/, '&amp;')\
+                        .gsub(/>/, '&gt;')\
+                        .gsub(/</, '&lt;')
+      value.gsub!(/"/, '&quot;') if attribute
+      value
+    end
+
+    # urlencode an string
+    def urlencode context, value
+      URI.escape(value.to_s)
+    end
+
+    # return the length of an object
+    def length context, value
+      if value.respond_to?(:size)
+        value.size
+      elsif value.respond_to?(:length)
+        value.length
+      elsif value.respond_to?(:count)
+        value.count
+      else
+        0
+      end
+    end
+
+  end
+
+  # module used to lookup filters
+  module Filters
+    @collections = {}
+    @filters = {}
+
+    class << self
+      # return filter `name`
+      def [] name
+        @filters[name]
+      end
+
+      # register a new filter collection
+      def register_collection collection
+        return if @collections.include? collection
+        collection.each_filter {|name, filter|
+          @filters[name] = filter
+        }
+        @collections[collection] = true
+        nil
+      end
+
+      # add just one filter using a code block:
+      # Ruty::Filters::add('swapcase') { |context, value|
+      #   value.to_s.swap_case
+      # }
+      def add name, &block
+        raise AttributeError, 'block required' if !block
+        @filters[name] = block
+      end
+
+      # return an array of symbols containing the names
+      # of all registered filters.
+      def all
+        return @filters.keys
+      end
+    end
+  end
+
+  # bootstrap filters module and register builtin filters
+  Filters.register_collection(StandardFilters)
+
+end