ruote-kit 2.1.4

data/lib/ruote-kit/vendor/sinatra-respond_to/README.markdown

@@ -0,0 +1,102 @@
+## About
+
+
+## Examples
+
+    require 'sinatra'
+    require 'sinatra/respond_to'
+
+    get '/posts' do
+      @posts = Post.recent
+
+      respond_to do |wants|
+        wants.html { haml :posts }      # => views/posts.html.haml, also sets content_type to text/html
+        wants.rss { haml :posts }       # => views/posts.rss.haml, also sets content_type to application/rss+xml
+        wants.atom { haml :posts }      # => views/posts.atom.haml, also sets content_type to appliation/atom+xml
+      end
+    end
+
+    get '/post/:id' do
+      @post = Post.find(params[:id])
+
+      respond_to do |wants|
+        wants.html { haml :post }       # => views/post.html.haml, also sets content_type to text/html
+        wants.xhtml { haml :post }      # => views/post.xhtml.haml, also sets content_type to application/xhtml+xml
+        wants.xml { @post.to_xml }      # => sets content_type to application/xml
+        wants.js { erb :post }          # => views/post.js.erb, also sets content_type to application/javascript
+      end
+    end
+
+    get '/comments/:id' do
+      @comment = Comment.find(params[:id])
+
+      respond_to do |wants|
+        wants.html { haml :comment }    # => views/comment.html.haml, also sets content_type to text/html
+        wants.json { @comment.to_json } # => sets content_type to application/json
+        wants.js { erb :comment }       # => views/comment.js.erb, also sets content_type to application/javascript
+      end
+    end
+
+To change the character set of the response, there is a <tt>charset</tt> helper.  For example
+
+    get '/iso-8859-1' do
+      charset 'iso-8859-1'
+      "This is now sent using iso-8859-1 character set"
+    end
+
+    get '/respond_to-mixed' do
+      respond_to do |wants|
+        wants.html { charset 'iso-8859-1'; "Some html in iso-8859-1" }
+        wants.xml { builder :utf-8-xml }    # => this is returned in the default character set
+      end
+    end
+
+## Configuration
+
+There a few options available for configuring the default behavior of respond_to using Sinatra's
+<tt>set</tt> utility.
+
+* <tt>default\_charset - utf-8</tt><br />
+    Assumes all text documents are encoded using this character set.
+    This can be overridden within the respond_to block for the appropriate format
+* <tt>default\_content - :html</tt><br />
+    When a user vists a url without an extension, for example /post this will be
+    the assumed content to serve first.  Expects a symbol as used in setting content_type.
+* <tt>assume\_xhr\_is\_js - true</tt><br />
+    To avoid headaches with accept headers, and appending .js to urls, this will
+    cause the default format for all XmlHttpRequests to be classified as wanting Javascript
+    in the response.
+
+## Installing
+    sudo gem install cehoffman-sinatra-respond_to --source=http://gems.github.com
+
+## Cavaets
+Due to the way respond\_to works, all incoming requests have the extension striped from the request.path\_info.
+This causes routes like the following to fail.
+
+    get '/style.css' do
+      content_type :css, :charset => 'utf-8'
+      sass :style   # => renders views/style.sass
+    end
+
+They need to be changed to the following.  Note that you no longer have to set the content\_type or charset.
+
+    get '/style' do
+      sass :style   # => renders views/style.css.sass
+    end
+
+If you want to ensure the route only gets called for css requests try this.  This will use sinatra's built in accept header matching.
+
+    get '/style', :provides => :css do
+      sass :style
+    end
+
+## Issues
+
+Sinatra has a bug that affects Classic style applications and extensions see [#215][215] and [#180][180].
+I have worked around this by explicitly registering RespondTo with the top level Sinatra::Application when
+requiring sinatra/respond\_to.
+
+[215]: https://sinatra.lighthouseapp.com/projects/9779/tickets/215-extensions-cannot-define-before-filters-for-classic-apps "Extensions cannot define before filters for classic apps"
+[180]: https://sinatra.lighthouseapp.com/projects/9779/tickets/180-better-route-inheritence "Better route inheritence"
+

data/lib/ruote-kit/vendor/sinatra-respond_to/Rakefile

@@ -0,0 +1,30 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |spec|
+    spec.name = 'sinatra-respond_to'
+    spec.summary = 'A respond_to style Rails block for baked-in web service support in Sinatra'
+    spec.email = 'cehoffman@gmail.com'
+    spec.homepage = 'http://github.com/cehoffman/sinatra-respond_to'
+    spec.description = spec.summary
+    spec.authors = ["Chris Hoffman"]
+    spec.add_dependency('sinatra-sinatra', '>= 0.9.1.3')
+  end
+rescue LoadError
+  puts "Jewler not available.  Install it with sugo gem install technicalpickles-jeweler -s http://gems.github.com"
+end
+
+begin
+  require 'spec/rake/spectask'
+  desc "Run specs"
+  Spec::Rake::SpecTask.new do |t|
+    t.spec_files = FileList['spec/*_spec.rb']
+    t.spec_opts = %w(-fp --color)
+
+    t.rcov = true
+    t.rcov_opts << '--text-summary'
+    t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
+    t.rcov_opts << '--exclude' << '.gem,pkg,spec'
+  end
+rescue LoadError
+  puts "RSpec not available. Install it with sudo gem install rspec."
+end

data/lib/ruote-kit/vendor/sinatra-respond_to/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 6
+:major: 0
+:minor: 3

data/lib/ruote-kit/vendor/sinatra-respond_to/lib/sinatra/respond_to.rb

@@ -0,0 +1,206 @@
+require 'sinatra/base'
+
+# Accept header parsing was looked at but deemed
+# too much of an irregularity to deal with.  Problems with the header
+# differences from IE, Firefox, Safari, and every other UA causes
+# problems with the expected output.  The general expected behavior
+# would be serve html when no extension provided, but most UAs say
+# they will accept application/xml with out a quality indicator, meaning
+# you'd get the xml block served insead.  Just plain retarded, use the
+# extension and you'll never be suprised.
+
+module Sinatra
+  module RespondTo
+    class UnhandledFormat < Sinatra::NotFound; end
+    class MissingTemplate < Sinatra::NotFound
+      def code; 500 end
+    end
+
+    TEXT_MIME_TYPES = [:txt, :html, :js, :json, :xml, :rss, :atom, :css, :asm, :c, :cc, :conf,
+                       :csv, :cxx, :diff, :dtd, :f, :f77, :f90, :for, :gemspec, :h, :hh, :htm,
+                       :log, :mathml, :mml, :p, :pas, :pl, :pm, :py, :rake, :rb, :rdf, :rtf, :ru,
+                       :s, :sgm, :sgml, :sh, :svg, :svgz, :text, :wsdl, :xhtml, :xsl, :xslt, :yaml,
+                       :yml, :ics]
+
+    def self.registered(app)
+      app.helpers RespondTo::Helpers
+
+      app.set :default_charset, 'utf-8'
+      app.set :default_content, :html
+      app.set :assume_xhr_is_js, true
+
+      # We remove the trailing extension so routes
+      # don't have to be of the style
+      #
+      #   get '/resouce.:format'
+      #
+      # They can instead be of the style
+      #
+      #   get '/resource'
+      #
+      # and the format will automatically be available in <tt>format</tt>
+      app.before do
+        unless options.static? && options.public? && (request.get? || request.head?) && static_file?(request.path_info)
+          request.path_info.sub! %r{\.([^\./]+)$}, ''
+
+          format request.xhr? && options.assume_xhr_is_js? ? :js : $1 || options.default_content
+
+          charset options.default_charset if Sinatra::RespondTo::TEXT_MIME_TYPES.include? format
+        end
+      end
+
+     app.configure :development do |dev|
+        # Very, very, very hackish but only for development at least
+        # Modifies the regex matching /__sinatra__/:image.png to not have the extension
+        ["GET", "HEAD"].each do |verb|
+          dev.routes[verb][1][0] = Regexp.new(dev.routes[verb][1][0].source.gsub(/\\\.[^\.\/]+\$$/, '$'))
+        end
+
+        dev.error UnhandledFormat do
+          content_type :html, :charset => 'utf-8'
+
+          (<<-HTML).gsub(/^ {10}/, '')
+          <!DOCTYPE html>
+          <html>
+          <head>
+            <style type="text/css">
+            body { text-align:center;font-family:helvetica,arial;font-size:22px;
+              color:#888;margin:20px}
+            #c {margin:0 auto;width:500px;text-align:left}
+            </style>
+          </head>
+          <body>
+            <h2>Sinatra doesn't know this ditty.</h2>
+            <img src='/__sinatra__/404.png'>
+            <div id="c">
+              Try this:
+              <pre>#{request.request_method.downcase} '#{request.path_info}' do\n  respond_to do |wants|\n    wants.#{format} { "Hello World" }\n  end\nend</pre>
+            </div>
+          </body>
+          </html>
+          HTML
+        end
+
+        dev.error MissingTemplate do
+          content_type :html, :charset => 'utf-8'
+          response.status = request.env['sinatra.error'].code
+
+          engine = request.env['sinatra.error'].message.split('.').last
+          engine = 'haml' unless ['haml', 'builder', 'erb'].include? engine
+
+          path = File.basename(request.path_info)
+          path = "root" if path.nil? || path.empty?
+
+          format = engine == 'builder' ? 'xml' : 'html'
+
+          layout = case engine
+                   when 'haml' then "!!!\n%html\n  %body= yield"
+                   when 'erb' then "<html>\n  <body>\n    <%= yield %>\n  </body>\n</html>"
+                   when 'builder' then "builder do |xml|\n  xml << yield\nend"
+                   end
+
+          layout = "<small>app.#{format}.#{engine}</small>\n<pre>#{escape_html(layout)}</pre>"
+
+          (<<-HTML).gsub(/^ {10}/, '')
+          <!DOCTYPE html>
+          <html>
+          <head>
+            <style type="text/css">
+            body { text-align:center;font-family:helvetica,arial;font-size:22px;
+              color:#888;margin:20px}
+            #c {margin:0 auto;width:500px;text-align:left;}
+            small {float:right;clear:both;}
+            pre {clear:both;}
+            </style>
+          </head>
+          <body>
+            <h2>Sinatra can't find #{request.env['sinatra.error'].message}</h2>
+            <img src='/__sinatra__/500.png'>
+            <div id="c">
+              Try this:<br />
+              #{layout}
+              <small>#{path}.#{format}.#{engine}</small>
+              <pre>Hello World!</pre>
+              <small>application.rb</small>
+              <pre>#{request.request_method.downcase} '#{request.path_info}' do\n  respond_to do |wants|\n    wants.#{engine == 'builder' ? 'xml' : 'html'} { #{engine} :#{path}#{",\n#{' '*32}layout => :app" if layout} }\n  end\nend</pre>
+            </div>
+          </body>
+          </html>
+          HTML
+        end
+
+      end
+
+      app.class_eval do
+        private
+          def render_with_format(*args)
+            args[1] = "#{args[1]}.#{format}".to_sym if args[1].is_a?(::Symbol)
+            render_without_format *args
+          rescue Errno::ENOENT
+            raise MissingTemplate, "#{args[1]}.#{args[0]}"
+          end
+          alias_method :render_without_format, :render
+          alias_method :render, :render_with_format
+
+          def lookup_layout_with_format(*args)
+            args[1] = "#{args[1]}.#{format}".to_sym if args[1].is_a?(::Symbol)
+            lookup_layout_without_format *args
+          end
+          alias_method :lookup_layout_without_format, :lookup_layout
+          alias_method :lookup_layout, :lookup_layout_with_format
+      end
+    end
+
+    module Helpers
+      def format(val=nil)
+        unless val.nil?
+          mime_type = media_type(val)
+          fail "Unknown media type #{val}\nTry registering the extension with a mime type" if mime_type.nil?
+
+          @format = val.to_sym
+          response['Content-Type'].sub!(/^[^;]+/, mime_type)
+        end
+
+        @format
+      end
+
+      # This is mostly just a helper so request.path_info isn't changed when
+      # serving files from the public directory
+      def static_file?(path)
+        public_dir = File.expand_path(options.public)
+        path = File.expand_path(File.join(public_dir, unescape(path)))
+
+        path[0, public_dir.length] == public_dir && File.file?(path)
+      end
+
+      def charset(val=nil)
+        fail "Content-Type must be set in order to specify a charset" if response['Content-Type'].nil?
+
+        if response['Content-Type'] =~ /charset=[^;]+/
+          response['Content-Type'].sub!(/charset=[^;]+/, (val == '' && '') || "charset=#{val}")
+        else
+          response['Content-Type'] += ";charset=#{val}"
+        end unless val.nil?
+
+        response['Content-Type'][/charset=([^;]+)/, 1]
+      end
+
+      def respond_to(&block)
+        wants = {}
+        def wants.method_missing(type, *args, &handler)
+          Sinatra::Base.send(:fail, "Unknown media type for respond_to: #{type}\nTry registering the extension with a mime type") if Sinatra::Base.media_type(type).nil?
+          self[type] = handler
+        end
+
+        yield wants
+
+        raise UnhandledFormat  if wants[format].nil?
+        wants[format].call
+      end
+    end
+  end
+
+  # Get around before filter problem for classic applications by registering
+  # with the context they are run in explicitly instead of Sinatra::Default
+  Sinatra::Base.register RespondTo
+end

data/lib/ruote-kit/vendor/sinatra-respond_to/sinatra-respond_to.gemspec

@@ -0,0 +1,56 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{sinatra-respond_to}
+  s.version = "0.3.6"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Chris Hoffman"]
+  s.date = %q{2009-08-02}
+  s.description = %q{A respond_to style Rails block for baked-in web service support in Sinatra}
+  s.email = %q{cehoffman@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+    "README.markdown"
+  ]
+  s.files = [
+    "LICENSE",
+    "README.markdown",
+    "Rakefile",
+    "VERSION.yml",
+    "lib/sinatra/respond_to.rb",
+    "spec/app/public/static.txt",
+    "spec/app/test_app.rb",
+    "spec/app/unreachable_static.txt",
+    "spec/app/views/layout.html.haml",
+    "spec/app/views/resource.html.haml",
+    "spec/app/views/resource.js.erb",
+    "spec/app/views/resource.xml.builder",
+    "spec/extension_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/cehoffman/sinatra-respond_to}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{A respond_to style Rails block for baked-in web service support in Sinatra}
+  s.test_files = [
+    "spec/app/test_app.rb",
+    "spec/extension_spec.rb",
+    "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<sinatra-sinatra>, [">= 0.9.1.3"])
+    else
+      s.add_dependency(%q<sinatra-sinatra>, [">= 0.9.1.3"])
+    end
+  else
+    s.add_dependency(%q<sinatra-sinatra>, [">= 0.9.1.3"])
+  end
+end

data/lib/ruote-kit/vendor/sinatra-respond_to/spec/app/public/static.txt

@@ -0,0 +1 @@
+A static file

data/lib/ruote-kit/vendor/sinatra-respond_to/spec/app/test_app.rb

@@ -0,0 +1,53 @@
+require 'sinatra/base'
+require 'erb'
+require 'haml'
+require 'builder'
+
+class TestApp < Sinatra::Base
+  register Sinatra::RespondTo
+
+  set :views, File.join(File.dirname(__FILE__), 'views')
+  set :public, File.join(File.dirname(__FILE__), 'public')
+
+  get '/resource' do
+    respond_to do |wants|
+      wants.html { haml :resource }
+      wants.json { "We got some json" }
+      wants.xml { builder :resource }
+      wants.js { erb :resource }
+      wants.png { }
+    end
+  end
+
+  get '/default_charset' do
+    respond_to do |wants|
+      wants.html { "Should set charcter set to default_charset" }
+    end
+  end
+
+  get '/iso-8859-1' do
+    respond_to do |wants|
+      wants.html { charset 'iso-8859-1'; "Should have character set of iso-8859-1" }
+    end
+  end
+
+  get '/normal-no-respond_to' do
+    "Just some plain old text"
+  end
+
+  get '/style.css' do
+    "This route should fail"
+  end
+
+  get '/style-no-extension', :provides => :css do
+    "Should succeed only when browser accepts text/css"
+  end
+
+  get '/missing-template' do
+    respond_to do |wants|
+      wants.html { haml :missing }
+      wants.xml { builder :missing }
+      wants.js { erb :missing }
+    end
+  end
+end

data/lib/ruote-kit/vendor/sinatra-respond_to/spec/app/unreachable_static.txt

@@ -0,0 +1 @@
+Unreachable static file

data/lib/ruote-kit/vendor/sinatra-respond_to/spec/app/views/layout.html.haml

@@ -0,0 +1,2 @@
+%html
+  %body= yield

data/lib/ruote-kit/vendor/sinatra-respond_to/spec/app/views/resource.html.haml

@@ -0,0 +1 @@
+Hello from HTML

data/lib/ruote-kit/vendor/sinatra-respond_to/spec/app/views/resource.js.erb

@@ -0,0 +1,3 @@
+$(function () {
+  return '<%= "Hiya from javascript" %>'
+});

data/lib/ruote-kit/vendor/sinatra-respond_to/spec/app/views/resource.xml.builder

@@ -0,0 +1,3 @@
+builder do |xml|
+  xml.root "Some XML"
+end