mynyml-merb-in-file-templates 0.3.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Martin Aumont
+
+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.

data/README

@@ -0,0 +1,151 @@
+merb-in-file-templates *ALPHA*
+==============================
+WARNING: This plugin isn't stable yet! Feel free to try it out and send patches
+though.
+
+A plugin for the Merb framework that allows templates (views) to be defined in
+the same file as the controller (Sinatra style). Especially useful for
+--very-flat apps (making them truly flat), apps that have litle/small view
+code, and for rapid prototyping.
+
+==== Features
+* Seamless integration with #render, #display
+* Respects template reloading
+* Very simple to use
+* Flexible
+
+==== Dependencies
+* Merb > 0.9.4 (?)
+* Rspec to run the specs
+
+==== Examples
+  #example for --very-flat app (single file app)
+  
+  #...
+  class Application < Merb::Controller; end
+  class Products < Application
+    def index
+      @products = Product.all
+      render
+    end
+    def show
+      @product = Product[params[:id]]
+      render
+    end
+  end
+  
+  __END__
+  @@ index.html.erb
+  <h1>Product List</h1>
+  <ul>
+    <% for product in @products -%>
+      <li><%= product.name %></li>
+    <% end -%>
+  </ul>
+  
+  @@ show.html.erb
+  <h1><%= @product.name %></h1>
+
+In-file templates cohabit peacefully with regular external templates. So in the
+above example, show.html.erb could be defined in views/products/show.html.erb
+and both templates will still be picked up normally. In case of a name conflict
+between an in-file and an external template, the external one will take
+precedence and won't be overwritten, keeping it safe from data loss.
+
+Template names follow the same rules as regular templates (usually
+action.mime_type.templating_engine). 
+
+Layouts, stylesheets and javascript can also be placed in in-file templates.
+
+  #...
+
+  __END__
+  @@ layout/application.css
+  #...
+
+  @@ layout/products.css
+  #...
+
+  @@ stylesheets/application.css
+  #...
+
+  @@ javascripts/jquery.js
+  #...
+
+==== Tweaking
+In order to be fed into merb's templating system, in-file templates need to be
+written to external files. This means you will see dynamically created view
+files inside your Merb.dir_for(:view) directory/subdirectories.
+
+The directory in which files are stored is chosen based on the templating
+system's native mechanisms, and so merb-in-file-templates will respect any
+changes to it. Therefore if you want to change where template files are stored,
+you can play with Merb.push_path(:view, ...) and the controller's
+#_template_location method.
+
+  Merb.push_path(:view, Merb.root / 'views')
+  class Application
+    def _template_location(context, type=nil, controller = controller_name)
+      "#{controller}.#{action_name}.#{type}"
+    end
+  end
+
+This will tell Merb to look under the /views directory, for a template named
+products.index.html.erb. 
+
+want even flatter?
+
+  Merb.push_path(:view, Merb.root)
+  class Application
+    def _template_location(context, type=nil, controller=controller_name)
+      "view.#{controller}.#{action_name}.#{type}"
+    end
+  end
+
+will give you a template under the root dir called view.products.index.html.erb
+(adding a common prefix, 'view.' in the example above, causes template files to
+show up nicely grouped with ls, file managers, etc, so they look organized even
+without being placed in a subdirectory).
+
+If you mix in-file and external templates and you don't want them to be mixed
+in the same directories, you can tell merb-in-file-templates to store its
+templates somewhere else. This is done through the config hash:
+
+  Merb::Plugins.config[:in_file_templates] = {
+    :view_root        => '...',
+    :stylesheets_root => '...',
+    :javascripts_root => '...',
+  }
+
+For example, you could set
+
+  :view_root => Merb.root / 'tmp' / 'ift_views'
+
+to store your files in merb-root/tmp/ift_views, or
+
+  :view_root => '/tmp'
+
+to store files in your system's tmp directory.
+
+Same goes for stylesheets and javascripts, but remember that those need to be
+placed in a public directory, and that they need to be referenced properly from
+within your html header. You can use the controller's
+#ift_dir_for(:stylesheets) and #ift_dir_for(:javascripts) methods to find their
+locations.
+
+==== Rake Task
+TODO
+(cleanup rake task before deployment..)
+
+==== Installation
+TODO
+
+==== Contact
+If you have suggestions, comments, a patch, a git pull request, rants, doc
+fixes/improvements, etc., feel free to contact me: mynyml at gmail,
+irc.freenode.net #rubyonrails, #merb
+
+Happy Hacking!
+
+-------------------------------------------------------------------------
+Copyright (c) 2008 Martin Aumont (mynyml), released under the MIT license

