ramaze 0.3.9.1 → 2023.01.06

data/lib/ramaze/template/haml.rb

@@ -1,37 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'haml/engine'
-
-module Ramaze
-  module Template
-
-    # Is responsible for compiling a template using the Haml templating engine.
-    # Can be found at: http://haml.hamptoncatlin.com/
-
-    class Haml < Template
-
-      ENGINES[self] = %w[ haml ]
-
-      class << self
-
-        # Transform via Haml templating engine
-
-        def transform action
-          haml = wrap_compile(action)
-          haml.to_html(action.instance, action.binding.locals)
-        end
-
-        # Instantiates Haml::Engine with the template and haml_options trait from
-        # the controller.
-
-        def compile(action, template)
-          opts = action.controller.trait[:haml_options] || {}
-          opts.merge! :filename => action.template if action.template
-
-          ::Haml::Engine.new(template, opts)
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/template/liquid.rb

@@ -1,36 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'liquid'
-
-module Ramaze
-  module Template
-
-    # Is responsible for compiling a template using the Liquid templating engine.
-    # Can be found at: http://home.leetsoft.com/liquid
-
-    class Liquid < Template
-
-      ENGINES[self] = %w[ liquid ]
-
-      class << self
-
-        # initializes the handling of a request on the controller.
-        # Creates a new instances of itself and sends the action and params.
-        # Also tries to render the template.
-        # In Theory you can use this standalone, this has not been tested though.
-
-        def transform action
-          template = reaction_or_file(action)
-
-          instance = action.instance
-          hash     = instance.instance_variable_get("@hash") || {}
-          template = ::Liquid::Template.parse(template)
-          options  = instance.ancestral_trait[:liquid_options]
-
-          template.render(hash, options)
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/template/markaby.rb

@@ -1,52 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'markaby'
-
-module Ramaze
-  module Template
-
-    # Is responsible for compiling a template using the Markaby templating engine.
-    # Can be found at: http://code.whytheluckystiff.net/markaby/
-
-    class Markaby < Template
-      include Ramaze::Helper::Methods
-
-      ENGINES[self] = %w[ mab ]
-
-      class << self
-
-        # Entry point for Action#render
-
-        def transform action
-          result, file = result_and_file(action)
-
-          result = transform_string(file, action) if file
-          result.to_s
-        end
-
-        # Takes a string and action, instance_evals the string inside a mab
-        # block that gets the instance_variables of the original
-        # action.instance passed.
-
-        def transform_string string, action
-          instance = action.instance
-          ivs = extract_ivs(instance)
-
-          instance.send(:mab, ivs) do
-            instance_eval(string)
-          end
-        end
-
-        # Generate a hash from instance-variables
-
-        def extract_ivs(controller)
-          controller.instance_variables.inject({}) do |hash, iv|
-            sym = iv.gsub('@', '').to_sym
-            hash.merge! sym => controller.instance_variable_get(iv)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/template/nagoro.rb

@@ -1,51 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'nagoro'
-
-module Ramaze
-  module Template
-
-    # Is responsible for compiling a template using the Nagoro templating engine.
-
-    class Nagoro < Template
-
-      ENGINES[self] = %w[ xhtml nag ]
-
-      PIPES = ::Nagoro::DEFAULT_PIPES.dup
-
-      class << self
-
-        # Transforms an action into the XHTML code for parsing and returns
-        # the result
-        def transform action
-          nagoro = wrap_compile(action)
-          file = action.template || action.method
-          nagoro.result(:file => file, :binding => action.binding)
-        end
-
-        def wrap_compile(action, template = nil)
-          template ||= file_or_result(action)
-          caching_compile(action, template)
-        end
-
-        def file_or_result(action)
-          result = render_method(action).to_s
-
-          if file = action.template
-            return File.new(file)
-          end
-
-          result
-        end
-
-        # Compile a template, applying all transformations from the pipeline
-        # and returning an instance of ::Nagoro::Template
-
-        def compile(action, template)
-          ::Nagoro.compile(template)
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/template/none.rb

