galena 0.0.1

data/lib/galena.rb

@@ -0,0 +1,324 @@
+# = Galena
+#
+# Copyright (c) 2006 Brad Phelan
+# 
+# Permission is hereby granted, free of charge, to any person obtaining a copy of
+# this software and associated documentation files (the "Software"), to deal in
+# the Software without restriction, including without limitation the rights to
+# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+# of the Software, and to permit persons to whom the Software is furnished to do
+# so, subject to the following conditions:
+# 
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+# 
+# Galena a bright shiny obsidian black oxide of lead which I fell in love with
+# whilst working at Pasminco Mines as a student many years back. Within the
+# expanse of black Galena crysta there are to be found many tiny ruby crystals.
+#
+# More precisely, in this context, Galena is text with bit of Ruby embedded
+# along similar lines to ERB. However it is different to ERB in that it uses
+# metaprogramming techniques to create templated text methods on any class
+# you are creating. Ruby methods are dynamically added to the class. Eval
+# and binding are never used. In theorey this should make these templates
+# much faster than ERB, though benchmarks need to be done.
+#
+#
+# A simple example is 
+#
+#     class Foo
+#       tdef :bar, "food" <<-END
+#          eat  %=food=% 
+#       END
+#     end
+#
+#     foo = Foo.new
+#     puts foo.bar "curry"
+#
+#     eat curry
+#
+# See #galena_test.rb for a full example
+#
+#   :include:galena_test.rb
+#
+module Galena
+
+    # Adds a method called #name to the enclosing class. The args
+    # to the methods are the comma seperated list defined in the
+    # string #args. The #text of the template is the final 
+    # parameter. 
+    #
+    # The template #text accepts the following types of markup.
+    #
+    # Given that Ruby does not require brackets and the magic of
+    # here documents, you can make the template look very close
+    # to what a method definition would look like
+    #
+    #     tdef :foo, "a,b,c", <<-END
+    #       a - %= a =%
+    #       b - %= b =%
+    #       c - %= b =%
+    #     END
+    #
+    # A line beginning with any whitespace followed by <b>^</b>
+    # designates a line of real Ruby code to be executed.
+    #
+    # A line containing ruby code embedded between the markers
+    # <b>%=</b> and <b>=%</b> will inline the result of the
+    # evaluation of the Ruby code. 
+    #
+    # A line beginning with any whitespace followed by </b>^=</b>
+    # designates a template sub-block which should be a function
+    # that processes a closure. For example the two template
+    # methods
+    #
+    #     tdef window <<-END
+    #       <div>
+    #           <div>window</div>
+    #           %= yield =%
+    #       </div>
+    #     END
+    #
+    #     tdef foo_window <<-END
+    #       ^= window do 
+    #           foo
+    #       ^= end
+    #     END
+    #
+    # result in text
+    #
+    #   <div>
+    #       <div>window</div>
+    #       foo
+    #   </div>
+    #
+    # Note that foo has been dedented to align with the above div.
+    # Text within a sublock is dedented to left align with the 
+    # leading <b>^=</b> of the block.
+    #
+    # The generated method has access to all instance and class variables
+    # of the enclosing class and it's instances. 
+    #
+    # You can control the indent of text placed within loops of conditionals
+    # by declaring the ruby code lines with the below markers
+    # 
+    #   ^>
+    #   
+    # or
+    #  
+    #   ^<
+    #
+    # for example
+    #
+    #     foo
+    #     ^ for i in (1..2)
+    #       %= i =%
+    #     ^ end
+    #     bar
+    #
+    # would normally output
+    #
+    #     foo
+    #       1
+    #       2
+    #     bar
+    #
+    # but if you do
+    #
+    #     foo
+    #     ^< for i in (1..2)
+    #       %= i =%
+    #     ^> end
+    #     bar
+    #
+    # you get
+    #
+    #     foo
+    #     1
+    #     2
+    #     bar
+    #
+    # A more detailed example 
+    #
+    #   :include:galena_test.rb
+    def tdef(name, args, text) 
+        text = Galena.compile(Galena.ladj(Galena.normalize(text)))
+        text = "def #{name}(" + ( args.split(",").collect {|a| a }.join ", " ) +
+		 ")\n" + text + "\nend\n" 
+         text
+        begin
+            block = class_eval(text);
+        rescue Exception => mes
+            # Generate a nice error message for
+            # the user to find out what went wrong
+            msg = "\n-----------------------------------\n"
+            lnum = 0
+            text.each_line do |line|
+                lnum = lnum + 1
+                msg << lnum.to_s << ":\t" << line
+            end
+            msg << "\n\n" << mes
+            throw msg
+        end
+    end
+
+    # indent text by #pad spaces
+    def Galena.indent text, pad
+        text.gsub(/^/, " " * pad)
+    end
+
+    # left adjust the text by #pad spaces
+    def Galena.ladj text, pad=0
+        len = 10000 
+        text.scan(/^\s+/){|s| len = s.length if s.length < len }
+        rexp = "^\\s{#{len},#{len}}"
+        text.gsub(Regexp.new(rexp), " " * pad)
+    end
+
+    # balances \#= and \#=end blocks
+    class BalanceStack
+
+        def initialize
+            @stack = []
+            @seeking = false
+            @block = false
+        end
+
+        # process a new line
+        def do_line line
+            s_len = line.match(/^\s*/)[0].length
+            case line
+            when /^\s*\^</
+                @block = false
+                push(s_len)
+                @seeking = true
+            when /^\s*\^>/
+                pop
+            else
+                if @seeking
+                    if @block == true
+                       self.dedent = 0
+                    else
+                        self.dedent = dedent + s_len - indent
+                    end
+                end
+                @seeking = false
+            end
+            # puts "#{dedent}, #{@stack.length}, #{line}"
+            if @stack.empty?
+                line
+            else
+                line = Galena.ladj(line, s_len - dedent)
+            end
+        end
+
+        # indent a line
+        def indent
+            @stack.last[0]
+        end
+
+        # dedent a line
+        def dedent=(dd)
+            @stack.last[1]=dd
+        end
+
+        # return the current dedent
+        def dedent(p=0)
+            if @stack.empty?
+                0
+            else
+                @stack.last[-1-p]
+            end
+        end
+
+        private
+
+        def push(indent)
+            @stack.push([indent, dedent])
+        end
+
+        def pop
+            @stack.pop
+        end
+    end
+
+    def Galena.balance(text)
+        stack = BalanceStack.new
+        seeking = false
+        text.each_line do |line|
+            line = stack.do_line(line)
+            yield line
+        end 
+    end
+
+    # normalizes the Ruby markup so that the resulting
+    # output will code will generate text with the expected
+    # indent structure. #normalize and it's workhorse
+    def Galena.normalize(text)
+        out = []
+        Galena.balance(text) do |line|
+            out << line
+        end
+        out = out.join
+    end
+
+    private
+
+    def Galena.tout(idx)
+        "_tout[#{idx}]"
+    end
+
+    def Galena.compile(text)
+        indent = 0
+        src = <<-END
+        _tout=[]
+        _tout[0]=""
+        END
+        scope = 0
+        dedent = false
+
+        text.each_line do |line|
+
+            current_indent = line.match(/^\s*/)[0].length
+
+            case line
+            when /^\s*\^=\s*end/
+                # The closing ^=end determines the indent of the
+                # block.
+                capture_indent = current_indent
+                scope = scope - 1
+                src << "end, #{capture_indent} ) \n"
+            when /^\s*\^=/
+                src << tout(scope) << " << Galena.indent( "
+                scope = scope + 1
+                src << line.gsub(/^\s*\^=/,"")
+                src << tout(scope) << " = \"\"\n" 
+            when /^\s*\^[<>]?/
+                src << line.gsub(/^\s*\^[<>]?/,"")
+            else
+                src << tout(scope) << "<<(\"" 
+                # Replace the inline substition tokens
+                src << line.chomp.gsub(/(\s*)%=(.*?)=%/) do
+                     "\" + Galena.ladj((#{$2}).to_s, " + ($1.length).to_s + ') + "' 
+                end
+
+                src << "\\n\")\n"
+            end
+        end
+        if scope != 0
+            throw "Unbalanced ^= with ^=end : " << scope.to_s
+        end
+        src << tout(scope) << "\n"
+              #puts src
+              #src
+    end
+end
+

