tennpipes-base 3.6.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cbcb2d5135e3229fa1a8c47913992afd6c80b665
+  data.tar.gz: 2041d262a1202552fcd382bea5d0e4a7f7be8375
+SHA512:
+  metadata.gz: 78733ce2ec65e8b5b2e2c0306e87110f5d2739462c86d7b3e3c381b7890bb739ee19a1c3ec39194a2891a13b30bdda8d3f6bf206712fba2bbf5a18649aacf3f2
+  data.tar.gz: 40272f77796040f4aa8d42af105f185a002bb4629cac7ed2e3b91ba9ce5f1aab40dcbf7f625d383fe4a3746432ff28a721df80fd6a339e9cba741ef35823302c

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Tennpipes
+
+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.rdoc

@@ -0,0 +1,294 @@
+= Tennpipes (tennpipes-base)
+
+Tennpipes is the framework based on Sinatra.
+
+== Preface
+
+Tennpipes is a ruby framework built upon the excellent {Sinatra Microframework}[http://www.sinatrarb.com].
+Sinatra is a DSL for creating simple web applications in Ruby with speed and minimal effort.
+This framework tries hard to make it as fun and easy as possible to code much more advanced web applications by
+building upon the Sinatra philosophies and foundation.
+
+== Introduction
+
+Many people love Sinatra's simplicity and lightweight but often quickly come to miss a great deal
+of functionality provided by other web frameworks such as Rails when building non-trivial applications.
+
+Our goal with this framework is to match the essence of Sinatra and at the same time create a standard library
+of tools, helpers and components that will make Sinatra suitable for more complex applications.
+
+Here is a brief overview of functionality provided by the Tennpipes framework:
+
+Agnostic:: Full support for many popular testing, templating, mocking, and data storage choices.
+Generators:: Create Tennpipes applications, models, controllers i.e: tennpipes-init project.
+Mountable:: Unlike other ruby frameworks, principally designed for mounting multiple apps.
+Routing:: Full url named routes, named params, before/after filter support.
+Tag Helpers:: View helpers such as: tag, content_tag, input_tag.
+Asset Helpers:: View helpers such as: link_to, image_tag, javascript_include_tag.
+Form Helpers:: Builder support such as: form_tag, form_for, field_set_tag, text_field.
+Text Helpers:: Useful formatting like: time_ago_in_words, js_escape_html, sanitize_html.
+Mailer:: Fast and simple delivery support for sending emails (akin to ActionMailer).
+Admin:: Builtin Admin interface (like Django)
+Logging:: Provide a unified logger that can interact with your ORM or any library.
+Reloading:: Automatically reloads server code during development.
+Localization:: Full support of I18n language localization and can auto-set user's locale.
+
+Keep in mind, the user will be able to pull in these components
+{seperately into existing Sinatra applications}[http://www.tennpipesrb.com/guides/standalone-usage-in-sinatra]
+or use them altogether for a comprehensive upgrade to Sinatra (a full-stack Tennpipes application).
+
+== Installation
+
+To install the tennpipes framework, simply grab the latest version from gemcutter:
+
+  $ sudo gem install tennpipes
+
+This will install the necessary tennpipes gems to get you started.
+Now you are ready to use this gem to enhance your sinatra projects or to create new Tennpipes applications.
+
+For a more detailed look at Tennpipes installation,
+check out the {Installation Guide}[http://www.tennpipesrb.com/guides/installation].
+
+== Usage
+
+Tennpipes is a framework which builds on the existing functionality and Sinatra and provides a variety of
+additional tools and helpers to build upon that foundation. This README and Tennpipes documentation in general will focus
+on the enhancements to the core Sinatra functionality. To use Tennpipes, one should be familiar with the basic
+usage of Sinatra itself.
+
+Please check out the
+{Understanding Sinatra}[http://www.tennpipesrb.com/guides/underlying-sinatra-overview] guide
+to learn more about these fundamentals.
+
+For information on how to use a specific gem in isolation within an existing Sinatra project, checkout the guide for
+{Using Tennpipes in Sinatra}[http://www.tennpipesrb.com/guides/standalone-usage-in-sinatra].
+
+== Getting Started
+
+Once a developer understands Sinatra, Tennpipes is quite easy to get comfortable with since Tennpipes is simply a superset
+of existing Sinatra Functionality! Best way to get started with building Tennpipes applications is to read following resources:
+
+* {Blog Tutorial}[http://www.tennpipesrb.com/guides/blog-tutorial] - Step-by-step guide to building a blog application with Tennpipes.
+* {Quick Overview}[http://www.tennpipesrb.com/guides/basic-projects] - Outlines basic generation commands.
+* {Tennpipes Examples}[http://www.tennpipesrb.com/guides/examples] - List of known Tennpipes applications which can serve as examples.
+
+== Enhanced Base Application (tennpipes-base)
+
+Sinatra has support for classes which can be extended to create an application: <tt>Sinatra::Base</tt> and <tt>Sinatra::Application</tt>
+These classes can be extended in order to create a Sinatra web application. These classes provide support for all the basic
+functionality afforded by Sinatra.
+
+Tennpipes has support for an enhanced base application class <tt>Tennpipes::Application</tt>. <tt>Tennpipes::Application</tt>
+expands the capabilities of Sinatra::Application and automatically provides the resulting application access to all of
+the tennpipes framework's functionalities.
+
+=== Simple Application Definition
+
+Let us first take a look at the simplest possible Tennpipes application:
+
+  # app.rb
+  TENNPIPES_ROOT = File.dirname(__FILE__) unless defined? TENNPIPES_ROOT
+  require 'tennpipes'
+  Tennpipes.load!
+
+  class SimpleApp < Tennpipes::Application
+    get '/' do
+      'Hello world'
+    end
+
+    # and for read better we can divide with controllers
+    controller '/admin' do
+      get '/foo' do
+        'Url is /admin/foo'
+      end
+    end
+  end
+
+=== Enhanced Route Definitions and Controllers
+
+For a complete overview of the Tennpipes routing and controller system,
+check out the {Routing and Controller guide}[http://www.tennpipesrb.com/guides/controllers].
+
+Suppose we wanted to add additional routes to our Tennpipes application, and we want to organize the routes
+within a more structured layout. Simply add a <tt>controllers</tt> or <tt>app/controllers</tt> folder and create a file as such:
+
+  # Simple Example
+  SimpleApp.controllers do
+    get "/test" do
+      "Text to return"
+    end
+  end
+
+You can also do more complex route alias definitions:
+
+  # app/controllers/example.rb
+  SimpleApp.controllers :posts do
+    get :index do
+      ...
+    end
+
+    get :show, :with => :id do
+      # url generated is '/posts/show/:id'
+      # access params[:id]
+    end
+  end
+
+as well as mapping the route aliases to an explicit url:
+
+  # app/controllers/example.rb
+  SimpleApp.controllers do
+    get :index, :map => '/index' do
+      ...
+    end
+
+    get :account, :map => '/the/accounts/:name/and/:id' do
+      # access params[:name] and params[:index]
+    end
+  end
+
+and even configure the +provides+ for each route:
+
+  # app/controllers/example.rb
+  SimpleApp.controllers :admin do
+    get :show, :with => :id, :provides => :js do
+      "Url is /admin/show/#{params[:id]}.#{params[:format]}"
+    end
+
+    get :other, :with => [:id, :name], :provides => [:html, :json] do
+      case content_type
+        when :js    then ... end
+        when :json  then ... end
+      end
+    end
+  end
+
+or auto lookup for current locale or content_type
+
+  # app/controllers/example.rb
+  SimpleApp.controllers :admin do
+    get :show, :with => :id, :provides => [:html, :js] do
+      render "admin/show"
+    end
+  end
+
+When you visit :+show+ and your I18n.locale == :ru Tennpipes try to look for "admin/show.ru.js.*" if nothing match that path
+they try "admin/show.ru.*" then "admin/show.js.*" if none match return "admin/show.erb" (or other engine i.e. haml)
+
+For a complete overview of the routing and controller system, check out the
+{Routing and Controller guide}[http://www.tennpipesrb.com/guides/controllers].
+
+=== Rendering
+
+Unlike Sinatra, Tennpipes supports automatic template lookups such as:
+
+  # searches for 'account/index.{erb,haml,...}
+  render 'account/index'
+
+This render does not require any template engine to be specified and will choose the first one that is discovered.
+The existing render function works as well if an engine type should be specified:
+
+# example.haml
+render :haml, 'account/index'
+
+For a complete overview of the Tennpipes rendering system, check out the
+{Routing and Controller guide}[http://www.tennpipesrb.com/guides/controllers].
+
+=== Layout
+
+With Tennpipes you can (like rails do) use for your custom layout, disable it
+
+  class SimpleApp < Tennpipes::Application
+
+    # Disable layouts
+    disable layout
+
+    # Use the layout located in views/layouts/custom.haml
+    layout :custom
+
+For a complete overview of the layout functionality,
+check out the {Routing and Controller guide}[http://www.tennpipesrb.com/guides/controllers].
+
+=== Mounting Applications
+
+Tennpipes applications are all automatically mountable into other Tennpipes projects. This means that a given Tennpipes
+project directory can easily mount multiple applications. This allows for better organization of complex applications,
+re-usable applications that can be applied (i.e admin, auth, blog) and even more flexibility.
+
+You can think of mountable applications as a 'full-featured' merb slice or rails engine. Instead of a separate construct,
+any application can simply be packaged and mounted into another project.
+
+Tennpipes stores application mounting information by default within <tt>config/apps.rb</tt>. This file is intended
+to keep all information regarding what applications are mounted to which uri's.
+
+For a complete look at mounting applications within a Tennpipes project,
+check out the guide on {Mounting Applications}[http://www.tennpipesrb.com/guides/mounting-applications].
+
+=== Auto Load Paths
+
+Tennpipes also intelligently supports requiring useful files within your application automatically and provides
+functionality for easily splitting up your application into separate files. Tennpipes automatically requires <tt>config/database.rb</tt>
+as a convention for establishing database connection. Also, any files within the <tt>lib</tt> folder will be required
+automatically by Tennpipes.
+
+For a complete overview of auto-loaded paths within Tennpipes,
+check out the {Tennpipes Development Guide}[http://www.tennpipesrb.com/guides/development-and-terminal-commands].
+
+=== Application Logging
+
+Tennpipes also supports robust logging capabilities. By default, logging information will
+go to the STDOUT in development (for use in a console) and in an environment-specific log file <tt>log/development.log</tt>
+in test and production environments.
+
+To use the logger within a Tennpipes application, simply refer to the <tt>logger</tt> method accessible
+within your app and any controller or views:
+
+  # controllers/example.rb
+  SimpleApp.controllers do
+    get("/test") { logger.info "This is a test" }
+  end
+
+For a complete overview of Tennpipes logger functionality, check out the
+{Tennpipes Development Guide}[http://www.tennpipesrb.com/guides/development-and-terminal-commands].
+
+=== Development Reloader
+
+Tennpipes applications also have the enabled ability to automatically reload all changing application files without
+the need to restart the server. Through the use of a customized Rack middleware, all files on the 'load path'
+are monitored and reloaded whenever changes are applied.
+
+This makes rapid development much easier and provides a better alternative to 'shotgun' or 'rerun'
+which requires the application server to be restarted which makes requests take much longer to complete.
+
+For a complete overview of code reloading in development,
+check out the {Tennpipes Development Guide}[http://www.tennpipesrb.com/guides/development-and-terminal-commands].
+
+=== Terminal Commands
+
+Tennpipes also comes equipped with multiple useful terminal commands which can be activated to perform
+common tasks such as starting / stopping the application, executing the unit tests or activating an irb session.
+
+The following commands are available:
+
+  # starts the app server (non-daemonized)
+  $ tennpipes start
+  # starts the app server (daemonized) with given port, environment and adapter
+  $ tennpipes start -d -p 3000 -e development -a thin
+
+  # Stops a daemonized app server
+  $ tennpipes stop
+
+  # Bootup the Tennpipes console (irb)
+  $ tennpipes console
+
+  # Run/List tasks
+  $ tennpipes rake
+
+You can also create custom rake tasks as well. Using these commands can simplify common tasks
+making development that much smoother.
+
+For a complete overview of Tennpipes terminal commands, check out the
+{Tennpipes Commands Guide}[http://www.tennpipesrb.com/guides/development-and-terminal-commands].
+
+== Copyright
+
+Copyright (c) 2011-2013 Tennpipes. See LICENSE for details.

data/Rakefile

@@ -0,0 +1 @@
+require File.expand_path(File.dirname(__FILE__) + '/../gem_rake_helper')

data/bin/tennpipes

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require 'bundler/setup' if %w(Gemfile .components).all? { |f| File.exist?(f) }
+
+tennpipes_core_path = File.expand_path('../../lib', __FILE__)
+$:.unshift(tennpipes_core_path) if File.directory?(tennpipes_core_path) && !$:.include?(tennpipes_core_path)
+
+require 'tennpipes-base/cli/base'
+Tennpipes::Cli::Base.start(ARGV)

data/lib/tennpipes-base.rb

@@ -0,0 +1,196 @@
+require 'sinatra/base'
+require 'tennpipes-base/version'
+require 'tennpipes-assist'
+require 'tennpipes-base/application'
+
+require 'tennpipes-base/caller'
+require 'tennpipes-base/command'
+require 'tennpipes-base/loader'
+require 'tennpipes-base/logger'
+require 'tennpipes-base/mounter'
+require 'tennpipes-base/reloader'
+require 'tennpipes-base/router'
+require 'tennpipes-base/server'
+require 'tennpipes-base/tasks'
+require 'tennpipes-base/module'
+
+if ENV["TENNPIPES_ENV"] || defined?(TENNPIPES_ENV)
+  warn 'Environment variable TENNPIPES_ENV is deprecated. Please, use RACK_ENV.'
+  ENV["RACK_ENV"] ||= ENV["TENNPIPES_ENV"] ||= TENNPIPES_ENV
+end
+RACK_ENV = ENV["RACK_ENV"] ||= "development"  unless defined?(RACK_ENV)
+TENNPIPES_ROOT = ENV["TENNPIPES_ROOT"] ||= File.dirname(Tennpipes.first_caller) unless defined?(TENNPIPES_ROOT)
+
+module Tennpipes
+  class ApplicationLoadError < RuntimeError # @private
+  end
+
+  extend Loader
+
+  class << self
+    ##
+    # Helper method for file references.
+    #
+    # @param [Array<String>] args
+    #   The directories to join to {TENNPIPES_ROOT}.
+    #
+    # @return [String]
+    #   The absolute path.
+    #
+    # @example
+    #   # Referencing a file in config called settings.yml
+    #   Tennpipes.root("config", "settings.yml")
+    #   # returns TENNPIPES_ROOT + "/config/setting.yml"
+    #
+    def root(*args)
+      File.expand_path(File.join(TENNPIPES_ROOT, *args))
+    end
+
+    ##
+    # Helper method that return {RACK_ENV}.
+    #
+    # @return [Symbol]
+    #   The Tennpipes Environment.
+    #
+    def env
+      @_env ||= RACK_ENV.to_s.downcase.to_sym
+    end
+
+    ##
+    # The resulting rack builder mapping each 'mounted' application.
+    #
+    # @return [Tennpipes::Router]
+    #   The router for the application.
+    #
+    # @raise [ApplicationLoadError]
+    #   No applications were mounted.
+    #
+    def application
+      warn 'WARNING! No apps are mounted. Please, mount apps in `config/apps.rb`' unless Tennpipes.mounted_apps.present?
+      router = Tennpipes::Router.new
+      Tennpipes.mounted_apps.each { |app| app.map_onto(router) }
+      middleware.present? ? add_middleware(router) : router
+    end
+
+    ##
+    # Configure Global Project Settings for mounted apps. These can be overloaded
+    # in each individual app's own personal configuration. This can be used like:
+    #
+    # @yield []
+    #   The given block will be called to configure each application.
+    #
+    # @example
+    #   Tennpipes.configure_apps do
+    #     enable  :sessions
+    #     disable :raise_errors
+    #   end
+    #
+    def configure_apps(&block)
+      return  unless block_given?
+      global_configurations << block
+    end
+
+    ##
+    # Stores global configuration blocks.
+    #
+    def global_configurations
+      @_global_configurations ||= []
+    end
+
+    ##
+    # Set +Encoding.default_internal+ and +Encoding.default_external+
+    # to +Encoding::UFT_8+.
+    #
+    # Please note that in +1.9.2+ with some template engines like +haml+
+    # you should turn off Encoding.default_internal to prevent problems.
+    #
+    # @see https://github.com/rtomayko/tilt/issues/75
+    #
+    # @return [NilClass]
+    #
+    def set_encoding
+      Encoding.default_external = Encoding::UTF_8
+      Encoding.default_internal = Encoding::UTF_8
+      nil
+    end
+
+    ##
+    # Creates Rack stack with the router added to the middleware chain.
+    #
+    def add_middleware(router)
+      builder = Rack::Builder.new
+      middleware.each{ |mw,args,block| builder.use(mw, *args, &block) }
+      builder.run(router)
+      builder.to_app
+    end
+
+    ##
+    # A Rack::Builder object that allows to add middlewares in front of all
+    # Tennpipes applications.
+    #
+    # @return [Array<Array<Class, Array, Proc>>]
+    #   The middleware classes.
+    #
+    def middleware
+      @middleware ||= []
+    end
+
+    ##
+    # Clears all previously configured middlewares.
+    #
+    # @return [Array]
+    #   An empty array
+    #
+    def clear_middleware!
+      @middleware = []
+    end
+
+    ##
+    # Convenience method for adding a Middleware to the whole tennpipes app.
+    #
+    # @param [Class] m
+    #   The middleware class.
+    #
+    # @param [Array] args
+    #   The arguments for the middleware.
+    #
+    # @yield []
+    #   The given block will be passed to the initialized middleware.
+    #
+    def use(mw, *args, &block)
+      middleware << [mw, args, block]
+    end
+
+    ##
+    # Registers a gem with tennpipes. This relieves the caller from setting up
+    # loadpaths by itself and enables Tennpipes to look up apps in gem folder.
+    #
+    # The name given has to be the proper gem name as given in the gemspec.
+    #
+    # @param [String] name
+    #   The name of the gem being registered.
+    #
+    # @param [Module] main_module
+    #   The main module of the gem.
+    #
+    # @returns The root path of the loaded gem
+    def gem(name, main_module)
+      _, spec = Gem.loaded_specs.find{|spec_pair| spec_pair[0] == name }
+      gems << spec
+      modules << main_module
+      spec.full_gem_path
+    end
+
+    ##
+    # @returns [Gem::Specification]
+    def gems
+      @gems ||= []
+    end
+
+    ##
+    # @returns [<Tennpipes::Module>]
+    def modules
+      @modules ||= []
+    end
+  end
+end