@@ -1,14 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-module Ramaze
-  module Template
-
-      class None < Template
-        def self.transform action
-          render_method(action)
-        end
-      end
-
-  end
-end

data/lib/ramaze/template/redcloth.rb

@@ -1,24 +0,0 @@
-require 'redcloth'
-
-module Ramaze
-  module Template
-
-    # Is responsible for compiling a template using the RedCloth templating engine.
-    # Can be found at: http://whytheluckystiff.net/ruby/redcloth/
-
-    class RedCloth < Erubis
-      ENGINES[self] = %w[ redcloth ]
-
-      class << self
-        def transform(action)
-          restrictions = action.controller.trait[:redcloth_options] || []
-          rules = action.controller.trait[:redcloth_options] || []
-
-          # Erubis -> RedCloth -> HTML
-          redcloth = ::RedCloth.new(super, restrictions)
-          redcloth.to_html(*rules)
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/template/remarkably.rb

@@ -1,38 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'remarkably/engines/html'
-
-module Ramaze
-  module Template
-
-    # Is responsible for compiling a template using the Remarkably templating engine.
-    # Can be found at: http://rubyforge.org/projects/remarkably
-
-    class Remarkably < Template
-      ENGINES[self] = %w[ rem ]
-
-      class << self
-
-        # Entry point for Action#render
-
-        def transform action
-          result, file = result_and_file(action)
-
-          result = transform_string(file, action) if file
-          result.to_s
-        end
-
-        # Takes a string and action, sets args to action.args and then proceeds
-        # to instance_eval the string inside the action.instance
-
-        def transform_string(string, action)
-          action.instance.instance_eval do
-            args = action.params
-            instance_eval(string)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/template/sass.rb

@@ -1,37 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'sass/engine'
-
-module Ramaze
-  module Template
-
-    # Is responsible for compiling a template using the Sass CSS templating engine.
-    # Can be found at: http://haml.hamptoncatlin.com/
-
-    class Sass < Template
-
-      ENGINES[self] = %w[ sass ]
-
-      class << self
-
-        # Transform via Sass templating engine
-
-        def transform action
-          if response = Response.current
-            response['Content-Type'] = "text/css"
-          end
-          sass = wrap_compile(action)
-          sass.to_css()
-        end
-
-        # Instantiates Sass::Engine with the template and sass_options trait from
-        # the controller.
-
-        def compile(action, template)
-          ::Sass::Engine.new(template, action.controller.trait[:sass_options] || {})
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/template/tagz.rb

@@ -1,79 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require "tagz"
-
-module Ramaze
-  module Template
-
-    # Is responsible for compiling a template using the Tagz templating engine.
-    # Can be found at: http://rubyforge.org/projects/codeforpeople/
-    #   gem install tagz 
-    # be sure you get version 1.0 or higher 
-
-    class Tagz < Template
-      ENGINES[self] = %w[ rb tagz ] 
-
-      class << self
-
-        # Entry point for Action#render
-
-        def transform action
-          result, file = result_and_file(action)
-          if file
-            markup = "tagz{#{ file }}" 
-            action.instance.extend Methods
-            result = eval markup, action.binding, file 
-          end
-          result
-        end
-
-      end
-
-      # Methods defines a host of methods useful inside the context of a view
-      # including print style methods that output content rather that printing to
-      # STDOUT
-
-      module Methods
-        include ::Tagz
-
-      private
-        def << s
-          tagz << s; self 
-        end
-
-        def concat *a 
-          a.each{|s| tagz << s}; self
-        end
-
-        def puts *a
-          a.each{|elem| tagz << "#{ elem.to_s.chomp }#{ eol }"}
-        end
-
-        def print *a
-          a.each{|elem| tagz << elem}
-        end
-
-        def p *a
-          a.each{|elem| tagz << "#{ CGI.escapeHTML elem.inspect }#{ eol }"}
-        end
-
-        def pp *a
-          a.each{|elem| tagz << "#{ CGI.escapeHTML PP.pp(elem, '') }#{ eol }"}
-        end
-
-        def eol
-          if response.content_type =~ %r|text/plain|io
-            "\n"
-          else
-            "<br />"
-          end
-        end
-
-        def __ *a
-          concat eol 
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/template/tenjin.rb

