ruty 0.0.1

data/lib/ruty/tags/capture.rb

@@ -0,0 +1,28 @@
+# = Ruty Capture Tag
+#
+# Author:: Armin Ronacher
+# 
+# Copyright (c) 2006 by Armin Ronacher
+#
+# You can redistribute it and/or modify it under the terms of the BSD license.
+
+class Ruty::Tags::Capture < Ruty::Tag
+
+  def initialize parser, argstring
+    if not argstring =~ /^as\s+([a-zA-Z_][a-zA-Z0-9_]*)$/
+      parser.fail('syntax for capture tag: {% capture as <variable> %}')
+    end
+
+    @name = $1.to_sym
+    @nodelist = parser.parse_until { |n, a| n == :endcapture }
+  end
+
+  def render_node context, stream
+    substream = ''
+    @nodelist.render(context, substream)
+    context[@name] = substream
+  end
+
+  Ruty::Tags.register(self, :include)
+
+end

data/lib/ruty/tags/conditional.rb

@@ -0,0 +1,59 @@
+# = Ruty Conditional 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.
+
+class Ruty::Tags::If < Ruty::Tag
+
+  def initialize parser, argstring
+    # parse everything until the next else or endif tag
+    # and save in a variable if it was a else tag for
+    # postprocessing.
+    was_else = false
+    @body = parser.parse_until do |name, a|
+      if [:endif, :else].include? name
+        was_else = name == :else
+        true
+      end
+    end
+
+    args = parser.parse_arguments(argstring)
+    @else_body = parser.parse_until { |name, a| name == :endif } if was_else
+
+    if not [1, 2].include?(args.length) or \
+       (args.length == 2 and args[0] != :not)
+      parser.fail('invalid syntax for if tag')
+    end
+
+    @negated = args.length == 2
+    @item = @negated ? args[1] : args[0]
+  end
+
+  def render_node context, stream
+    item = context.resolve(@item)
+    if item == false
+      val = false
+    elsif item.respond_to?(:nonzero?)
+      val = item.nonzero?
+    elsif item.respond_to?(:empty?)
+      val = !item.empty?
+    elsif item.respond_to?(:size)
+      val = item.size > 0
+    elsif item.respond_to?(:length)
+      val = item.length > 0
+    else
+      val = !item.nil?
+    end
+    if @negated ? !val : val
+      @body.render_node(context, stream)
+    elsif @else_body
+      @else_body.render_node(context, stream)
+    end
+  end
+
+  Ruty::Tags.register(self, :if)
+
+end

data/lib/ruty/tags/debug.rb

@@ -0,0 +1,28 @@
+# = Ruty Debug Tag
+#
+# 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'
+require 'pp'
+
+class Ruty::Tags::Debug < Ruty::Tag
+
+  def initialize parser, argstring
+    parser.fail('debug tag takes no arguments') if not argstring.empty?
+  end
+
+  def render_node context, stream
+    buffer = StringIO.new
+    PP.pp(context, buffer)
+    buffer.rewind
+    stream << buffer.read.strip
+    buffer.close
+  end
+
+  Ruty::Tags.register(self, :debug)
+
+end

data/lib/ruty/tags/filter.rb

@@ -0,0 +1,27 @@
+# = Ruty Filter Tag
+#
+# Author:: Armin Ronacher
+# 
+# Copyright (c) 2006 by Armin Ronacher
+#
+# You can redistribute it and/or modify it under the terms of the BSD license.
+
+class Ruty::Tags::Filter < Ruty::Tag
+
+  def initialize parser, argstring
+    @filters = parser.parse_arguments('|' + argstring)
+    parser.fail('filter tag requires at least on filter') if @filters.empty?
+    @nodelist = parser.parse_until { |n, a| n == :endfilter }
+  end
+
+  def render_node context, stream
+    substream = Ruty::Datastructure::OutputStream.new
+    @nodelist.render_node(context, substream)
+    value = context.apply_filters(substream.to_s, @filters).to_s
+    stream << value if not value.empty?
+    nil
+  end
+
+  Ruty::Tags.register(self, :filter)
+
+end

data/lib/ruty/tags/forloop.rb

