rjspotter-ramaze 2009.06.29

data/lib/ramaze/tool/create.rb

@@ -0,0 +1,48 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'ramaze/tool/project_creator'
+
+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
+
+      # Default options passed to Create::create
+      #   :proto  is the directory to duplicate
+      #   :amend  no files may be overwritten but missing files will be added
+      #   :force  will overwrite existing files
+      #   :layout copy one subdirectory in +proto+
+
+      DEFAULT = {
+        :proto => File.join(ROOT, 'proto'),
+        :amend => false,
+        :force => false,
+        :layout => '/',
+      }
+
+      # Using ProjectCreator to copy all files and directories from lib/proto
+      # to another location.
+      # +options+ are described in the DEFAULT constant and should be:
+      #   :force  => (true|false|nil)
+      #   :amend  => (true|false|nil)
+      #   :layout => (String|nil)
+      #   :proto  => String
+
+      def self.create(project, options = {})
+        options = DEFAULT.merge(options)
+        creator = ProjectCreator.new(project, options)
+        creator.create
+      end
+    end
+  end
+end

data/lib/ramaze/tool/project_creator.rb

@@ -0,0 +1,111 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'fileutils'
+require 'find'
+
+class ProjectCreator
+  PROTO = []
+  PROTO << '~/.proto/' if ENV["HOME"] # Guard against Windows
+  attr_accessor :name, :options
+
+  def initialize(name, options = {})
+    @name, @options = name, options
+  end
+
+  def target
+    File.expand_path(name)
+  end
+
+  def proto
+    PROTO.map!{|pr| File.expand_path(pr) }
+    proto = options[:proto] ||= PROTO.find{|f| File.directory?(f) }
+    layout = options[:layout] ||= '/'
+    File.expand_path(File.join(proto, layout))
+  end
+
+  def create_root?
+    return true unless File.directory?(target)
+    return true if amend? or force?
+    fatal "%p is a directory, choose different project name or use --amend/--force" % target
+  end
+
+  def got_proto?
+    return true if File.directory?(proto)
+    fatal "Cannot create, %p doesn't exist, use --proto or create the proto directory" % proto
+  end
+
+  def create
+    got_proto?
+
+    puts "Found proto at: %p, proceeding...\n\n" % proto
+    mkdir(relate('/')) if create_root?
+    proceed
+  end
+
+  def proceed
+    files, directories = partition{|path| File.file?(path) }
+    proceed_directories(directories)
+    proceed_files(files)
+  end
+
+  def proceed_files(files)
+    files.each{|file| copy(file, relate(file)) }
+  end
+
+  def proceed_directories(dirs)
+    dirs.each{|dir| mkdir(relate(dir)) }
+  end
+
+  def mkdir(dir)
+    exists = File.directory?(dir)
+    return if exists and amend?
+    return if exists and not force?
+    puts "mkdir(%p)" % dir
+    FileUtils.mkdir_p(dir)
+  end
+
+  def copy(from, to)
+    return unless copy_check(to)
+    puts "copy(%p, %p)" % [from, to]
+    FileUtils.cp(from, to, :preserve => true)
+    post_process(to)
+  end
+
+  def copy_check(to)
+    exists = File.file?(to)
+    return if exists and amend?
+    return if exists and not force?
+    return true
+  end
+
+  # Think about a useful way to process the generated files it should be
+  # possible to substitute some things like the project name in the
+  # configuration
+
+  def post_process(file)
+    return
+    source = File.read(file)
+    File.open(file, 'w+') do |io|
+      io.write(source.gsub('$project', "'#@name'"))
+    end
+  end
+
+  def relate(path)
+    File.join(target, path.to_s.sub(proto, ''))
+  end
+
+  def amend?; options[:amend] end
+  def force?; options[:force] end
+
+  def fatal(message)
+    warn message
+    exit 1
+  end
+
+  def each
+    Dir["#{proto}/**/*"].each{|path| yield(path) }
+  end
+
+  include Enumerable
+end

data/lib/ramaze/version.rb

@@ -0,0 +1,3 @@
+module Ramaze
+  VERSION = "2009.06.12"
+end

data/lib/ramaze/view.rb