@@ -1,34 +0,0 @@
-require "tenjin"
-require "tempfile"
-
-class Tenjin::Context
-  include Ramaze::Helper::Methods
-  helper :link, :sendfile, :flash, :cgi
-end
-
-module Ramaze
-  module Template
-
-    # Is responsible for compiling a template using the Tenjin templating engine.
-    # Can be found at: http://www.kuwata-lab.com/tenjin/
-
-    class Tenjin < Template
-
-      ENGINES[self] = %w[ rbhtml tenjin ]
-
-      class << self
-        def transform(action)
-          tenjin = wrap_compile(action)
-          context = action.instance.instance_variable_get("@context") || {}
-          tenjin.render(context)
-        end
-
-        def compile(action, template)
-          tenjin = ::Tenjin::Template.new
-          tenjin.convert(template)
-          return tenjin
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/template/xslt.rb

@@ -1,96 +0,0 @@
-#          Copyright (c) 2007  Stephan Maka  stephan@spaceboyz.net
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'xml/libxml'
-require 'xml/xslt'
-require 'thread'
-
-module Ramaze
-
-  # Use the Gestalt helper to put your controller result
-  # into proper XML form
-  #
-  # TODO:
-  # * Error handling
-  # * Maybe prevent extFunction to be called by HTTP
-  module Template
-    class XSLT < Template
-      ENGINES[self] = %w[ xsl ]
-
-      XSLT_EXT_FUNCTIONS_LOCK = Mutex.new
-
-      class << self
-
-        # Entry point for Action#render
-
-        def transform action
-
-          if options = action.instance.ancestral_trait[:xslt_options] and
-              fun_xmlns = options[:fun_xmlns]
-            # If a controller uses extFunctions, lock the whole
-            # transform action with a Mutex to prevent mixing
-            # extFunction binding and callback of two controller
-            # instances with one fun_xmlns.
-            ext_functions_synchronize do
-              register_ext_functions action.instance, fun_xmlns
-              do_transform action
-            end
-
-          else
-            do_transform action
-          end
-
-        end
-
-        private
-
-        def do_transform(action)
-          result, file = result_and_file(action)
-
-          xslt = XML::XSLT.new
-          xslt.xsl = action.template
-          xslt.xml = result
-          xslt.serve
-        end
-
-        def ext_functions_synchronize &block
-          XSLT_EXT_FUNCTIONS_LOCK.synchronize &block
-        end
-
-        def register_ext_functions instance, fun_xmlns
-
-          instance.methods.each do |method|
-            if method =~ /^xslt_.+/
-              method_name = method[5..-1]
-
-              proxy_instance = make_functor(method_name.intern) { |*a|
-                instance.send method.intern, *a
-              }
-
-              XML::XSLT.extFunction method_name.gsub('_', '-'), fun_xmlns, proxy_instance
-            end
-          end
-
-        end
-
-        # Can be replaced by Ruby Facets' Functor pattern
-        def make_functor(m, &block)
-          # Create anonymous class and instantiate;
-          # anonymous because only this one object with this
-          # particular custom method should call &block
-          o = Class.new.new
-
-          class << o
-            def create_method(name, &block)
-              self.class.send(:define_method, name, &block)
-            end
-          end
-
-          o.create_method(m, &block)
-          o
-        end
-
-      end
-    end
-  end
-end

data/lib/ramaze/template.rb