data/lib/galena_test.rb

@@ -0,0 +1,67 @@
+#! /usr/bin/ruby
+require 'galena'
+require 'enumerator'
+
+include Galena
+
+class MyText 
+
+    def initialize
+        @drink = "koolaid"
+        @food  = "dogfood"
+    end
+
+    # Creates a method called page which
+    # accepts an array and prints it in 
+    # an html table with four columns.
+    tdef :page, "data", <<-END
+        <html>
+            <head>
+            </head>
+            <body>
+            ^= tableize(data, 4) do |item|
+                foo
+                ^= window("Wow") do
+                    This is my item %=item=%
+                    boo
+                ^= end
+            ^= end
+            </body>
+        </html>
+    END
+    
+
+    # Generates an html table with a varying
+    # number of columns
+    tdef :tableize, "data, columns", <<-END
+        <table>
+            ^< data.each_slice(columns) do |slice|
+                <tr>
+                    ^< slice.each do |s|
+                        <td> 
+                            %=yield s=%
+                        </td>
+                    ^> end 
+                </tr>
+            ^> end 
+        </table>
+    END
+
+    
+    
+    # Generates an html div with a title and some
+    # contents defined by the yielded block
+    tdef :window, "title", <<-END
+        <div>
+            <div style="width:100; color:blue;%">
+                %=title=%
+            </div>
+            %=yield=%
+        </div>
+    END
+
+end
+
+h = MyText.new
+puts h.page(1..10)
+

data/rakefile.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+
+PKG_VERSION="0.0.1"
+PKG_FILES= [
+    "lib/galena.rb",
+    "lib/galena_test.rb",
+    "rakefile.rb" ]
+
+spec = Gem::Specification.new do |s|
+    s.platform = Gem::Platform::RUBY
+    s.summary = "Object Oriented Template Engine"
+    s.name = 'galena'
+    s.version = PKG_VERSION
+    s.requirements << 'none'
+    s.require_path = 'lib'
+    s.autorequire = ''
+    s.files = PKG_FILES
+    s.has_rdoc = true
+    s.rdoc_options << '--title' << ' Galena -- OO Templating' <<
+                         '--main' << 'lib/galena.rb' <<
+                         '-S'
+    s.description = <<EOF
+Object oriented Ruby template engine with advanced support
+for blocks/closures used as arguments to layouts.
+EOF
+end
+
+gem = Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_zip = true
+    pkg.need_tar = true
+end
+
+desc "Default Task packages this into a gem"
+task :default => :package

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: galena
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2006-09-13 00:00:00 +02:00
+summary: Object Oriented Template Engine
+require_paths: 
+- lib
+email: 
+homepage: 
+rubyforge_project: 
+description: Object oriented Ruby template engine with advanced support for blocks/closures used as arguments to layouts.
+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: []
+
+files: 
+- lib/galena.rb
+- lib/galena_test.rb
+- rakefile.rb
+test_files: []
+
+rdoc_options: 
+- --title
+- " Galena -- OO Templating"
+- --main
+- lib/galena.rb
+- -S
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: 
+- none
+dependencies: []
+