mynyml-merb_simple_views 0.5.0

data/README

@@ -0,0 +1,158 @@
+merb_simple_views *ALPHA*
+==============================
+
+WARNING: This plugin is a rewrite of merb-in-file-templates for merb >= 1.0 It
+is very much a work in progress, and is NOT yet stable! Feel free to contribute
+or fork if you are interesting though.
+
+UPDATE: Due to the direction the merb project has taken, this plugin's
+development has been put on hold indefinitly.
+
+
+
+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,49 @@
+require 'rake/gempackagetask'
+require 'pathname'
+require 'yaml'
+
+def gem
+  RUBY_1_9 ? 'gem19' : 'gem'
+end
+
+def all_except(paths)
+  Dir['**/*'] - paths.map {|path| path.strip.gsub(/^\//,'').gsub(/\/$/,'') }
+end
+
+spec = Gem::Specification.new do |s|
+  s.name            = 'merb_simple_views'
+  s.version         = '0.5.0'
+  s.summary         = 'Merb plugin that allows defining templates (views, css, js)in the same file as the controller.'
+  s.description     = 'Merb plugin that allows defining templates (views, css, js)in the same file as the controller.'
+  s.author          = "Martin Aumont"
+  s.email           = 'mynyml@gmail.com'
+  s.homepage        = ''
+  s.has_rdoc        = true
+  s.require_path    = "lib"
+  s.files           = all_except(%w( tmp/* log/* ))
+  s.add_dependency 'merb-core >= 1.0'
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+end
+
+
+desc "Remove package products"
+task :clean => :clobber_package
+
+desc "Update the gemspec for GitHub's gem server"
+task :gemspec do
+  Pathname("#{spec.name}.gemspec").open('w') {|f| f << YAML.dump(spec) }
+end
+
+desc "Install gem"
+task :install => [:clobber, :package] do
+  sh "#{SUDO} #{gem} install pkg/#{spec.full_name}.gem"
+end
+
+desc "Uninstall gem"
+task :uninstall => :clean do
+  sh "#{SUDO} #{gem} uninstall -v #{spec.version} -x #{spec.name}"
+end
+

data/autotest/discover.rb

@@ -0,0 +1,2 @@
+Autotest.add_discovery { "simpleviews" }
+Autotest.add_discovery { "rspec" }

data/autotest/rspec_simpleviews.rb

@@ -0,0 +1,106 @@
+# adaptest from autotest/merb_rspec.rb
+require 'autotest'
+
+class RspecCommandError < StandardError; end
+
+class Autotest::RspecSimpleviews < Autotest
+  def initialize
+    super
+
+    # Ignore any happenings in these directories
+    add_exception %r%^\./(?:doc|log|tmp|autotest|bin|\.git|\.autotest)% 
+
+    # Ignore any mappings that Autotest may have already set up
+    clear_mappings
+
+    # run all specs if spec_helper is modified
+    add_mapping %r%^spec/spec_helper\.rb% do |_,_|
+      all_specs
+    end
+
+    # run all specs if main lib file is modified
+    add_mapping %r%^lib/merb_simple_views\.rb% do |_,_|
+      all_specs
+    end
+
+    # changing a lib file runs corresponding spec
+    add_mapping %r%^lib/merb_simple_views/(.*)\.rb% do |_, m|
+      files_matching %r%^spec/.*#{m[1]}_spec\.rb$%
+    end
+
+    # Changing a spec will cause it to run itself
+    add_mapping %r%^spec/.*_spec\.rb$% do |filename, _|
+      filename
+    end
+
+  end
+
+  # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  def failed_results(results)
+    results.scan(/^\d+\)\n(?:\e\[\d*m)?(?:.*?Error in )?'([^\n]*)'(?: FAILED)?(?:\e\[\d*m)?\n(.*?)\n\n/m)
+  end
+
+  def handle_results(results)
+    @failures      = failed_results(results)
+    @files_to_test = consolidate_failures(@failures)
+    @files_to_test.empty? && !$TESTING ? hook(:green) : hook(:red)
+    @tainted = !@files_to_test.empty?
+  end
+
+  def consolidate_failures(failed)
+    filters = Hash.new { |h,k| h[k] = [] }
+    failed.each do |spec, failed_trace|
+      if f = test_files_for(failed).find { |f| f =~ /spec\// }
+        filters[f] << spec
+        break
+      end
+    end
+    filters
+  end
+
+  def make_test_cmd(specs_to_runs)
+    [
+      ruby,
+      "-S",
+      spec_command,
+      add_options_if_present,
+      files_to_test.keys.flatten.join(' ')
+    ].join(' ')
+  end
+
+  def add_options_if_present
+    File.exist?("spec/spec.opts") ? "-O spec/spec.opts " : ""
+  end
+
+  # Finds the proper spec command to use. Precendence is set in the
+  # lazily-evaluated method spec_commands.  Alias + Override that in
+  # ~/.autotest to provide a different spec command then the default
+  # paths provided.
+  def spec_command(separator=File::ALT_SEPARATOR)
+    unless defined?(@spec_command)
+      @spec_command = spec_commands.find { |cmd| File.exists?(cmd) }
+
+      raise RspecCommandError, "No spec command could be found" unless @spec_command
+
+      @spec_command.gsub!(File::SEPARATOR, separator) if separator
+    end
+    @spec_command
+  end
+
+  # Autotest will look for spec commands in the following
+  # locations, in this order:
+  #
+  #   * default spec bin/loader installed in Rubygems
+  #   * any spec command found in PATH
+  def spec_commands
+    [File.join(Config::CONFIG['bindir'], 'spec'), 'spec']
+  end
+
+  private
+
+    # Runs +files_matching+ for all specs
+    def all_specs
+      files_matching %r%^spec/.*_spec\.rb$%
+    end
+end

data/lib/merb_simple_views.rb

@@ -0,0 +1,33 @@
+if defined?(Merb::Plugins)
+  dir = Pathname(__FILE__).dirname / 'merb_simple_views'
+
+  # Make Merb::RenderMixin's #render and #display methods chainable
+  #
+  # ==== Notes
+  # This is used as a (arguably) more elegant workaround to
+  # alias_method_chaining them.
+  #
+  # "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."
+  # -- http://yehudakatz.com/2008/05/22/the-greatest-thing-since-sliced-merb/
+  #
+  # Ideally those methods would be declared chainable within the RenderMixin
+  # itself and this monkey patch wouldn't be needed.
+  Merb::RenderMixin.module_eval do
+    [:render, :display].each do |name|
+      method = instance_method(name)
+      self.class.chainable { send(:define_method, name, method) }
+    end
+  end
+
+  require dir / 'template_parser'
+  require dir / 'mixin'
+
+  # config options
+  Merb::Plugins.config[:simple_views] = {}
+
+  Merb::BootLoader.after_app_loads do
+    Merb::Controller.class_eval { include SimpleViews::Mixin }
+  end
+end

data/lib/merb_simple_views/mixin.rb

@@ -0,0 +1,84 @@
+module SimpleViews
+
+  TEMPLATES = {}
+
+  # Adds SimpleViews functionality to a Merb controller, allowing templates
+  # defined in the controller's file to serve as views. See README for more.
+  module Mixin
+    attr_reader :_template_parser
+
+    def initialize
+      @_template_parser = SimpleViews::TemplateParser.new
+      super
+    end
+
+    # In addition to default #render behaviour, parse simple views defined in
+    # controller's file and render them when requested, or render external
+    # templates otherwise.
+    #
+    # ==== Notes
+    # 1. Turned into a chainable method in merb_simple_views.rb
+    # 2. Uses a VirtualFile to trick template engines.
+    #
+    # ==== Parameters
+    # See Merb::RenderMixin#render
+    #
+    # ==== Options
+    # See Merb::RenderMixin#render
+    #
+    # ==== Returns
+    # See Merb::RenderMixin#render
+    #
+    # ==== Raises
+    # See Merb::RenderMixin#render
+    #
+    # ==== Alternatives
+    # See Merb::RenderMixin#render
+    #
+    # :api: public
+    def render(*args)
+      tpls_file = (@__caller_info__ || __caller_info__).first.first
+      self._template_parser.load(tpls_file).parse.each do |template_name, raw_content|
+        # no controller name if absolute view path
+        ctrl_name = template_name.match(/^\//) ? nil : self.controller_name
+        path = Merb.dir_for(:view) / self._template_location(template_name.gsub(/^\//,''), nil, ctrl_name)
+        file = VirtualFile.new(raw_content, path)
+        TEMPLATES[path.to_s] = file
+      end
+      super
+    end
+
+    # Wrap #display and store caller info so that #render (called internally by
+    # #display) knows what file to fetch template data from.
+    #
+    # ==== Notes
+    # Turned into a chainable method in merb_simple_views.rb
+    #
+    # ==== Parameters
+    # See Merb::RenderMixin#display
+    #
+    # ==== Options
+    # See Merb::RenderMixin#display
+    #
+    # ==== Returns
+    # See Merb::RenderMixin#display
+    #
+    # ==== Raises
+    # See Merb::RenderMixin#display
+    #
+    # ==== Alternatives
+    # See Merb::RenderMixin#display
+    #
+    # :api: public
+    def display(*args)
+      @__caller_info__ = __caller_info__
+      super
+    end
+  end
+end
+
+module Merb::Template
+  def self.load_template_io(path)
+    super || template_extensions.map {|ext| SimpleViews::TEMPLATES["#{path}.#{ext}"] }.compact.first
+  end
+end

data/lib/merb_simple_views/template_parser.rb

@@ -0,0 +1,93 @@
+module SimpleViews
+  class TemplateParser
+    # templates as a string, directly extracted from the file.
+    attr_accessor :raw_templates
+    alias :raw    :raw_templates
+    alias :raw=   :raw_templates=
+
+    # templates as a {'name' => 'content'} hash
+    attr_accessor  :parsed_templates
+    alias :parsed  :raw_templates
+    alias :parsed= :raw_templates=
+
+    def initialize
+      self.raw_templates    = ''
+      self.parsed_templates = {}
+    end
+
+    # Read a file and fetch its __END__ section, if any.
+    #
+    # ==== Parameters
+    # file<String,Pathname>:: File to find in-file templates in
+    #
+    # ==== Returns
+    # self
+    #
+    # :api: public
+    def load(file='')
+      file = Pathname(file)
+      if file.exist?
+        parts = file.read.split(/^__END__$/)
+        if parts.size > 1
+          self.raw_templates = parts[1].lstrip
+        end
+      end
+      self
+    end
+
+    # Parse templates string and extract template names and contents.
+    #
+    # Template names must be preceded with '@@', appear alone on their line,
+    # and follow the same conventions regular templates do. They can also be
+    # disabled by simply commenting out their name.
+    #
+    # ==== Parameters
+    # file<String,Pathname>:: File to find in-file templates in
+    #
+    # ==== Returns
+    # Hash:: Parsed templates as {'name' => 'content'}
+    #
+    # ==== Examples
+    #
+    #   #posts_controller.rb
+    #   [...]
+    #   __END__
+    #   @@ index.html.erb
+    #   posts
+    #
+    #   @@ show.html.erb
+    #   post01
+    #
+    #   #=> {'index.html.erb' => "posts", 'show.html.erb' => "post01"}
+    #
+    # To disable a template, comment out its name:
+    #
+    #   __END__
+    #   #@@ index.html.erb
+    #   posts
+    #
+    #   #=> {}
+    #
+    # ==== Notes
+    # Also stores the result in self.parsed_templates
+    #
+    # :api: public
+    def parse(file='')
+      self.load(file) if file
+      templates, current, ignore = {}, nil, false
+      self.raw_templates.each_line do |line|
+        if matches = line.strip.match(/^\s*(\#)*\s*@@\s*(.*)/)
+          ignore = (matches[1] && matches[1].match(/^#/)) and next #skip commented out templates
+          templates[current = matches[2]] = ''
+        elsif ignore
+          next
+        elsif current
+          templates[current] << line
+        end
+      end
+      # remove trailing witespace off every template body and template name
+      self.parsed_templates = templates.each {|key,value| templates[key.chomp.gsub(/[[:blank:]]|\t/,'')] = value.rstrip }
+      self.parsed_templates
+    end
+  end
+end

data/spec/mixin_spec.rb

@@ -0,0 +1,160 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Simple Views" do
+
+  before(:all) do
+    Merb.root.should == Pathname(__FILE__).dirname.parent.expand_path.to_s
+    views_dir = Pathname(Merb.root / "spec/fixtures/views")
+    views_dir.mkdir unless views_dir.directory?
+    Merb.push_path(:view, views_dir, "**/*")
+  end
+
+  before(:each) do
+    class Posts < Merb::Controller
+      def index()  render end
+      def edit()   render end
+      def quote()  render end
+      def nohaz()  render end
+      def random() render end
+      def show
+        obj = Object.new; def obj.to_html() '<b>x</b>' end
+        display(obj)
+      end
+      def new
+        obj = Object.new; def obj.to_html() '<b>y</b>' end
+        display(obj)
+      end
+    end
+    class Topics < Merb::Controller
+      def index() render end
+      def quote() render end
+    end
+    # -----
+    @posts  = Posts.new(fake_request)
+    @topics = Topics.new(fake_request)
+    # -----
+    clean_view_dir!
+  end
+
+  it "should be injected in Merb::Controller" do
+    Merb::Controller.included_modules.should include(SimpleViews::Mixin)
+  end
+
+  describe "parsing templates" do
+
+    it "should parse in-file templates on render" do
+      @posts._dispatch(:index)
+      @posts._template_parser.parsed_templates['index.html.erb'].should == "kittehs"
+      @posts.body.should == "kittehs"
+    end
+
+    it "should parse in-file templates on display" do
+      @posts._dispatch(:show)
+      @posts._template_parser.parsed_templates['show.html.erb'].should == "kitteh-01"
+      @posts.body.should == "kitteh-01"
+    end
+
+    it "should parse absolute paths" do
+      @posts._dispatch(:quote)
+      @posts._template_parser.parsed_templates['/posts/quote.html.erb'].should == "<i>kitteh-01</i>"
+      @posts.body.should == "<i>kitteh-01</i>"
+    end
+
+    it "should let template engines parse views" do
+      @posts._dispatch(:random)
+      @posts._template_parser.parsed_templates['/posts/random.html.erb'].should == "kitteh-<%= '07' %>"
+      @posts.body.should == "kitteh-07"
+    end
+
+    it "should respect changes to #_template_location" do
+      def @posts._template_location(context, type=nil, controller=controller_name)
+        "#{controller}.#{action_name}.#{type}"
+      end
+      @posts._dispatch(:index)
+      @posts.body.should == "tiny kittehs"
+    end
+
+    describe "with template reloading" do
+
+      it "should reload templates when code reloading is on" do
+        Merb::Config[:reload_templates] = true
+        # -----
+        @posts._dispatch(:index)
+        @posts.body.should == "kittehs"
+        # -----
+        @posts._template_parser.stub!(:parsed_templates).and_return({'index.html.erb' => 'swapped'})
+        # -----
+        @posts._dispatch(:index)
+        @posts.body.should == "swapped"
+      end
+
+      it "should not reload templates when code reloading is off" do
+        Merb::Config[:reload_templates] = false
+        # -----
+        @posts._dispatch(:index)
+        @posts.body.should == "kittehs"
+        # -----
+        @posts._template_parser.stub!(:parsed_templates).and_return({'index.html.erb' => 'swapped'})
+        # -----
+        @posts._dispatch(:index)
+        @posts.body.should == "kittehs"
+      end
+    end
+
+    describe "falling back to default behaviour" do
+
+      it "should delegate to regular render control flow when no in-file template exists" do
+        write_template('edit.html.erb', "<i>ohaie!</i>", @posts)
+        @posts._dispatch(:edit)
+        @posts.body.should == "<i>ohaie!</i>"
+      end
+
+      it "should delegate to regular display control flow when no in-file template exists" do
+        @posts._dispatch(:new)
+        @posts.body.should == "<b>y</b>"
+      end
+
+      it "should raise exception when template is not found" do
+        lambda {
+          @posts._dispatch(:nohaz)
+        }.should raise_error(Merb::ControllerExceptions::TemplateNotFound)
+      end
+    end
+
+    describe "with multiple controllers" do
+
+      it "should pick up templates from the same file" do
+        @posts._dispatch(:quote)
+        @posts.body.should == "<i>kitteh-01</i>"
+        @topics._dispatch(:quote)
+        @topics.body.should == "<i>ceilingcat</i>"
+      end
+
+      it "should allow different controllers to use the same, relative template" do
+        @posts._dispatch(:index)
+        @posts.body.should == "kittehs"
+        @topics._dispatch(:index)
+        @topics.body.should == "kittehs"
+      end
+    end
+  end
+end
+
+__END__
+@@ index.html.erb
+kittehs
+
+@@ show.html.erb
+kitteh-01
+
+@@ /posts/random.html.erb
+kitteh-<%= '07' %>
+
+@@ /posts/quote.html.erb
+<i>kitteh-01</i>
+
+@@ /topics/quote.html.erb
+<i>ceilingcat</i>
+
+@@ /posts.index.html.erb
+tiny kittehs

data/spec/spec.opts

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

data/spec/spec_helper.rb

@@ -0,0 +1,51 @@
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'rubygems'
+require 'spec'
+require 'merb-core'
+require 'merb_simple_views'
+
+begin
+  require 'ruby-debug'
+rescue LoadError, RuntimeError
+  # i can haz dibugz plz?
+end
+
+Merb.start :environment => 'test', :adapter => 'runner'
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# Core Extensions
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# This might cause errors to slip into specs, but it beats using fixtures.
+class String
+  def unindent
+    indent = self.select {|line| !line.strip.empty? }.map {|line| line.index(/[^\s]/) }.compact.min
+    self.gsub(/^[[:blank:]]{#{indent}}/, '')
+  end
+  def unindent!
+    self.replace(self.unindent)
+  end
+end
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# Helpers
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+module Helpers
+  def write_template(name, content, controller)
+    view_path = Merb.dir_for(:view) / controller.controller_name / name
+    view_path.dirname.mkdir
+    Kernel.open(view_path, 'w+') {|file| file.write(content) }
+  end
+
+  def clean_view_dir!
+    FileUtils.rm_rf( Pathname.glob(Merb.dir_for(:view) / "*") )
+  end
+end
+
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+# Config
+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Spec::Runner.configure do |config|
+  config.include Merb::Test::RequestHelper
+  config.include Helpers
+end

data/spec/template_parser_spec.rb

@@ -0,0 +1,52 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Parser" do
+
+  before(:each) do
+    @parser = SimpleViews::TemplateParser.new.load(__FILE__)
+  end
+
+  it "should load in-file templates" do
+    @parser.raw_templates.should match(/ohaie/)
+  end
+
+  describe "when parsing template strings" do
+
+    it "should split templates at @@ marks" do
+      @parser.raw = %|
+        @@ index
+        kittehs
+        @@ show
+        kitteh1
+      |.unindent
+      @parser.parse.size.should == 2
+      @parser.parse['index'].strip.should == 'kittehs'
+      @parser.parse['show'].strip.should  == 'kitteh1'
+    end
+
+    it "should remove trailing witespace off every template" do
+      @parser.raw = %|
+        @@ index
+
+        kittehs \t\n
+      |.unindent
+      @parser.parse['index'].should_not match(/\t\n$/)
+      @parser.parse['index'].should     match(/^\n/)
+    end
+
+    it "should not be bothered by amount of spaces or tabs between marker and template name" do
+      @parser.raw = %|
+        @@index
+        kittehs
+        @@\t\sshow
+        kitteh1
+      |.unindent
+      @parser.parse['index'].should_not be_nil
+      @parser.parse['show'].should_not be_nil
+      @parser.parse["\t\sshow"].should be_nil
+    end
+  end
+end
+
+__END__
+ohaie

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: mynyml-merb_simple_views
+version: !ruby/object:Gem::Version 
+  version: 0.5.0
+platform: ruby
+authors: 
+- Martin Aumont
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-14 21:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: merb-core >= 1.0
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Merb plugin that allows defining templates (views, css, js)in the same file as the controller.
+email: mynyml@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- CHANGELOG
+- log
+- lib
+- lib/merb_simple_views.rb
+- lib/merb_simple_views
+- lib/merb_simple_views/mixin.bk.rb
+- lib/merb_simple_views/cache.rb
+- lib/merb_simple_views/cache.bk.rb
+- lib/merb_simple_views/merbtasks.rb
+- lib/merb_simple_views/merbtasks.bk.rb
+- lib/merb_simple_views/mixin.rb
+- lib/merb_simple_views/template_parser.rb
+- lib/merb_simple_views.bk.rb
+- LICENSE
+- README
+- Rakefile
+- MYTODO
+- draft
+- TODO
+- autotest
+- autotest/rspec_simpleviews.rb
+- autotest/discover.rb
+- autotest/rspec_simpleviews.bk.rb
+- spec
+- spec/spec_helper.rb
+- spec/mixin_spec.bk.rb
+- spec/mixin_spec.rb
+- spec/fixtures
+- spec/fixtures/views
+- spec/fixtures/controller3.rb
+- spec/spec.opts
+- spec/template_parser_spec.rb
+has_rdoc: true
+homepage: ""
+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.2.0
+signing_key: 
+specification_version: 2
+summary: Merb plugin that allows defining templates (views, css, js)in the same file as the controller.
+test_files: []
+