data/Rakefile

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+
+PLUGIN = "merb-in-file-templates"
+NAME = "merb-in-file-templates"
+GEM_VERSION = "0.3.1"
+AUTHOR = "Martin Aumont"
+EMAIL = "mynyml@gmail.com"
+HOMEPAGE = "http://github.com/mynyml/"
+SUMMARY = "Merb plugin that allows templates (views, css, js) to be defined in the same file as the controller"
+
+spec = Gem::Specification.new do |s|
+  s.name = NAME
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.author = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.add_dependency('merb', '>= 0.9.4')
+  s.require_path = 'lib'
+  #s.autorequire = PLUGIN
+  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,spec}/**/*")
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the plugin locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{NAME}-#{GEM_VERSION} --no-update-sources}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{NAME}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end
+
+namespace :jruby do
+
+  desc "Run :package and install the resulting .gem with jruby"
+  task :install => :package do
+    sh %{#{SUDO} jruby -S gem install pkg/#{NAME}-#{Merb::VERSION}.gem --no-rdoc --no-ri}
+  end
+  
+end

data/TODO

@@ -0,0 +1,10 @@
+TODO:
+* stylesheets/javascripts need to be cached as well
+* fix caching hierarchy (e.g. layout should not be under a controller in
+  ift.cache)
+* improve README
+* test with haml/sass
+* ensure compatibility with merb-parts and merb-slices
+* see if there is an alternative to alias_method_chain'ing #render and #display
+* ift_ namespace is kinda lame - alternative?
+* fix or find workaround for autotest infinite loops on first pass

data/lib/merb-in-file-templates.rb

@@ -0,0 +1,23 @@
+if defined?(Merb::Plugins)
+
+  require 'merb-in-file-templates/cache'
+  require 'merb-in-file-templates/in_file_templates_mixin'
+
+  # Config options
+  # This plugin will respect Merb::Config[:reload_templates]. This means that
+  # if set to true, templates will be rebuilt every time #render is called.
+  Merb::Plugins.config[:in_file_templates] = {
+    :view_root        => nil,
+    :stylesheets_root => nil,
+    :javascripts_root => nil,
+    :garbage_collect  => true #unused
+  }
+
+  Merb::BootLoader.after_app_loads do
+    Merb::Controller.class_eval do
+      include InFileTemplatesMixin
+    end
+  end
+
+  Merb::Plugins.add_rakefiles "merb-in-file-templates/merbtasks"
+end

data/lib/merb-in-file-templates/cache.rb

@@ -0,0 +1,45 @@
+require 'yaml'
+
+module InFileTemplatesMixin
+  class Cache #:nodoc:
+    attr_accessor :controller
+    def self.path
+      Merb.dir_for(:config) / 'ift.cache'
+    end
+    def initialize(controller_name)
+      self.controller = controller_name.to_s
+    end
+    def store(tpl_path)
+      self.cache[self.controller] ||= []
+      self.cache[self.controller] << tpl_path
+      self.flush
+    end
+    alias :<< :store
+    def files
+      self.cache[self.controller]
+    end
+    def reset!
+      self.cache.delete(self.controller)
+      self.flush
+    end
+    def exists?
+      !self.cache[self.controller].nil?
+    end
+    protected
+      def cache
+        @cache ||= self.load
+      end
+      def reload!
+        @cache = nil
+      end
+      def load
+        YAML::load_file(self.class.path) || {} rescue {}
+      end
+      def dump
+        open(self.class.path,'w+') do |file|
+          YAML::dump(self.cache,file)
+        end
+      end
+      alias :flush :dump
+  end
+end

data/lib/merb-in-file-templates/in_file_templates_mixin.rb

@@ -0,0 +1,416 @@
+require 'fileutils'
+
+# The in-file-templates mixin allows defining view templates inside controller
+# files. Especially useful for --very-flat apps that have few/small view code,
+# and for rapid prototyping.
+#
+# Templates are defined at the end of the controller file, following the
+# __END__ keyword (__END__ must be placed at the very beginning of the line,
+# with nothing following it). Each template is consists of its name, marked by
+# @@ (@@ must also be placed at the very beginning of the line), followed be
+# the template's content.
+#
+# Template names follow the same rules as regular merb templates:
+#
+#   name.mime_type.templating_engine:
+#     index.html.erb, edit.html.haml, show.xml.bilder, etc
+#
+# ==== Examples
+#   class Application < Merb::Controller; end
+#   class Products < Application
+#     def index
+#       @products = Product.all
+#       render
+#     end
+#     def show
+#       @product = Product[params[:id]]
+#       render
+#     end
+#   end
+#
+#   __END__
+#   @@ index.html.erb
+#   <h1>Product List</h1>
+#   <ul>
+#     <% for product in @products -%>
+#       <li><%= product.name %></li>
+#     <% end -%>
+#   </ul>
+#
+#   @@ show.html.erb
+#   <h1><%= @product.name %></h1>
+#
+# ==== Notes
+# Most methods are prefixed with ift_ (In File Templates). This is simply to
+# avoid naming conflicts with controller methods.
+module InFileTemplatesMixin
+
+  # When mixin is included in controller, define aliases to wrap #render and
+  # #display
+  #
+  # ==== Parameters
+  # base<Module>:: Module that is including InFileTemplatesMixin (probably a controller)
+  #
+  # ==== Notes
+  # http://yehudakatz.com/2008/05/22/the-greatest-thing-since-sliced-merb/
+  # "We consider cases of people using alias_method_chain on Merb to be a bug in
+  # Merb, and try to find ways to expose enough functionality so it will not be
+  # required."
+  # So could this code be written otherwise, or is it an exception to the above
+  # rule? what are the alternatives?
+  #_
+  # @public
+  def self.included(base)
+    base.send(:alias_method, :render_without_in_file_templates, :render)
+    base.send(:alias_method, :render, :render_with_in_file_templates)
+    base.send(:alias_method, :display_without_in_file_templates, :display)
+    base.send(:alias_method, :display, :display_with_in_file_templates)
+  end
+
+  # Wrap #render to gather template data from caller's file and trigger
+  # template build process.
+  #
+  # ==== Parameters
+  # Same as Merb::RenderMixin#render
+  #
+  # ==== Returns
+  # Same as Merb::RenderMixin#render
+  #
+  # ==== Raises
+  # Same as Merb::RenderMixin#render
+  #
+  # ==== Alternatives
+  # Same as Merb::RenderMixin#render
+  #_
+  # @public
+  def render_with_in_file_templates(*args) #:nodoc:
+    ift_build!((@ift_caller ||= caller).first.split(':').first)
+    render_without_in_file_templates(*args)
+  end
+
+  # Overwrite display and set caller so that #render (called internally by
+  # #display) knows what file to fetch template data from.
+  #
+  # ==== Parameters
+  # Same as Merb::RenderMixin#display
+  #
+  # ==== Returns
+  # Same as Merb::RenderMixin#display
+  #
+  # ==== Raises
+  # Same as Merb::RenderMixin#display
+  #
+  # ==== Alternatives
+  # Same as Merb::RenderMixin#display
+  # -----
+  # @public
+  def display_with_in_file_templates(*args) #:nodoc:
+    @ift_caller = caller
+    display_without_in_file_templates(*args)
+  end
+
+  # Render in-file template in a very basic fashion; only fetches the template
+  # as a string, without having it go through the templating system (which
+  # includes the templating engines). The method then is equivalent to directly
+  # returning a string from the action method.
+  #
+  # ==== Examples
+  #   def index
+  #     'hello world'
+  #   end
+  #
+  # is equivalent to:
+  #
+  #   def index
+  #     render_from_file(:index)
+  #   end
+  #   #...
+  #   __END__
+  #   @@ index
+  #   hello world
+  #
+  # You can also use a templating engine manually:
+  #
+  #   def index
+  #     @name = 'world'
+  #     Erubis::Eruby.new(render_from_file(:new)).result(binding)
+  #   end
+  #   #...
+  #   __END__
+  #   @@ index
+  #   hello <%= @name %>
+  #
+  # ==== Parameters
+  # context<~to_s, nil>::
+  #   Name of the template to fetch. Defaults to action name
+  # file<String, nil>::
+  #   Path to a file in which to fetch the template data. Default is file this
+  #   method has been called from
+  #
+  # ==== Returns
+  # String:: Raw template
+  #
+  # ==== Raises
+  # TemplateNotFound:: There is no template in the specified file.
+  #_
+  # @public
+  def render_from_file(context=action_name, file=nil)
+    file ||= caller.first.split(':').first
+    data = IO.read(file).split('__END__').last
+    ift_parse(data)[context.to_s] or raise(Merb::Controller::TemplateNotFound, "Template #{context} not found in #{File.expand_path(file)}")
+  end
+
+  # Builds templates from in-file data so that they can be picked up by merb's
+  # templating system. Building includes parsing the data to extract the
+  # templates and then writing them to files.
+  #
+  # Will skip rebuilding process if Merb::Config[:reload_templates] is false
+  #
+  # ==== Parameters
+  # file<String>::
+  #   Path to a file in which to fetch the template data.
+  #_
+  # @semipublic
+  def ift_build!(file)
+    # write templates to view files if they haven't been already been
+    # written, or always if :reload_templates config option is true
+    return unless !ift_built? || Merb::Config[:reload_templates] 
+
+    data = IO.read(file).split('__END__').last
+    templates = ift_parse(data)
+
+    self.ift_set_template_roots!
+    self.ift_garbage_collect!
+
+    templates.each do |name,data|
+      path = ift_path_for(name)
+      unless File.exist?(path) #don't overwrite externaly defined templates
+        self.ift_write_template(path, data)
+        @cache << path
+      end
+    end
+  end
+
+  # Construct path (including filename) for given template name.
+  # Template can be a view, stylesheet or javascript file.
+  #
+  # ==== Parameters
+  # name<String>:: Template name
+  #
+  # ==== Returns
+  # String:: Path to template
+  #
+  # ==== Examples
+  #   # given @@ products/foo.html.erb
+  #   ift_path_for('foo.html.erb') #=> /merb.root/views/products/foo.html.erb
+  #
+  #   # given @@ bar.html.erb
+  #   # and current controller is Products
+  #   ift_path_for('bar.html.erb') #=> /merb.root/views/products/bar.html.erb
+  #
+  #   # given @@ public/stylesheet/app.css
+  #   ift_path_for('app.css') #=> /merb.root/public/stylesheets/app.css
+  #_
+  # @semipublic
+  def ift_path_for(name)
+    name =
+      if ift_stylesheet?(name)
+        self.ift_dir_for(:stylesheets) / File.basename(name)
+      elsif ift_javascript?(name)
+        self.ift_dir_for(:javascripts) / File.basename(name)
+      else
+        name = ift_template_dir / name unless name.include?('/') #add path prefix if omitted
+        self.ift_dir_for(:view) / name
+      end
+    File.expand_path(name)
+  end
+
+  # Get in-file template directory for a type. Equivalent to Merb.dir_for,
+  # but taking config options for template paths into consideration.
+  #
+  # ==== Parameters
+  # type<Symbol>::
+  #   The type of path to retrieve directory for, e.g. :view. Accepted types
+  #   are :view, :stylesheets and :javascripts
+  #
+  # ==== Returns
+  # String:: Path to the type directory
+  #_
+  # @public
+  def ift_dir_for(type)
+    case type
+    when :view
+      Merb::Plugins.config[:in_file_templates][:view_root] ||
+      self._template_root
+    when :stylesheets
+      Merb::Plugins.config[:in_file_templates][:stylesheets_root] ||
+      Merb.dir_for(:stylesheets)
+    when :javascripts
+      Merb::Plugins.config[:in_file_templates][:javascripts_root] ||
+      Merb.dir_for(:javascripts)
+    end
+  end
+
+  # Find out if template defines a stylesheet, based on template's name.
+  #
+  # ==== Parameters
+  # name<String>:: Template name
+  #
+  # ==== Returns
+  # Boolean:: True if stylesheet, false otherwise
+  #
+  # ==== Examples
+  #   # given Merb.dir_for(:stylesheets) #=> '/merb.root/public/stylesheets'
+  #   ift_stylesheet?('public/stylesheets/app.css') #=> true
+  #   ift_stylesheet?('stylesheets/app.css') #=> true
+  #   ift_stylesheet?('index.html.erb') #=> false
+  #_
+  # @semipublic
+  def ift_stylesheet?(name)
+    dir = File.dirname(name).chomp('.')
+    dir.empty? ? false : !!(Merb.dir_for(:stylesheet) =~ /#{dir}$/)
+  end
+
+  # Find out if template defines a javascript, based on template's name.
+  #
+  # ==== Parameters
+  # name<String>:: Template name
+  #
+  # ==== Returns
+  # Boolean:: True if javascript, false otherwise
+  #
+  # ==== Examples
+  #   # given Merb.dir_for(:javascript) #=> '/merb.root/public/javascripts'
+  #   ift_javascript?('public/javascripts/app.js') #=> true
+  #   ift_javascript?('javascripts/app.js') #=> true
+  #   ift_javascript?('index.html.erb') #=> false
+  #   ift_javascript?('app.js') #=> false
+  #_
+  # @semipublic
+  def ift_javascript?(name)
+    dir = File.dirname(name).chomp('.')
+    dir.empty? ? false : !!(Merb.dir_for(:javascript) =~ /#{dir}$/)
+  end
+
+  # Get path to current controller's template location, relative to template
+  # root (not view root).
+  #
+  # ==== Returns
+  # String:: relative path to template location
+  #_
+  # @semipublic
+  def ift_template_dir
+    File.dirname(
+      self._template_location("im in ur gems, playin' wif ur templetz")
+    )
+  end
+
+  # Parse given data and extract individual templates and their names.
+  #
+  # ==== Parameters
+  # data<String>:: Raw templates data
+  #
+  # ==== Returns
+  # Hash:: Template names (keys) and their raw content (values)
+  #
+  # ==== Examples
+  #   @@ template_name
+  #   content here
+  #
+  #   @@ index.html.erb
+  #   the two @ signs must be at the beginning of the line
+  #
+  #   @@ template names can even include spaces
+  #   pretty unconventional though
+  #_
+  # @semipublic
+  def ift_parse(data)
+    templates, current, ignore = {}, nil, false
+    data.each_line do |line|
+      #(templates[current = $2], ignore = '', $1=='#') and next if line =~ /^(\#)*@@\s*(.*)/
+      #templates[current] << line if current unless ignore
+      if line =~ /^(\#)*@@\s*(.*)/
+        #ignore = ($1 == '#') #skip commented out templates
+        #next if ignore
+        #current = $2
+        #templates[current] = ''
+        ignore = ($1 == '#') and next #skip commented out templates
+        templates[current = $2] = ''
+      elsif ignore
+        next
+      elsif current
+        templates[current] << line
+      end
+    end
+    templates
+  end
+
+  # Rid template directory of all dynamically created files (those created
+  # through #ift_build!).
+  #_
+  # @semipublic
+  def ift_garbage_collect!
+    ift_init_cache
+    if @cache.exists?
+      @cache.files.each do |file|
+        file.chomp!
+        FileUtils.rm(file) if File.exist?(file)
+      end
+      @cache.reset!
+    end
+  end
+
+  protected
+
+  # Add custom template root to controller's #_template_roots, based on config
+  # option. If option isn't set, template_roots stay unchanged.
+  #_
+  # @private
+  def ift_set_template_roots!
+    if root = Merb::Plugins.config[:in_file_templates][:view_root]
+      self.class._template_roots.unshift([root, :_template_location])
+    end
+  end
+
+  # Write template data to a file. 
+  #
+  # ==== Parameters
+  # file<String>:: Path name to file in which to store template data.
+  # data<String>:: Template data
+  #_
+  # @private
+  def ift_write_template(file, data)
+    dir = File.dirname(file)
+    FileUtils.mkdir_p(dir) unless File.directory?(dir)
+    open(file, 'w+') {|f| f.write(data) }
+  end
+
+  # Determine whether templates have already been built.
+  #
+  # ==== Returns
+  # Boolean::
+  #   True if templates have been built for this controller, false otherwise
+  #_
+  # @private
+  def ift_built?
+    ift_init_cache
+    @cache.exists?
+  end
+
+  # Initialize cache.
+  # Because the cache depends on controller specific information, it has to be
+  # set while execution is in actual controller (as opposed to parent).
+  #_
+  # @private
+  def ift_init_cache
+    #@cache ||= Cache.new(self.controller_name)
+    @cache = Cache.new(self.controller_name)
+  end
+
+  # unused; optional garbage collection not yet implemented.
+  #_
+  # @private
+  def ift_garbage_collect?
+    !!Merb::Plugins.config[:in_file_templates][:garbage_collect]
+  end
+end

data/lib/merb-in-file-templates/merbtasks.rb

@@ -0,0 +1,18 @@
+namespace :in_file_templates do
+  desc "Remove all generated template files"
+  task :clean do
+    require 'fileutils'
+    YAML::load_file(Merb.dir_for(:config) / 'ift.cache').values.flatten.each do |file|
+      unless File.exist?(file)
+        file_path = file.gsub(Dir.pwd, '')
+        cache_path = (Merb.dir_for(:config) / 'ift.cache').gsub(Dir.pwd,'')
+        msg  = "Warning: Potential cache corruption. "
+        msg << "File #{path} is listed in the cache "
+        msg << "(#{cache_path}) but doesn't exist."
+        raise msg
+      else
+        FileUtils.rm(file)
+      end
+    end
+  end
+end

data/spec/controller3.rb

@@ -0,0 +1,15 @@
+# as much as I hate external fixtures, in this case the file #render is called
+# from matters so this controller must be split off into its own file
+class Controller3 < Merb::Controller
+  def index; render; end
+end
+
+__END__
+@@ foo
+fou
+
+@@ controller3/index.html.erb
+3rdctrl-index
+
+@@ controller3/qwerty.xml.haml
+funky

data/spec/merb-in-file-templates_spec.rb

@@ -0,0 +1,336 @@
+require 'fileutils'
+begin
+  require 'rubygems'
+  require 'ruby-debug'
+rescue
+  #pass
+end
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "In-file templates" do
+
+  before(:all) do
+    Merb.root = File.dirname(__FILE__) / '..' / 'root'
+    Merb.push_path(:view,       Merb.root / 'views', '**/*.rb')
+    Merb.push_path(:config,     Merb.root / 'config')
+    Merb.push_path(:public,     Merb.root / 'public')
+    Merb.push_path(:stylesheets, Merb.dir_for(:public) / "stylesheets", nil)
+    Merb.push_path(:javascripts, Merb.dir_for(:public) / "javascripts", nil)
+    #-----
+    FileUtils.mkdir(Merb.dir_for(:config)) unless File.exist?(Merb.dir_for(:config))
+    # --------- Fixtures
+    class Controller1 < Merb::Controller
+      provides :html, :xml
+      def index; render; end
+      def show;  render_from_file("foo", __FILE__); end
+    end
+    class Controller2 < Merb::Controller
+      provides :html, :xml
+      def index; render; end
+    end
+    require @controller3_file = File.dirname(__FILE__) / 'controller3.rb'
+    # ---------- Views
+    # (see end of file for rest of views)
+    dir = Merb.dir_for(:view) / 'controller1'
+    FileUtils.mkdir_p(dir)
+    open(dir / 'static.html.erb','w+') {|file| file.write("=^.^=\n") }
+  end
+
+  before(:each) do
+    Merb::Config[:reload_templates] = true
+    Merb::Template::METHOD_LIST.clear #reset inline templates cache
+    Controller1._template_roots = nil
+    Controller2._template_roots = nil
+    Controller3._template_roots = nil
+    @controller1 = Controller1.new(fake_request)
+    @controller2 = Controller2.new(fake_request)
+    @controller3 = Controller3.new(fake_request)
+    @controller  = @controller1 #synonym
+    clean_tpl_files(@controller1)
+    clean_tpl_files(@controller2)
+    clean_tpl_files(@controller3)
+  end
+
+  after(:all) do
+    clean_tpl_files(@controller1)
+    clean_tpl_files(@controller2)
+    clean_tpl_files(@controller3)
+    #Dir[Merb.root / '*'].each {|e| FileUtils::DryRun.rm_rf(e) }
+    Dir[Merb.root / '*'].each {|e| FileUtils.rm_rf(e) }
+  end
+
+  def clean_tpl_files(controller)
+    controller.send(:ift_garbage_collect!)
+  end
+
+  it "should be integrated with render" do
+    @controller.render(:index).strip.should == "1stctrl-index"
+  end
+
+  it "should be callable from within a controller action" do
+    @controller._dispatch(:show)
+    @controller.body.strip.should == "bar"
+    @controller._dispatch(:index)
+    @controller.body.strip.should == "1stctrl-index"
+  end
+
+  it "should be integrated with display" do
+    obj = Object.new; def obj.to_html; '<b>a</b>'; end
+    @controller.action_name = 'fu'
+    @controller.display(obj).strip.should == '<b>a</b>'
+    @controller.display(obj,:index).strip.should == '1stctrl-index'
+  end
+
+  it "should parse template engine code" do
+    @controller.render(:dynamic).strip.should == "dynamic str"
+  end
+
+  it "should reload templates when code reloading is on" do
+    Merb::Config[:reload_templates] = true
+    @controller.render(:index).strip.should == "1stctrl-index"
+    @controller.stub!(:ift_parse).and_return({'controller1/index.html.erb' => 'foobar'})
+    @controller.render(:index).strip.should == 'foobar'
+  end
+
+  it "should not reload templates when code reloading is off" do
+    Merb::Config[:reload_templates] = false
+    @controller.render(:index).strip.should == "1stctrl-index"
+    @controller.stub!(:ift_parse).and_return({'controller1/index.html.erb' => 'foobar'})
+    @controller.render(:index).strip.should == '1stctrl-index'
+    Merb::Config[:reload_templates] = true
+    @controller.render(:index).strip.should == 'foobar'
+  end
+
+  it "should obey template content types (1)" do
+    @controller.content_type(:xml)
+    @controller.render(:index).strip.should == '<x>ml</x>'
+  end
+
+  it "should obey template content types (2)" do
+    @controller.content_type(:html)
+    @controller.render(:index).strip.should == '1stctrl-index'
+  end
+
+  it "should look for templates in file where #render is called" do
+    @controller3._dispatch(:index)
+    @controller3.body.strip.should == "3rdctrl-index"
+  end
+
+  it "should not get confused with many controllers in different files" do
+    @controller1._dispatch(:index)
+    @controller1.body.strip.should == "1stctrl-index"
+    @controller3._dispatch(:index)
+    @controller3.body.strip.should == "3rdctrl-index"
+  end
+
+  it "should not get confused with many controllers in the same file" do
+    @controller1.render(:index).strip.should == '1stctrl-index'
+    @controller2.render(:index).strip.should == '2ndctrl-index'
+  end
+
+  it "should create cache file if it doesn't exist" do
+    path  = InFileTemplatesMixin::Cache.path
+    cache = File.exist?(path) ? (YAML::load_file(path) || {}) : {}
+    FileUtils.rm(path) if File.exist?(path)
+    File.file?(path).should be_false
+    @controller.render(:index).strip.should == '1stctrl-index'
+    File.file?(path).should be_true
+    YAML::load_file(path).should_not be_false #false when not proper yaml
+  end
+
+  it "should respect changes to config options" do
+    view_root = Merb.root / 'tmp' / 'ift' / 'views'
+    css_root  = Merb.dir_for(:stylesheets) / 'ift'
+    js_root   = Merb.dir_for(:javascripts) / 'ift'
+    #-----
+    Merb::Plugins.config[:in_file_templates] = {
+      :view_root        => view_root,
+      :stylesheets_root => css_root,
+      :javascripts_root => js_root
+    }
+    #-----
+    @controller.render(:index)
+    #-----
+    view = view_root / @controller._template_location('') / 'index.html.erb'
+    css  = css_root  / 'app.css'
+    js   = js_root   / 'app.js'
+    #-----
+    File.exist?(view).should be_true
+    File.exist?(css).should be_true
+    File.exist?(js).should be_true
+  end
+
+  it "should respect changes to template location" do
+    def @controller._template_location(context, type=nil, controller=controller_name)
+      "#{controller}.#{action_name}.#{type}"
+    end
+    @controller.stub!(:ift_parse).and_return({'controller1.index.html.erb' => '=0.0='})
+    #-----
+    @controller._dispatch(:index)
+    @controller.body.strip.should == "=0.0="
+  end
+
+  it "should ignore commented out templates" do
+    lambda {
+      @controller.render(:commented_out)
+    }.should raise_error(Merb::ControllerExceptions::TemplateNotFound)
+  end
+
+  it "should guess template path prefix when not explicitly specified" do
+    @controller.render(:onlyname).strip.should include('Defaults')
+  end
+
+  it "should render layouts" do
+    @controller.render(:index, :layout => :custom).strip.should == "hd\n1stctrl-index\nft"
+  end
+
+  it "should render stylesheets" do
+    @controller.render(:index)
+    File.exist?(@controller.ift_dir_for(:stylesheets) / 'app.css').should be_true
+  end
+
+  it "should render javascript" do
+    @controller.render(:index)
+    File.exist?(@controller.ift_dir_for(:javascripts) / 'app.js').should be_true
+  end
+
+  describe "#render_from_file" do
+
+    it "should read the template data from the file it is called from" do
+      @controller.render_from_file(:foo).strip.should == "bar"
+      @controller.render_from_file('controller1/index.html.erb').strip.should == "1stctrl-index"
+    end
+
+    it "should read template's data from provided file" do
+      @controller.render_from_file(:foo, @controller3_file).strip.should == "fou"
+    end
+
+    it "should raise an error when it cannot find the template" do
+      lambda {
+        @controller.render_from_file(:baz)
+      }.should raise_error(Merb::ControllerExceptions::TemplateNotFound)
+    end
+
+    it "should be able to find templates based on action name" do
+      @controller.action_name = 'foo'
+      @controller.render_from_file.strip.should == "bar"
+    end
+  end
+
+  # For the purposes of this plugin, static templates refer to templates
+  # defined in external files (the regular way), as opposed to those
+  # dynamically generated form in-file templates.
+  describe "cohabiting with static templates" do
+
+    it "should be able to render from both in-file template and static template" do
+      @controller.render(:index).strip.should == '1stctrl-index'
+      @controller.render(:static).strip.should == '=^.^='
+    end
+
+    it "should not modify static templates that are already in view directories" do
+      static = (
+        @controller._template_root /
+        @controller._template_location('') /
+        'static.html.erb'
+      )
+      File.file?(static).should be_true
+      file_prev = File.new(static)
+      @controller.render(:index).strip.should == '1stctrl-index'
+      File.file?(static).should be_true
+      file_prev.read.should == File.new(static).read
+    end
+
+    it "should not overwrite a static template with an in-file template" do
+      # views/controller1/ contains a file called static.html.erb
+      @controller.stub!(:ift_parse).and_return({'static.html.erb' => '=0.0='})
+      @controller.render(:static).strip.should == '=^.^='
+    end
+
+    it "should give precedence to static templates" do
+      # views/controller1/ contains a file called static.html.erb
+      @controller.stub!(:ift_parse).and_return({'static.html.erb' => '=0.0='})
+      @controller.render(:static).strip.should == '=^.^='
+    end
+  end
+
+  describe "rake tasks" do
+    #setup for rake task specs thanks to
+    #http://blog.nicksieger.com/articles/2007/06/11/test-your-rake-tasks
+
+    before(:all) { require 'rake' }
+
+    before(:each) do
+      @rake = Rake::Application.new
+      Rake.application = @rake
+      load 'lib/merb-in-file-templates/merbtasks.rb'
+    end
+
+    after(:each) do
+      Rake.application = nil
+    end
+
+    it "should garbage collect the dynamic views" do
+      @controller1._dispatch(:index)
+      @controller3._dispatch(:index)
+      File.file?(@controller1.ift_path_for('foo'             )).should be_true
+      File.file?(@controller1.ift_path_for('index.xml.erb'   )).should be_true
+      File.file?(@controller1.ift_path_for('index.html.erb'  )).should be_true
+      File.file?(@controller1.ift_path_for('dynamic.html.erb')).should be_true
+      File.file?(@controller3.ift_path_for('foo'             )).should be_true
+      File.file?(@controller3.ift_path_for('index.html.erb'  )).should be_true
+      File.file?(@controller3.ift_path_for('qwerty.xml.haml' )).should be_true
+      @rake['in_file_templates:clean'].invoke
+      File.file?(@controller1.ift_path_for('foo'             )).should be_false
+      File.file?(@controller1.ift_path_for('index.xml.erb'   )).should be_false
+      File.file?(@controller1.ift_path_for('index.html.erb'  )).should be_false
+      File.file?(@controller1.ift_path_for('dynamic.html.erb')).should be_false
+      File.file?(@controller3.ift_path_for('foo'             )).should be_false
+      File.file?(@controller3.ift_path_for('index.html.erb'  )).should be_false
+      File.file?(@controller3.ift_path_for('qwerty.xml.haml' )).should be_false
+    end
+
+    it "should raise warn that cache might be corrupted if a listed file doesn't exist" do
+      @controller.render(:index).strip.should == '1stctrl-index'
+      @controller.instance_variable_get(:@cache).store(@controller.ift_path_for('rogue.php'))
+      lambda {
+        @rake['in_file_templates:clean'].invoke
+      }.should raise_error
+    end
+  end
+end
+
+__END__
+@@ foo
+bar
+
+@@ layout/custom.html.erb
+hd
+<%= catch_content(:for_layout).strip %>
+ft
+
+@@ controller1/index.html.erb
+1stctrl-index
+
+@@ controller2/index.html.erb
+2ndctrl-index
+
+@@ controller1/dynamic.html.erb
+<%= "dynamic str" %>
+
+@@ controller1/index.xml.erb
+<x>ml</x>
+
+#@@ controller1/commented_out
+should not be parsed
+
+@@ onlyname.html.erb
+Defaults to current controller (the one #render is called from) when no path
+prefix is specified. Useful when there's a single controller in the file, but
+be careful about creating conflicts when there's multiple controllers and they
+have templates of the same name
+
+@@ public/stylesheets/app.css
+a { color: red; }
+
+@@ javascripts/app.js
+var x = 'x'

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+$TESTING=true
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'rubygems'
+require 'merb-core'
+require 'merb-in-file-templates'
+require 'spec'
+
+Merb.start :environment => 'test'
+
+Spec::Runner.configure do |config|
+  config.include Merb::Test::RequestHelper  
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification 
+name: mynyml-merb-in-file-templates
+version: !ruby/object:Gem::Version 
+  version: 0.3.1
+platform: ruby
+authors: 
+- Martin Aumont
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-06-10 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: merb
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.4
+    version: 
+description: Merb plugin that allows templates (views, css, js) to be defined in the same file as the controller
+email: mynyml@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- TODO
+files: 
+- LICENSE
+- README
+- Rakefile
+- TODO
+- lib/merb-in-file-templates
+- lib/merb-in-file-templates/cache.rb
+- lib/merb-in-file-templates/in_file_templates_mixin.rb
+- lib/merb-in-file-templates/merbtasks.rb
+- lib/merb-in-file-templates.rb
+- spec/merb-in-file-templates_spec.rb
+- spec/spec.opts
+- spec/controller3.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/mynyml/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.0.1
+signing_key: 
+specification_version: 2
+summary: Merb plugin that allows templates (views, css, js) to be defined in the same file as the controller
+test_files: []
+