ruote-kit 2.1.4.1 → 2.1.7

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

@@ -1,102 +0,0 @@
-## 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

@@ -1,30 +0,0 @@
-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

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

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

@@ -1,206 +0,0 @@
-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

@@ -1,56 +0,0 @@
-# -*- 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

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

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

@@ -1,53 +0,0 @@
-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

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

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

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

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

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

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

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

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

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