@@ -0,0 +1,83 @@
+# = Ruty For Loop Tag
+#
+# Author:: Armin Ronacher
+# 
+# Copyright (c) 2006 by Armin Ronacher
+#
+# You can redistribute it and/or modify it under the terms of the BSD license.
+
+class Ruty::Tags::ForLoop < Ruty::Tag
+
+  def initialize parser, argstring
+    # parse everything until the next else or endfor tag
+    # and save in a variable if it was a else tag or an
+    # endfor tag so that we can parse the second part if
+    # required later.
+    was_else = false
+    @body = parser.parse_until do |name, a|
+      if [:endfor, :else].include? name
+        was_else = name == :else
+        true
+      end
+    end
+    
+    args = parser.parse_arguments(argstring)
+    @else_body = parser.parse_until { |name, a| name == :endfor } if was_else
+    if args.length != 3 or args[1] != :in
+      parser.fail('invalid syntax for for-loop tag')
+    end
+    @item = args[0]
+    @iterable = args[2]
+  end
+
+  def render_node context, stream
+    iterable = context.resolve(@iterable)
+    length = 0
+    if iterable.respond_to?(:each)
+      if iterable.respond_to?(:size)
+        length = iterable.size
+      elsif iterable.respond_to?(:length)
+        length = iterable.length
+      end
+    end
+
+    if length > 0
+      index = 0
+      parent = context[:loop]
+      context.push
+
+      iterable.each do |item|
+        break if index == length
+        context[@item] = item
+        context[:loop] = {
+          :parent =>          parent,
+          :index =>           index + 1,
+          :index0 =>          index,
+          :revindex =>        length - index,
+          :revindex0 =>       length - index - 1,
+          :first =>           index == 0,
+          :last =>            length - index == 1,
+          :length =>          length,
+          :even =>            index % 2 != 0,
+          :odd =>             index % 2 == 0
+        }
+        @body.render_node(context, stream)
+        index += 1
+      end
+      if index != 0
+        context.pop
+        return nil
+      end
+    end
+
+    # if we reach this point there was no iteration. either because
+    # we tried to iterate something without a size or it was an object
+    # that isn't iterable, render the else_body if given
+    @else_body.render_node(context, stream) if @else_body
+    context.pop
+    nil
+  end
+
+  Ruty::Tags.register(self, :for)
+
+end

data/lib/ruty/tags/inclusion.rb