@@ -1,81 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-# This module serves as a namespace for all templates, it will autoload
-# Amrita2, Erubis, Haml, Liquid and Markaby if you refer to them.
-
-module Ramaze
-
-  # Namespace for templating.
-
-  module Template
-
-    COMPILED = {} unless defined?(COMPILED)
-
-    # Place register_engine puts the class and extensions for templating engines
-
-    ENGINES = {} unless defined?(ENGINES)
-
-    AVAILABLE_ENGINES = %w[ Amrita2 Builder Erubis Haml Liquid Markaby Nagoro None RedCloth Remarkably Sass XSLT Tenjin Tagz ]
-
-    AVAILABLE_ENGINES.each do |const|
-      autoload(const, "ramaze/template/#{const.downcase}")
-    end
-
-    # The superclass for all templates, contains the shared behaviour of
-    # the templates and includes Ramaze::Helper::Methods
-
-    class Template
-      include Ramaze::Helper::Methods
-
-      class << self
-
-        # calls result_and_file with the given action and returns the first of
-        # the result of the controller or content of the file.
-
-        def reaction_or_file action
-          result_and_file(action).reverse.compact.first
-        end
-
-        # Takes an Action and returns the result from sending the action.method
-        # to the controller via render_method and reads the contents of the file
-        # if given.
-
-        def result_and_file(action)
-          result = render_method(action)
-
-          if file = action.template
-            content = File.read(file)
-          end
-
-          [result, content]
-        end
-
-        # returns nil if no method is on the action, otherwise it will send the
-        # action and optional parameters to the controller via __send__ and
-        # return the unaltered result
-
-        def render_method(action)
-          return unless method = action.method
-          action.instance.__send__(method, *action.params)
-        end
-
-        # This is a wrapper to use Global.compile without even thinking about it.
-        # Don't use it if your engine is not based on a compile/eval principle.
-
-        def wrap_compile(action, template = nil)
-          template ||= reaction_or_file(action).to_s
-          caching_compile(action, template)
-        end
-
-        def caching_compile(action, template)
-          if Global.compile
-            Cache.compiled[action.relaxed_hash] ||= compile(action, template)
-          else
-            compile(action, template)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ramaze/tool/create.rb

@@ -1,74 +0,0 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-module Ramaze
-  module Tool
-
-    # Create is a simple class used to create new projects based on the proto
-    # directory.
-    #
-    # It is primarly used for this command:
-    #
-    #   ramaze --create project
-    #
-    # where project is the directory you want the content put into.
-
-    class Create
-      class << self
-
-        # a method to create a new project by copying the contents of lib/proto
-        # to the position you specify (project)
-        #
-        # It is just a nice wrapper showing you what files/directories are put
-        # in place.
-
-        def create project
-          @basedir = ::Ramaze::BASEDIR / 'proto'
-          @destdir = Dir.pwd / project
-
-          if File.directory?(@destdir)
-            puts "Error: #{project}/ already exists. Rename or delete directory and try again."
-            return
-          end
-
-          puts "Creating project #{project}"
-
-          FileUtils.mkdir_p(project)
-
-          puts "Copying skeleton project to new project (#@destdir)..."
-
-          directories, files =
-            Dir[@basedir / '**' / '*'].partition{ |f| File.directory?(f) }
-
-          # gem packaging removes empty model directory, so add it in ourselves
-          create_dirs(*Array[ @basedir/'model', *directories ].uniq)
-          copy_files(*files)
-
-          puts "\nStart your new ramaze app: ruby #{project}/start.rb"
-        end
-
-        # create the directories recursivly
-
-        def create_dirs(*dirs)
-          dirs.each do |dir|
-            dest = dir.gsub(@basedir, @destdir)
-
-            puts "Create directory: '#{dest}'"
-            FileUtils.mkdir_p(dest)
-          end
-        end
-
-        # copy the files over
-
-        def copy_files(*files)
-          files.each do |file|
-            dest = file.gsub(@basedir, @destdir)
-
-            puts "Copy file: '#{dest}'"
-            FileUtils.cp(file, dest)
-          end
-        end
-      end
-    end
-  end
-end