@@ -0,0 +1,39 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  View = Innate::View
+
+  # This is a container module for wrappers of templating engines and handles
+  # lazy requiring of needed engines.
+  module View
+
+    # Combine Kernel#autoload and Innate::View::register
+
+    def self.auto_register(name, *exts)
+      autoload(name, "ramaze/view/#{name}".downcase)
+      register("Innate::View::#{name}", *exts)
+    end
+
+    # TODO:
+    # * markaby - though we should advertise remarkably instead
+    # * XSLT    - this one is just crazy, someone up for the task?
+
+    # Engines provided by Innate are:
+    # ERB, Etanni, None
+
+    auto_register :Erubis,     :erubis, :rhtml
+    auto_register :Ezamar,     :zmr
+    auto_register :Gestalt,    :ges
+    auto_register :Haml,       :haml
+    auto_register :Less,       :lss, :less
+    auto_register :Liquid,     :liquid
+    auto_register :Maruku,     :mkd, :md
+    auto_register :Nagoro,     :nag
+    auto_register :RedCloth,   :redcloth
+    auto_register :Remarkably, :rem
+    auto_register :Sass,       :sass
+    auto_register :Tagz,       :rb, :tagz
+    auto_register :Tenjin,     :rbhtml, :tenjin
+  end
+end

data/lib/ramaze/view/erubis.rb

@@ -0,0 +1,23 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'erubis'
+
+module Ramaze
+  module View
+    module Erubis
+      OPTIONS = { :engine => ::Erubis::Eruby }
+
+      def self.call(action, string)
+        options = OPTIONS.dup
+        engine = options.delete(:engine)
+
+        eruby = View.compile(string){|s| engine.new(s, options) }
+        eruby.init_evaluator(:filename => (action.view || __FILE__))
+        html = eruby.evaluate(action.instance)
+
+        return html, 'text/html'
+      end
+    end
+  end
+end

data/lib/ramaze/view/ezamar.rb

@@ -0,0 +1,23 @@
+require 'ezamar'
+
+module Ramaze
+  module View
+    module Ezamar
+      TRANSFORM_PIPELINE = [ ::Ezamar::Element ]
+
+      def self.call(action, string)
+        ezamar = View.compile(string){|s| compile(action, s) }
+        html = ezamar.result(action.binding)
+        return html, 'text/html'
+      end
+
+      def self.compile(action, template)
+        file = action.view || __FILE__
+
+        TRANSFORM_PIPELINE.each{|tp| template = tp.transform(template) }
+
+        ::Ezamar::Template.new(template, :file => file)
+      end
+    end
+  end
+end

data/lib/ramaze/view/gestalt.rb

@@ -0,0 +1,14 @@
+require 'ramaze/gestalt'
+
+module Ramaze
+  module View
+    module Gestalt
+      def self.call(action, string)
+        string = action.instance.instance_eval(string) if action.view
+        html = [string].join
+
+        return html, 'text/html'
+      end
+    end
+  end
+end

data/lib/ramaze/view/haml.rb

@@ -0,0 +1,16 @@
+require 'haml/util'
+require 'haml/engine'
+
+module Ramaze
+  module View
+    module Haml
+      def self.call(action, string)
+        action.options[:filename] = (action.view || '(haml)')
+        haml = View.compile(string){|s| ::Haml::Engine.new(s, action.options) }
+        html = haml.to_html(action.instance, action.variables)
+
+        return html, 'text/html'
+      end
+    end
+  end
+end

data/lib/ramaze/view/liquid.rb