@@ -0,0 +1,31 @@
+# = Ruty Include 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.
+
+# simple include tag. just includes another template at
+# the current position. (for header/footer inclusion for
+# example, although it's better to use extends in combination
+# with some blocks)
+class Ruty::Tags::Include < Ruty::Tag
+
+  def initialize parser, argstring
+    if not argstring =~ /^("')(.*?)\1$/
+      parser.fail('include takes exactly one argument which must be ' +
+                  'an hardcoded string')
+    end
+
+    # load given template using the load_local function of the parser
+    @nodelist = parser.load_local(argstring[1...-1])
+  end
+
+  def render_node context, stream
+    @nodelist.render_node(context, stream)
+  end
+
+  Ruty::Tags.register(self, :include)
+
+end

data/lib/ruty/tags/inheritance.rb

@@ -0,0 +1,80 @@
+# = Ruty Template Inheritance
+#
+# Author:: Armin Ronacher
+# 
+# Copyright (c) 2006 by Armin Ronacher
+#
+# You can redistribute it and/or modify it under the terms of the BSD license.
+
+# special tag that marks a part of a template for inheritance.
+# If a template extends from a template with a block tag with
+# the same name it will replace the block in the inherited
+# template with the block with the same name in the current
+# template.
+class Ruty::Tags::Block < Ruty::Tag
+
+  def initialize parser, argstring
+    if not argstring =~ /^[a-zA-Z_][a-zA-Z0-9_]*$/
+      parser.fail('Invalid syntax for block tag')
+    end
+    @name = argstring.to_sym
+    @stack = [parser.parse_until { |name, a| name == :endblock }]
+
+    blocks = (parser.storage[:blocks] ||= {})
+    parser.fail("block '#{@name}' defined twice") if blocks.include?(@name)
+    blocks[@name] = self
+  end
+
+  def add_layer nodelist
+    @stack << nodelist
+  end
+
+  def render_node context, stream, index=-1
+    context.push
+    context[:block] = Ruty::Datastructure::Deferred.new(
+      :super =>     Proc.new {
+        render_node(context, stream, index - 1) if index.abs <= @stack.size
+      },
+      :depth =>     Proc.new { index.abs },
+      :name =>      Proc.new { @name }
+    )
+    @stack[index].render_node(context, stream)
+    context.pop
+    nil
+  end
+
+  Ruty::Tags.register(self, :block)
+
+end
+
+# tag used to load a template from another file. must be the first
+# tag of a document!
+class Ruty::Tags::Extends < Ruty::Tag
+
+  def initialize parser, argstring
+    if not parser.first
+      parser.fail('extends tag must be at the beginning of a template')
+    elsif not argstring =~ /^(["'])(.*?)\1$/
+      parser.fail('extends takes exactly one argument which must be ' +
+                  'an hardcoded string')
+    end
+
+    # parse the template to the end and load parent nodelist
+    parser.parse_all
+    @nodelist = parser.load_local(argstring[1...-1])
+    blocks = @nodelist.parser.storage[:blocks] || {}
+
+    # iterate over all blocks found while parsing and add them
+    # to the parent nodelist which will be the new nodelist
+    (parser.storage[:blocks] || []).each do |name, tag|
+      blocks[name].add_layer(tag) if blocks.include?(name)
+    end
+  end
+
+  def render_node context, stream
+    @nodelist.render_node(context, stream)
+  end
+
+  Ruty::Tags.register(self, :extends)
+
+end

data/lib/ruty/tags/looptools.rb

@@ -0,0 +1,85 @@
+# = Ruty Loop Tool 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.
+
+# A tag that cycles through a list of values each iteration
+# Useful for example if you want alternating rows:
+#
+#   {% for row in rows %}
+#     <tr class="{% cycle 'row1', 'row2' %}">
+#       <td>..</td>
+#     </tr>
+#   {% endfor %}
+class Ruty::Tags::Cycle < Ruty::Tag
+
+  def initialize parser, argstring
+    args = parser.parse_arguments(argstring)
+    parser.fail('At least one item is required for cycle') if args.empty?
+    @items = args
+  end
+
+  def render_node context, stream
+    item = @items[context[self] = ((context[self] || -1) + 1) % @items.length]
+    item = context.resolve(item) if item.is_a?(Symbol)
+    stream << item.to_s
+    nil
+  end
+
+  Ruty::Tags.register(self, :cycle)
+
+end
+
+
+# just render everything between the tag and the closing
+# endifchanged tag if the given variable hasn't changed
+# from the last iteration. If no variable is given the
+# block will check it's own rendering against the
+# rendering of the last iteration.
+#
+# {% for day in days %}
+#   <div class="day">
+#     <h2>{{ day.name|escape }}</h2>
+#     {% for entry in day.entries %}
+#       {% ifchanged entry.pub_date.hour %}
+#         <h3>{{ entry.pub_date }}</h3>
+#       {% endifchanged %}
+#       ...
+#     {% endfor %}
+#   </div>
+# {% endfor %}
+class Ruty::Tags::IfChanged < Ruty::Tag
+
+  def initialize parser, argstring
+    args = parser.parse_arguments(argstring)
+    if not [0, 1].include?(args.length)
+      parser.fail('ifchanged-tag takes at most one argument')
+    end
+    @arg = args[0]
+    @body = parser.parse_until { |name, a| name == :endifchanged }
+  end
+
+  def render_node context, stream
+    if not @arg
+      substream = Datastructure::OutputStream.new
+      @body.render_node(context, substream)
+      this_iteration = substream.to_s
+      if this_iteration != context[self]
+        block << this_iteration
+        context[self] = this_iteration
+      end
+    else
+      item = (@arg.is_a?(Symbol)) ? context.resolve(@arg) : @arg
+      if item != context[self]
+        @body.render_node(context, stream)
+        context[self] = item
+      end
+    end
+    nil
+  end
+
+  Ruty::Tags.register(self, :ifchanged)
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: ruty
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-01-21 00:00:00 +01:00
+summary: A Template-Engine inspired by the jinja engine
+require_paths: 
+- lib
+email: 
+homepage: 
+rubyforge_project: 
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: "true"
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Armin Ronacher
+files: 
+- lib/ruty
+- lib/ruty.rb
+- lib/ruty/constants.rb
+- lib/ruty/context.rb
+- lib/ruty/datastructure.rb
+- lib/ruty/filters.rb
+- lib/ruty/loaders
+- lib/ruty/loaders.rb
+- lib/ruty/parser.rb
+- lib/ruty/tags
+- lib/ruty/tags.rb
+- lib/ruty/loaders/filesystem.rb
+- lib/ruty/tags/capture.rb
+- lib/ruty/tags/conditional.rb
+- lib/ruty/tags/debug.rb
+- lib/ruty/tags/filter.rb
+- lib/ruty/tags/forloop.rb
+- lib/ruty/tags/inclusion.rb
+- lib/ruty/tags/inheritance.rb
+- lib/ruty/tags/looptools.rb
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: []
+