rubycut-sinatra-contrib 1.4.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008-2011 Nicolas Sanguinetti, entp.com, Konstantin Haase
+
+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.md

@@ -0,0 +1,136 @@
+[![Build Status](https://secure.travis-ci.org/sinatra/sinatra-contrib.png)](http://travis-ci.org/sinatra/sinatra-contrib)
+
+Collection of common Sinatra extensions, semi-officially supported.
+
+# Goals
+
+* For every future Sinatra release, have at least one fully compatible release
+* High code quality, high test coverage
+* Include plugins people usually ask for a lot
+
+# Included extensions
+
+## Common Extensions
+
+These are common extension which will not add significant overhead or change any
+behavior of already existing APIs. They do not add any dependencies not already
+installed with this gem.
+
+Currently included:
+
+* `sinatra/capture`: Let's you capture the content of blocks in templates.
+
+* `sinatra/config_file`: Allows loading configuration from yaml files.
+
+* `sinatra/content_for`: Adds Rails-style `content_for` helpers to Haml, Erb,
+  Erubis and Slim.
+
+* `sinatra/cookies`: A `cookies` helper for reading and writing cookies.
+
+* `sinatra/engine_tracking`: Adds methods like `haml?` that allow helper
+  methods to check whether they are called from within a template.
+
+* `sinatra/json`: Adds a `#json` helper method to return JSON documents.
+
+* `sinatra/link_header`: Helpers for generating `link` HTML tags and
+  corresponding `Link` HTTP headers. Adds `link`, `stylesheet` and `prefetch`
+  helper methods.
+
+* `sinatra/multi_route`: Adds ability to define one route block for multiple
+  routes and multiple or custom HTTP verbs.
+
+* `sinatra/namespace`: Adds namespace support to Sinatra.
+
+* `sinatra/respond_with`: Choose action and/or template automatically
+  depending on the incoming request. Adds helpers `respond_to` and
+  `respond_with`.
+
+
+## Custom Extensions
+
+These extensions may add additional dependencies and enhance the behavior of the
+existing APIs.
+
+Currently included:
+
+* `sinatra/decompile`: Recreates path patterns from Sinatra's internal data
+  structures (used by other extensions).
+
+* `sinatra/reloader`: Automatically reloads Ruby files on code changes.
+
+## Other Tools
+
+* `sinatra/extension`: Mixin for writing your own Sinatra extensions.
+
+* `sinatra/test_helpers`: Helper methods to ease testing your Sinatra
+  application. Partly extracted from Sinatra. Testing framework agnostic
+
+# Installation
+Add `gem 'sinatra-contrib'` to *Gemfile*, then execute `bundle install`.  
+
+If you don't use Bundler, install the gem manually by executing `gem install sinatra-contrib` in your command line.
+
+
+# Usage
+
+## Classic Style
+
+A single extension (example: sinatra-content-for):
+
+``` ruby
+require 'sinatra'
+require 'sinatra/content_for'
+```
+
+Common extensions:
+
+``` ruby
+require 'sinatra'
+require 'sinatra/contrib'
+```
+
+All extensions:
+
+``` ruby
+require 'sinatra'
+require 'sinatra/contrib/all'
+```
+
+## Modular Style
+
+A single extension (example: sinatra-content-for):
+
+``` ruby
+require 'sinatra/base'
+require 'sinatra/content_for'
+require 'sinatra/namespace'
+
+class MyApp < Sinatra::Base
+  # Note: Some modules are extensions, some helpers, see the specific
+  # documentation or the source
+  helpers Sinatra::ContentFor
+  register Sinatra::Namespace
+end
+```
+
+Common extensions:
+
+``` ruby
+require 'sinatra/base'
+require 'sinatra/contrib'
+
+class MyApp < Sinatra::Base
+  register Sinatra::Contrib
+end
+```
+
+All extensions:
+
+``` ruby
+require 'sinatra/base'
+require 'sinatra/contrib/all'
+
+class MyApp < Sinatra::Base
+  register Sinatra::Contrib
+end
+```

data/Rakefile

@@ -0,0 +1,75 @@
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+require 'open-uri'
+require 'yaml'
+require 'sinatra/contrib/version'
+
+desc "run specs"
+task(:spec) { ruby '-S rspec spec -c' }
+task(:test => :spec)
+task(:default => :spec)
+
+namespace :doc do
+  task :readmes do
+    Dir.glob 'lib/sinatra/*.rb' do |file|
+      excluded_files = %w[lib/sinatra/contrib.rb lib/sinatra/capture.rb lib/sinatra/engine_tracking.rb]
+      next if excluded_files.include?(file)
+      doc  = File.read(file)[/^module Sinatra(\n)+(  #[^\n]*\n)*/m].scan(/^ *#(?!#) ?(.*)\n/).join("\n")
+      file = "doc/#{file[4..-4].tr("/_", "-")}.rdoc"
+      Dir.mkdir "doc" unless File.directory? "doc"
+      puts "writing #{file}"
+      File.open(file, "w") { |f| f << doc }
+    end
+  end
+
+  task :all => [:readmes]
+end
+
+desc "generate documentation"
+task :doc => 'doc:all'
+
+desc "generate gemspec"
+task 'sinatra-contrib.gemspec' do
+  content = File.read 'sinatra-contrib.gemspec'
+
+  fields = {
+    :authors => `git shortlog -sn`.scan(/[^\d\s].*/),
+    :email   => `git shortlog -sne`.scan(/[^<]+@[^>]+/),
+    :files   => `git ls-files`.split("\n").reject { |f| f =~ /^(\.|Gemfile)/ }
+  }
+
+  fields.each do |field, values|
+    updated = "  s.#{field} = ["
+    updated << values.map { |v| "\n    %p" % v }.join(',')
+    updated << "\n  ]"
+    content.sub!(/  s\.#{field} = \[\n(    .*\n)*  \]/, updated)
+  end
+
+  content.sub! /(s\.version.*=\s+).*/, "\\1\"#{Sinatra::Contrib::VERSION}\""
+  File.open('sinatra-contrib.gemspec', 'w') { |f| f << content }
+end
+
+task :gemspec => 'sinatra-contrib.gemspec'
+
+desc 'update travis config to correspond to sinatra'
+task :travis, [:branch] do |t, a|
+  a.with_defaults :branch => :master
+  data = YAML.load open("https://raw.github.com/sinatra/sinatra/#{a.branch}/.travis.yml")
+  data["notifications"]["recipients"] << "ohhgabriel@gmail.com"
+  File.open('.travis.yml', 'w') { |f| f << data.to_yaml }
+  system 'git add .travis.yml && git diff --cached .travis.yml'
+end
+
+task :release => :gemspec do
+  sh <<-SH
+    rm -Rf sinatra-contrib*.gem &&
+    gem build sinatra-contrib.gemspec &&
+    gem install sinatra-contrib*.gem --local &&
+    gem push sinatra-contrib*.gem  &&
+    git commit --allow-empty -a -m '#{Sinatra::Contrib::VERSION} release'  &&
+    git tag -s v#{Sinatra::Contrib::VERSION} -m '#{Sinatra::Contrib::VERSION} release'  &&
+    git tag -s #{Sinatra::Contrib::VERSION} -m '#{Sinatra::Contrib::VERSION} release'  &&
+    git push && (git push sinatra || true) &&
+    git push --tags && (git push sinatra --tags || true)
+  SH
+end
+

data/ideas.md

@@ -0,0 +1,29 @@
+* Extension that does something like this:
+
+      def build(*)
+        if settings.memcached?
+          use Rack::Cache, :backend => :memcached
+          use Rack::Session::Memcached
+          # ...
+        end
+        super
+      end
+
+* `sinatra-smart-cache`: update cache header only if arguments are more
+  restrictive than curent value, set caching headers that way for most helper
+  methods (i.e. `sass` or `send_file`)
+
+* Some verbose logging extension: Log what filters, routes, error handlers,
+  templates, and so on is used.
+
+* Form helpers, with forms as first class objects that accepts hashes or
+  something, so the form meta data can also be used to expose a JSON API or
+  similar, possibly defining routes (like "Sinatra's Hat"), strictly using
+  the ActiveModel API.
+
+* Extend `sinatra-content-for` to support Liquid, Radius, Markaby, Nokogiri and
+  Builder. At least the first two probably involve patching Tilt.
+
+* Rewrite of `sinatra-compass`?
+
+* Helpers for HTML escaping and such.

data/lib/sinatra/capture.rb

@@ -0,0 +1,124 @@
+require 'sinatra/base'
+require 'sinatra/engine_tracking'
+require 'backports'
+
+module Sinatra
+  #
+  # = Sinatra::Capture
+  #
+  # Extension that enables blocks inside other extensions.
+  # It currently works for erb, slim and haml.
+  # Enables mixing of different template languages.
+  #
+  # Example:
+  #
+  #    # in hello_world.erb
+  #
+  #    Say
+  #    <% a = capture do %>World<% end %>
+  #    Hello <%= a %>!
+  #
+  #    # in hello_world.slim
+  #
+  #    | Say
+  #    - a = capture do
+  #      | World
+  #    |  Hello #{a}!
+  #
+  #    # in hello_world.haml
+  #
+  #    Say
+  #    - a = capture do
+  #      World
+  #      Hello #{a.strip}!
+  #
+  #
+  # You can also use nested blocks.
+  #
+  # Example
+  #
+  #     # in hello_world.erb
+  #
+  #     Say
+  #     <% a = capture do %>
+  #       <% b = capture do %>World<% end %>
+  #         <%= b %>!
+  #     <% end %>
+  #     Hello <%= a.strip %>
+  #
+  #
+  # The main advantage of capture is mixing of different template engines.
+  #
+  # Example
+  #
+  #    # in mix_me_up.slim
+  #
+  #    - two = capture do
+  #      - erb "<%= 1 + 1 %>"
+  #    | 1 + 1 = #{two}
+  #
+  # == Usage
+  #
+  # === Classic Application
+  #
+  # In a classic application simply require the helpers, and start using them:
+  #
+  #     require "sinatra"
+  #     require "sinatra/capture"
+  #
+  #     # The rest of your classic application code goes here...
+  #
+  # === Modular Application
+  #
+  # In a modular application you need to require the helpers, and then tell
+  # the application you will use them:
+  #
+  #     require "sinatra/base"
+  #     require "sinatra/capture"
+  #
+  #     class MyApp < Sinatra::Base
+  #       helpers Sinatra::Capture
+  #
+  #       # The rest of your modular application code goes here...
+  #     end
+  #
+  module Capture
+    include Sinatra::EngineTracking
+
+    DUMMIES = {
+      :haml   => "!= capture_haml(*args, &block)",
+      :erubis => "<% @capture = yield(*args) %>",
+      :slim   => "== yield(*args)"
+    }
+
+    def capture(*args, &block)
+      @capture = nil
+      if current_engine == :ruby
+        result = block[*args]
+      elsif current_engine == :erb
+        @_out_buf, _buf_was = '', @_out_buf
+        block[*args]
+        result = eval('@_out_buf', block.binding)
+        @_out_buf = _buf_was
+      else
+        buffer     = eval '_buf if defined?(_buf)', block.binding
+        old_buffer = buffer.dup if buffer
+        dummy      = DUMMIES.fetch(current_engine)
+        options    = { :layout => false, :locals => {:args => args, :block => block }}
+
+        buffer.try :clear
+        result = render(current_engine, dummy, options, &block)
+      end
+      result.strip.empty? && @capture ? @capture : result
+    ensure
+      buffer.try :replace, old_buffer
+    end
+
+    def capture_later(&block)
+      engine = current_engine
+      proc { |*a| with_engine(engine) { @capture = capture(*a, &block) }}
+    end
+  end
+
+  helpers Capture
+end

data/lib/sinatra/config_file.rb

@@ -0,0 +1,167 @@
+require 'sinatra/base'
+require 'yaml'
+require 'erb'
+
+module Sinatra
+
+  # = Sinatra::ConfigFile
+  #
+  # <tt>Sinatra::ConfigFile</tt> is an extension that allows you to load the
+  # application's configuration from YAML files.  It automatically detects if
+  # the files contains specific environment settings and it will use the
+  # corresponding to the current one.
+  #
+  # You can access those options through +settings+ within the application. If
+  # you try to get the value for a setting that hasn't been defined in the
+  # config file for the current environment, you will get whatever it was set
+  # to in the application.
+  #
+  # == Usage
+  #
+  # Once you have written your configurations to a YAML file you can tell the
+  # extension to load them.  See below for more information about how these
+  # files are interpreted.
+  #
+  # For the examples, lets assume the following config.yml file:
+  #
+  #     greeting: Welcome to my file configurable application
+  #
+  # === Classic Application
+  #
+  #     require "sinatra"
+  #     require "sinatra/config_file"
+  #
+  #     config_file 'path/to/config.yml'
+  #
+  #     get '/' do
+  #       @greeting = settings.greeting
+  #       haml :index
+  #     end
+  #
+  #     # The rest of your classic application code goes here...
+  #
+  # === Modular Application
+  #
+  #     require "sinatra/base"
+  #     require "sinatra/config_file"
+  #
+  #     class MyApp < Sinatra::Base
+  #       register Sinatra::ConfigFile
+  #
+  #       config_file 'path/to/config.yml'
+  #
+  #       get '/' do
+  #         @greeting = settings.greeting
+  #         haml :index
+  #       end
+  #
+  #       # The rest of your modular application code goes here...
+  #     end
+  #
+  # === Config File Format
+  #
+  # In its most simple form this file is just a key-value list:
+  #
+  #     foo: bar
+  #     something: 42
+  #     nested:
+  #       a: 1
+  #       b: 2
+  #
+  # But it also can provide specific environment configuration.  There are two
+  # ways to do that: at the file level and at the setting level.  They are
+  # illustrated, repsectively, as follows:
+  #
+  #     development:
+  #       foo: development
+  #       bar: bar
+  #     test:
+  #       foo: test
+  #       bar: bar
+  #     production:
+  #       foo: production
+  #       bar: bar
+  #
+  # and
+  #
+  #     foo:
+  #       development: development
+  #       test: test
+  #       production: production
+  #     bar: bar
+  #
+  # In either case, <tt>settings.foo</tt> will return the environment name, and
+  # <tt>settings.bar</tt> will return <tt>"bar"</tt>.
+  #
+  # Be aware that if you have a different environment, besides development,
+  # test and production, you will also need to adjust the +environments+
+  # setting, otherwise the settings will not load.  For instance, when
+  # you also have a staging environment:
+  #
+  #     set :environments, %w{development test production staging}
+  #
+  # If you wish to provide defaults that may be shared among all the environments,
+  # this can be done by using one of the existing environments as the default using
+  # the YAML alias, and then overwriting values in the other environments:
+  #
+  #     development: &common_settings
+  #       foo: 'foo'
+  #       bar: 'bar'
+  #
+  #     production:
+  #       <<: *common_settings
+  #       bar: 'baz' # override the default value
+  #
+  module ConfigFile
+
+    # When the extension is registered sets the +environments+ setting to the
+    # traditional environments: development, test and production.
+    def self.registered(base)
+      base.set :environments, %w[test production development]
+    end
+
+    # Loads the configuration from the YAML files whose +paths+ are passed as
+    # arguments, filtering the settings for the current environment.  Note that
+    # these +paths+ can actually be globs.
+    def config_file(*paths)
+      Dir.chdir(root || '.') do
+        paths.each do |pattern|
+          Dir.glob(pattern) do |file|
+            $stderr.puts "loading config file '#{file}'" if logging?
+            document = IO.read(file)
+            document = ERB.new(document).result if file.split('.').include?('erb')
+            yaml = config_for_env(YAML.load(document)) || {}
+            yaml.each_pair do |key, value|
+              for_env = config_for_env(value)
+              set key, for_env unless value and for_env.nil? and respond_to? key
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    # Given a +hash+ with some application configuration it returns the
+    # settings applicable to the current environment.  Note that this can only
+    # be done when all the keys of +hash+ are environment names included in the
+    # +environments+ setting (which is an Array of Strings).  Also, the
+    # returned config is a indifferently accessible Hash, which means that you
+    # can get its values using Strings or Symbols as keys.
+    def config_for_env(hash)
+      if hash.respond_to? :keys and hash.keys.all? { |k| environments.include? k.to_s }
+        hash = hash[environment.to_s] || hash[environment.to_sym]
+      end
+
+      if hash.respond_to? :to_hash
+        indifferent_hash = Hash.new {|hash,key| hash[key.to_s] if Symbol === key }
+        indifferent_hash.merge hash.to_hash
+      else
+        hash
+      end
+    end
+  end
+
+  register ConfigFile
+  Delegator.delegate :config_file
+end