@@ -0,0 +1,100 @@
+#          Copyright (c) 2009 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 View
+    # Liquid is a smarty-style templating engine that restricts the usage of
+    # code inside templates. This is mostly helpful if you want to let users
+    # submit templates but prevent them from running arbitrary code.
+    #
+    # Liquid offers a pipe-like syntax for chaining operations on objects.
+    # Any instance variable from your Controller is available as a variable
+    # inside Liquid, so be sensitive about what data you provide.
+    #
+    # If you want to allow partials you can provide a kind of virtual
+    # filesystem that contains partials. These can be rendered using the
+    # Liquid `{% include 'name' %}` tag. The include tag has no relation to the
+    # Ramaze::Helper::Render, it simply inlines the file.
+    #
+    # To tell Liquid where to find partials, you have to set the file_system.
+    # The naming-convention for liquid-partials is to use a '_' prefix to the
+    # filename and the '.liquid' filename extension. The names of partials
+    # are restricted to ASCII alpha-numeric characters and underscores. You
+    # can also use '/' to use templates located in deeper directories.
+    # The partial has access to the same variables as the template including
+    # it.
+    #
+    # @example setting file_system
+    #   template_path = './partials/'
+    #   Liquid::Template.file_system = Liquid::LocalFileSystem.new(template_path)
+    #
+    # @example using include
+    #   {% include 'foo' %}
+    #   {% include 'bar/foo' %}
+    #
+    # This will include the files located at './partials/_foo.liquid' and
+    # './partials/bar/_foo.liquid'.
+    #
+    # This functionality gets even more interesting if you customize it with
+    # your own virtual file-system, you can use anything that responds to
+    # `#read_template_file(path)`.
+    # That way you can even fetch templates from a database or instruct Liquid
+    # to allow you access to your own templates in the '/views' directory.
+    module Liquid
+
+      # Liquid requires the variable keys to be strings, most likely for
+      # security resons (don't allow arbitrary symbols).
+      def self.call(action, string)
+        action.sync_variables(action)
+        variables = {}
+        action.variables.each{|k,v| variables[k.to_s] = v }
+
+        liquid = View.compile(string){|s| ::Liquid::Template.parse(s) }
+        html = liquid.render(variables)
+
+        return html, 'text/html'
+      end
+
+      class Tag < ::Liquid::Tag
+        def initialize(tag_name, arg, tokens)
+          super
+          @arg = arg.strip
+        end
+      end
+
+      # Liquid has intentionally? no support for binding, in order to use
+      # helpers you have to register them as tags.
+      #
+      # Creating a tag needs boilerplate, so we reduce that for your
+      # convenience.
+      #
+      # This is not the most performant way, it seems like Liquid uses
+      # initialize to compile templates and gives you the chance to process the
+      # arguments to the tag only once, but if you want that please contribute.
+      #
+      # Further below are a couple of tags that map to the most common helpers,
+      # this also needs contribution as I simply don't have the time to write
+      # all of that and invent a consistent syntax.
+      def self.register_tag(name, helper, &block)
+        klass = Class.new(Tag)
+        klass.send(:include, helper)
+        klass.send(:define_method, :render, &block)
+
+        ::Liquid::Template.register_tag(name, klass)
+      end
+
+      # {% route index %}
+      register_tag('route', Ramaze::Helper::Link) do |context|
+        Ramaze::Current.action.node.route(@arg)
+      end
+
+      # {% anchor "The index" index %}
+      register_tag('anchor', Ramaze::Helper::Link) do |context|
+        @arg =~ /^(['"])(.*?)\1\s+(.*)/
+        Ramaze::Current.action.node.anchor($2, $3)
+      end
+    end
+  end
+end

data/lib/ramaze/view/maruku.rb

@@ -0,0 +1,15 @@
+require 'maruku'
+
+module Ramaze
+  module View
+    module Maruku
+      def self.call(action, string)
+        string = File.read(action.view) if action.view
+        maruku = View.compile(string){|s| ::Maruku.new(s) }
+        html = maruku.to_html
+
+        return html, 'text/html'
+      end
+    end
+  end
+end

data/lib/ramaze/view/nagoro.rb

@@ -0,0 +1,44 @@
+require 'nagoro'
+require 'ramaze/view/nagoro/render_partial'
+
+module Ramaze
+  module View
+    # Binding to the Nagoro templating engine.
+    #
+    # To pipe your template through tidy you have to use:
+    #
+    #   Ramaze::View::Nagoro.options.tidy = true
+    #
+    # @see http://github.com/manveru/nagoro
+    module Nagoro
+      include Optioned
+
+      options.dsl do
+        o "Pipes to pass the template through",
+          :pipes, ::Nagoro::DEFAULT_PIPES
+
+        o "Use tidy to cleanup the rendered template",
+          :tidy, false
+      end
+
+      def self.call(action, string)
+        default_options = {
+          :pipes     => options.pipes,
+          :filename  => action.view,
+          :binding   => action.binding,
+          :variables => action.variables
+        }
+
+        render_options = default_options.merge(action.options)
+
+        if options.tidy
+          html = ::Nagoro.tidy_render(string.to_s, render_options)
+        else
+          html = ::Nagoro.render(string.to_s, render_options)
+        end
+
+        return html, 'text/html'
+      end
+    end
+  end
+end