tennpipes-init 3.6.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c7ceae2eea5dffe4f6251675777b082af7ff26fd
+  data.tar.gz: 30e12698ffc27d64b3e719a0444be4c4e47597aa
+SHA512:
+  metadata.gz: 39f426e683fb4166564fb2297ddbf4a1a93d0fdd4917f1a53a10686fc3c1c89cfd22779aa5561c2a21a4935566761a0be4dc564b1e030f373db0bd091e1f47b5
+  data.tar.gz: 2b208aec0720a1ee5d24df9591261882cec35ddd8ae77f5cddc49f37a3ea3aff59e3bedf8227be1f5519307265605cb393d373f0c7ff5122d994436b56aaf281

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,163 @@
+= Agnostic Application Generators (tennpipes-init)
+
+=== Overview
+
+Tennpipes comes preloaded with flexible code generators powered in part by the excellent Thor gem
+(incidentally also used in the Rails 3 generators). These generators are intended to allow for easy code generation
+both in creating new applications and building on existing ones. The generators have been built to be as library agnostic
+as possible, supporting a myriad of test frameworks, js libraries, mocking libraries, etc.
+
+See the guide for {Tennpipes Generators}[http://www.tennpipesrb.com/guides/generators] for a
+more in-depth look at the system.
+
+=== Project Generator
+
+Tennpipes provides generator support for quickly creating new Tennpipes applications. This provides many benefits
+such as constructing the recommended Tennpipes application structure, auto-generating a Gemfile listing
+all starting dependencies and guidelines provided within the generated files to help orient a new user
+to using Tennpipes.
+
+One important feature of the generators is that they were built from the ground up to support a wide variety
+of tools, libraries and gems for use within your tennpipes application.
+
+The simplest possible command to generate a base application would be:
+
+  $ tennpipes-init project demo_project
+
+This would construct a Tennpipes application DemoApp (which extends from Tennpipes::Application)
+inside the folder 'demo_project' at our current path. Inside the application there would be configuration and
+setup performed for the default components.
+
+You can define specific components to be used:
+
+  $ tennpipes-init project demo_project -t rspec -r haml -m rr -s jquery -d datamapper
+
+You can also instruct the generator to skip a certain component to avoid using one at all (or to use your own):
+
+  $ tennpipes-init project demo_project --test none --renderer none
+
+The available components and their default options are listed below:
+
+test::       none  (default), bacon, shoulda, cucumber, riot, rspec, minitest, steak
+renderer::   slim  (default), erb, erubis, liquid, haml
+stylesheet:: none  (default), less, compass, sass, scss
+mock::       none  (default), mocha, rr
+script::     none  (default), jquery, prototype, mootools, rightjs, extcore, dojo
+orm::        none  (default), datamapper, mongomapper, mongoid, activerecord, minirecord, sequel, couchrest, ohm, mongomatic, ripple, dynamoid
+
+In addition, you can generate projects based on existing templates:
+
+  $ tennpipes-init project demo_project --template sampleblog
+
+To learn more about the project generator, check out the guide to
+{Tennpipes Generators}[http://www.tennpipesrb.com/guides/generators].
+
+=== Plugin System
+
+Tennpipes provides support for plugins to be executed within your application. For example:
+
+  $ tennpipes-init plugin hoptoad
+
+would install the hoptoad middleware into your application automatically.
+
+To learn more about the plugin system, check out the guide to
+{Tennpipes Generators}[http://www.tennpipesrb.com/guides/generators].
+
+=== Sub App Generator
+
+Unlike other ruby frameworks Tennpipes is principally designed for mounting multiple apps at the same time.
+
+First you need to create a project
+
+  $ tennpipes-init project demo_project
+  $ cd demo_project
+
+Now you are in demo_project and you can create your apps:
+
+  $ tennpipes-init app one
+  $ tennpipes-init app two
+
+By default these apps are mounted under:
+
+  * /one
+  * /two
+
+but you can edit config/apps.rb and change it.
+
+To learn more about the subapp generator, check out the guide to
+{Tennpipes Generators}[http://www.tennpipesrb.com/guides/generators].
+
+=== Model Generator
+
+Tennpipes provides generator support for quickly creating new models within your Tennpipes application. Note that
+the models (and migrations) generated are specifically tailored towards the ORM component and testing framework
+chosen during application generation.
+
+Very important to note that model generators are intended primarily to work within applications
+created through the Tennpipes application generator and that follow Tennpipes conventions. Using model generators
+within an existing application not generated by Tennpipes will likely not work as expected.
+
+Using the model generator is as simple as:
+
+  $ tennpipes-init model User
+
+You can also specify desired fields to be contained within your User model:
+
+  $ tennpipes-init model User name:string age:integer email:string
+
+To learn more about the model generator, check out the guide to
+{Tennpipes Generators}[http://www.tennpipesrb.com/guides/generators].
+
+=== Migration Generator
+
+Tennpipes provides generator for quickly generating new migrations to change or manipulate the database schema.
+These migrations generated will be tailored towards the ORM chosen when generating the application.
+
+Very important to note that migration generators are intended primarily to work within applications
+created through the Tennpipes application generator and that follow Tennpipes conventions. Using migration generators
+within an existing application not generated by Tennpipes will likely not work as expected.
+
+Using the migration generator is as simple as:
+
+  $ tennpipes-init migration AddFieldsToUsers
+  $ tennpipes-init migration RemoveFieldsFromUsers
+
+To learn more about the migration generator, check out the guide to
+{Tennpipes Generators}[http://www.tennpipesrb.com/guides/generators].
+
+=== Controller Generator
+
+Tennpipes provides generator support for quickly creating new controllers within your Tennpipes application. Note that
+the controller tests are generated specifically tailored towards the testing framework chosen
+during application generation.
+
+Very important to note that controller generators are intended primarily to work within applications
+created through the Tennpipes application generator and that follow Tennpipes conventions.
+
+Using the controller generator is as simple as:
+
+  $ tennpipes-init controller Admin
+
+You can also specify desired actions to be added to your controller:
+
+  $ tennpipes-init controller Admin get:index get:new post:create
+
+To learn more about the controller generator, check out the guide to
+{Tennpipes Generators}[http://www.tennpipesrb.com/guides/generators].
+
+=== Mailer Generator
+
+Tennpipes provides generator support for quickly creating new mailers within your Tennpipes application.
+Very important to note that mailer generators are intended primarily to work within applications
+created through the Tennpipes application generator and that follow Tennpipes conventions.
+
+Using the mailer generator is as simple as:
+
+  $ tennpipes-init mailer UserNotifier
+
+To learn more about the mailer generator, check out the guide to
+{Tennpipes Generators}[http://www.tennpipesrb.com/guides/generators].
+
+== 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-init

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require 'rubygems' unless defined?(Gem) # Useful only on --dev mode
+require 'bundler/setup' if %w(Gemfile .components).all? { |f| File.exist?(f) }
+
+tennpipes_gen_path = File.expand_path('../../lib', __FILE__)
+$:.unshift(tennpipes_gen_path) if File.directory?(tennpipes_gen_path) && !$:.include?(tennpipes_gen_path)
+
+# We try to load the vendored tennpipes-base if exist (useful also for --dev mode)
+tennpipes_core_path = File.expand_path('../../../tennpipes-base/lib', __FILE__)
+$:.unshift(tennpipes_core_path) if File.directory?(tennpipes_core_path) && !$:.include?(tennpipes_core_path)
+
+require 'tennpipes-init'
+require 'tennpipes-init/generators/cli'
+
+# We need our config boot because we need to load registered generators so:
+Tennpipes::Generators::Cli.start(ARGV)

data/lib/tennpipes-init.rb

@@ -0,0 +1,73 @@
+require 'tennpipes-base/tasks'
+require 'tennpipes-init/command'
+require 'active_support/ordered_hash'
+
+module Tennpipes
+  ##
+  # This module it's used for register generators.
+  #
+  # Can be useful for 3rd party generators:
+  #
+  #   # custom_generator.rb
+  #   class CustomGenerator < Thor::Group
+  #     Tennpipes::Generators.add_generator(:custom_generator, self)
+  #   end
+  #
+  # Now for handle generators in tennpipes you need to add it to into +load_paths+.
+  #
+  # Tennpipes::Generators.load_paths << "custom_generator.rb"
+  #
+  module Generators
+    # Defines the absolute path to the tennpipes source folder.
+    DEV_PATH = File.expand_path("../../", File.dirname(__FILE__))
+
+    class << self
+      ##
+      # Store our generators paths.
+      #
+      def load_paths
+        @_files ||= []
+      end
+
+      ##
+      # Return an ordered list of task with their class.
+      #
+      def mappings
+        @_mappings ||= ActiveSupport::OrderedHash.new
+      end
+
+      ##
+      # Global add a new generator class to +tennpipes-init+.
+      #
+      # @param [Symbol] name
+      #   Key name for generator mapping.
+      # @param [Class] klass
+      #   Class of generator.
+      #
+      # @return [Hash] generator mappings
+      #
+      # @example
+      #   Tennpipes::Generators.add_generator(:controller, Controller)
+      #
+      def add_generator(name, klass)
+        mappings[name] = klass
+      end
+
+      ##
+      # Load Global Actions and Component Actions then all files in +load_path+.
+      #
+      def load_components!
+        require 'tennpipes-init/generators/actions'
+        require 'tennpipes-init/generators/components/actions'
+        require 'tennpipes-init/generators/runner'
+        load_paths.flatten.each { |file| require file  }
+      end
+    end
+  end
+end
+
+# Add our generators to Tennpipes::Generators.
+Tennpipes::Generators.load_paths << Dir[File.dirname(__FILE__) + '/tennpipes-init/generators/{project,app,mailer,controller,helper,model,migration,plugin,component,task}.rb']
+
+# Add our tasks to tennpipes-base.
+Tennpipes::Tasks.files << Dir[File.dirname(__FILE__) + "/tennpipes-init/tennpipes-tasks/**/*.rb"]

data/lib/tennpipes-init/command.rb

@@ -0,0 +1,18 @@
+require 'tennpipes-base/command'
+
+module Tennpipes
+  ##
+  # This method return the correct location of tennpipes-init bin or
+  # exec it using Kernel#system with the given args.
+  #
+  # @param [Array<String>] args.
+  #   Splat of arguments to pass to tennpipes-init.
+  #
+  # @example
+  #   Tennpipes.bin_gen(:app, name.to_s, "-r=#{destination_root}")
+  #
+  def self.bin_gen(*args)
+    @_tennpipes_gen_bin ||= [Tennpipes.ruby_command, File.expand_path("../../../bin/tennpipes-init", __FILE__)]
+    system args.unshift(@_tennpipes_gen_bin).join(" ")
+  end
+end

data/lib/tennpipes-init/generators/actions.rb

@@ -0,0 +1,630 @@
+require 'pathname'
+
+module Tennpipes
+  module Generators
+    # Raised when an application does not have a resolved root path.
+    class  AppRootNotFound < RuntimeError; end
+    ##
+    # Default helper name for use in tiny app skeleton generator.
+    #
+    DEFAULT_HELPER_NAME = "Helper".freeze
+    ##
+    # Common actions needed to support project and component generation.
+    #
+    module Actions
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+      ##
+      # Avoids editing destination file if it does not exist.
+      #
+      def inject_into_file(destination, *args, &block)
+        destination_path = Pathname.new(destination).absolute? ? destination : destination_root(destination)
+        return unless File.exist?(destination_path)
+        super
+      end
+
+      ##
+      # Performs the necessary generator for a given component choice.
+      #
+      # @param [Symbol] component
+      #   The type of component module.
+      # @param [String] choice
+      #   The name of the component module choice.
+      #
+      # @example
+      #   execute_component_setup(:mock, 'rr')
+      #
+      def execute_component_setup(component, choice)
+        return true && say_status(:skipping, "#{component} component...") if choice.to_s == 'none'
+        say_status(:applying, "#{choice} (#{component})...")
+        apply_component_for(choice, component)
+        send("setup_#{component}") if respond_to?("setup_#{component}")
+      end
+
+      ##
+      # Returns the related module for a given component and option.
+      #
+      # @param [String] choice
+      #   The name of the component module.
+      # @param [Symbol] component
+      #   The type of the component module.
+      #
+      # @example
+      #   apply_component_for('rr', :mock)
+      #
+      def apply_component_for(choice, component)
+        # I need to override Thor#apply because for unknow reason :verbose => false break tasks.
+        path = File.expand_path(File.dirname(__FILE__) + "/components/#{component.to_s.pluralize}/#{choice}.rb")
+        say_status :apply, "#{component.to_s.pluralize}/#{choice}"
+        shell.padding += 1
+        instance_eval(File.read(path))
+        shell.padding -= 1
+      end
+
+      ##
+      # Includes the component module for the given component and choice.
+      # It determines the choice using .components file.
+      #
+      # @param [Symbol] component
+      #   The type of component module.
+      # @param [String] choice
+      #   The name of the component module.
+      #
+      # @example
+      #   include_component_module_for(:mock)
+      #   include_component_module_for(:mock, 'rr')
+      #
+      def include_component_module_for(component, choice=nil)
+        choice = fetch_component_choice(component) unless choice
+        return false if choice.to_s == 'none'
+        apply_component_for(choice, component)
+      end
+
+      ##
+      # Returns the component choice stored within the .component file of an application.
+      #
+      # @param [Symbol] component
+      #   The type of component module.
+      #
+      # @return [String] Name of the component module.
+      #
+      # @example
+      #   fetch_component_choice(:mock)
+      #
+      def fetch_component_choice(component)
+        retrieve_component_config(destination_root('.components'))[component]
+      end
+
+      ##
+      # Set the component choice in the .component file of the application.
+      #
+      # @param [Symbol] key
+      #   The type of component module.
+      # @param [Symbol] value
+      #   The name of the component module.
+      #
+      # @return [Symbol] The name of the component module.
+      #
+      # @example
+      #   store_component_choice(:renderer, :haml)
+      #
+      def store_component_choice(key, value)
+        path        = destination_root('.components')
+        config      = retrieve_component_config(path)
+        config[key] = value
+        create_file(path, :force => true) { config.to_yaml }
+        value
+      end
+
+      ##
+      # Loads the component config back into a hash.
+      #
+      # @param [String] target
+      #   Path to component config file.
+      #
+      # @return [Hash] Loaded YAML file.
+      #
+      # @example
+      #   retrieve_component_config(...)
+      #   # => { :mock => 'rr', :test => 'riot', ... }
+      #
+      def retrieve_component_config(target)
+        YAML.load_file(target)
+      end
+
+      ##
+      # Prompts the user if necessary until a valid choice is returned for the component.
+      #
+      # @param [Symbol] component
+      #   The type of component module.
+      #
+      # @return [String] Name of component if valid, otherwise ask for valid choice.
+      #
+      # @example
+      #   resolve_valid_choice(:mock)
+      #
+      def resolve_valid_choice(component)
+        available_string = self.class.available_choices_for(component).join(", ")
+        choice = options[component]
+        until valid_choice?(component, choice)
+          say("Option for --#{component} '#{choice}' is not available.", :red)
+          choice = ask("Please enter a valid option for #{component} (#{available_string}):")
+        end
+        choice
+      end
+
+      ##
+      # Returns true if the option passed is a valid choice for component.
+      #
+      # @param [Symbol] component
+      #   The type of component module.
+      # @param [String] choice
+      #   The name of the component module.
+      #
+      # @return [Boolean] Boolean of whether the choice is valid.
+      #
+      # @example
+      #   valid_choice?(:mock, 'rr')
+      #
+      def valid_choice?(component, choice)
+        choice.present? && self.class.available_choices_for(component).include?(choice.to_sym)
+      end
+
+      ##
+      # Creates a component_config file at the destination containing all component options.
+      # Content is a YAMLized version of a hash containing component name mapping to chosen value.
+      #
+      # @param [String] destination
+      #   The file path to store the component config.
+      #
+      # @example
+      #   store_component_config('/foo/bar')
+      #
+      def store_component_config(destination)
+        components = @_components || options
+        create_file(destination) do
+          self.class.component_types.inject({}) { |result, comp|
+            result[comp] = components[comp].to_s; result
+          }.to_yaml
+        end
+      end
+
+      ##
+      # Returns the root for this Thor class (also aliased as destination root).
+      #
+      # @param [Array<String>] paths
+      #   The relative path from destination root.
+      #
+      # @return [String] The full path
+      #
+      # @example
+      #   destination_root('config/boot.rb')
+      #
+      def destination_root(*paths)
+        File.expand_path(File.join(@destination_stack.last, paths))
+      end
+
+      ##
+      # Returns true if inside a Tennpipes application.
+      #
+      def in_app_root?
+        File.exist?(destination_root('config/boot.rb'))
+      end
+
+      ##
+      # Returns true if constant name already exists.
+      #
+      def already_exists?(name, project_name = nil)
+        project_name = project_name ? (Object.const_get(project_name) rescue nil) : nil
+        Object.const_defined?(name) || (project_name && project_name.const_defined?(name))
+      end
+
+      ##
+      # Returns the field with an unacceptable name(for symbol) else returns nil.
+      #
+      # @param [Array<String>] fields
+      #   Field names for generators.
+      #
+      # @return [Array<String>] array of invalid fields
+      #
+      # @example
+      #   invalid_fields ['foo:bar', 'hello:world']
+      #
+      def invalid_fields(fields)
+        results = fields.select { |field| field.split(":").first =~ /\W/ }
+        results.empty? ? nil : results
+      end
+
+      ##
+      # Apply default field types.
+      #
+      # @param [Array<String>] fields
+      #   Field names for generators.
+      #
+      # @return [Array<String>] fields with default types
+      #
+      def apply_default_fields(fields)
+        fields.map! { |field| field =~ /:/ ? field : "#{field}:string" }
+      end
+
+      # Returns the namespace for the project.
+      #
+      # @param [String] app
+      #   folder name of application.
+      #
+      # @return [String] namespace for application.
+      #
+      # @example
+      #   fetch_project_name
+      #
+      def fetch_project_name(app='app')
+        app_path = destination_root(app, 'app.rb')
+        @project_name = fetch_component_choice(:namespace) if @project_name.empty?
+        @project_name ||= begin
+          say "Autodetecting project namespace using folder name.", :red
+          say ""
+          detected_namespace = File.basename(destination_root('.')).gsub(/\W/, '_').camelize
+          say(<<-WARNING, :red)
+From v0.11.0 on, applications should have a `namespace` setting
+in their .components file. Please include a line like the following
+in your .components file:
+WARNING
+          say "\t:namespace: #{detected_namespace}", :yellow
+          say ""
+
+          detected_namespace
+        end
+      end
+
+      ##
+      # Returns the app_name for the application at root.
+      #
+      # @param [String] app
+      #   folder name of application.
+      #
+      # @return [String] class name for application.
+      #
+      # @example
+      #   fetch_app_name('subapp')
+      #
+      def fetch_app_name(app='app')
+        app_path = destination_root(app, 'app.rb')
+        @app_name ||= File.read(app_path).scan(/class\s(.*?)\s</).flatten[0]
+      end
+
+      ##
+      # Adds all the specified gems into the Gemfile for bundler.
+      #
+      # @param [Array<String>] gem_names
+      #   Splat of gems to require in Gemfile.
+      # @param [Hash] options
+      #   The options to pass to gem in Gemfile.
+      #
+      # @example
+      #   require_dependencies('active_record')
+      #   require_dependencies('mocha', 'bacon', :group => 'test')
+      #   require_dependencies('json', :version => ">=1.2.3")
+      #
+      def require_dependencies(*gem_names)
+        options = gem_names.extract_options!
+        gem_names.reverse_each { |lib| insert_into_gemfile(lib, options) }
+      end
+
+      ##
+      # Inserts a required gem into the Gemfile to add the bundler dependency.
+      #
+      # @param [String] name
+      #   Name of gem to insert into Gemfile.
+      # @param [Hash] options
+      #   Options to generate into Gemfile for gem.
+      #
+      # @example
+      #   insert_into_gemfile(name)
+      #   insert_into_gemfile(name, :group => 'test', :require => 'foo')
+      #   insert_into_gemfile(name, :group => 'test', :version => ">1.2.3")
+      #
+      def insert_into_gemfile(name, options={})
+        after_pattern = options[:group] ? "#{options[:group].to_s.capitalize} requirements\n" : "Component requirements\n"
+        version       = options.delete(:version)
+        gem_options   = options.map { |k, v| k.to_s == 'require' && [true,false].include?(v) ? ":#{k} => #{v}" : ":#{k} => '#{v}'" }.join(", ")
+        write_option  = gem_options.present? ? ", #{gem_options}" : ''
+        write_version = version.present? ? ", '#{version}'" : ''
+        include_text  = "gem '#{name}'" << write_version << write_option << "\n"
+        inject_into_file('Gemfile', include_text, :after => after_pattern)
+      end
+
+      ##
+      # Inserts an hook before or after load in our boot.rb.
+      #
+      # @param [String] include_text
+      #   Text to include into hooks in boot.rb.
+      # @param [Symbol] where
+      #   method hook to call from Tennpipes, i.e :after_load, :before_load.
+      #
+      # @example
+      #   insert_hook("DataMapper.finalize", :after_load)
+      #
+      def insert_hook(include_text, where)
+        inject_into_file('config/boot.rb', "  #{include_text}\n", :after => "Tennpipes.#{where} do\n")
+      end
+
+      ##
+      # Inserts a middleware inside app.rb.
+      #
+      # @param [String] include_text
+      #   Text to include into hooks in boot.rb.
+      #
+      # @example
+      #   insert_middleware(ActiveRecord::ConnectionAdapters::ConnectionManagement)
+      #
+      def insert_middleware(include_text, app=nil)
+        name = app || (options[:name].present? ? @app_name.downcase : 'app')
+        inject_into_file("#{name}/app.rb", "    use #{include_text}\n", :after => "Tennpipes::Application\n")
+      end
+
+      ##
+      # Registers and creates initializer.
+      #
+      # @param [Symbol] name
+      #   Name of the initializer.
+      # @param [String] data
+      #   Text to generate into the initializer file.
+      #
+      # @example
+      #   initializer(:test, "some stuff here")
+      #   #=> generates 'lib/test_init.rb'
+      #
+      def initializer(name, data=nil)
+        @_init_name, @_init_data = name, data
+        register = data.present? ? "    register #{name.to_s.underscore.camelize}Initializer\n" : "    register #{name}\n"
+        inject_into_file destination_root("/app/app.rb"), register, :after => "Tennpipes::Application\n"
+        template "templates/initializer.rb.tt", destination_root("/lib/#{name}_initializer.rb") if data.present?
+      end
+
+      ##
+      # Creates and inserts middleware.
+      # @param [Symbol, String] name
+      #   Name of the middleware.
+      # @param [String] source
+      #   Text to generate into the middleware file.
+      #
+      # @example
+      #   middleware(:hello, "class Hello\nend")
+      #   #=> generates 'lib/hello_middleware.rb'
+      #
+      def middleware(name, source)
+        create_file destination_root("lib/#{name}_middleware.rb"), source
+        insert_middleware name.to_s.underscore.camelize
+      end
+
+      ##
+      # Insert the regired gem and add in boot.rb custom contribs.
+      #
+      # @param [String] contrib
+      #   name of library from tennpipes-contrib
+      #
+      # @example
+      #   require_contrib('auto_locale')
+      #
+      def require_contrib(contrib)
+        insert_into_gemfile 'tennpipes-contrib'
+        contrib = "require '" + File.join("tennpipes-contrib", contrib) + "'\n"
+        inject_into_file destination_root("/config/boot.rb"), contrib, :before => "\nTennpipes.load!"
+      end
+
+      ##
+      # Return true if our project has test component.
+      #
+      def test?
+        fetch_component_choice(:test).to_s != 'none'
+      end
+
+      ##
+      # Return true if we have a tiny skeleton.
+      #
+      def tiny?
+        File.exist?(destination_root('app/controllers.rb'))
+      end
+
+      ##
+      # Run the bundler.
+      #
+      def run_bundler
+        say 'Bundling application dependencies using bundler...', :yellow
+        in_root { run 'bundle install' }
+      end
+
+      ##
+      # Ask something to the user and receives a response.
+      #
+      # @param [String] statement
+      #   String of statement to display for input.
+      # @param [String] default
+      #   Default value for input.
+      # @param [String] color
+      #   Name of color to display input.
+      #auto_locale
+      # @return [String] Input value
+      #
+      # @example
+      #   ask("What is your name?")
+      #   ask("Path for ruby", "/usr/local/bin/ruby") => "Path for ruby (leave blank for /usr/local/bin/ruby):"
+      #
+      def ask(statement, default=nil, color=nil)
+        default_text = default ? " (leave blank for #{default}):" : nil
+        say("#{statement}#{default_text} ", color)
+        result = $stdin.gets.strip
+        result.blank? ? default : result
+      end
+
+      ##
+      # Raise SystemExit if the app does not exist.
+      #
+      # @param [String] app
+      #   Directory name of application.
+      #
+      # @example
+      #   check_app_existence 'app'
+      #
+      def check_app_existence(app)
+        unless File.exist?(destination_root(app))
+          say
+          say "================================================================="
+          say "Unable to locate '#{app.underscore.camelize}' application        "
+          say "================================================================="
+          say
+          raise SystemExit
+        end
+      end
+
+      ##
+      # Generates standard and tiny applications within a project.
+      #
+      # @param [String] app
+      #   Name of application.
+      # @param [Boolean] tiny
+      #   Boolean to generate a tiny structure.
+      #
+      # @example
+      #   app_skeleton 'some_app'
+      #   app_skeleton 'sub_app', true
+      #
+      def app_skeleton(app, tiny=false)
+        directory('app/', destination_root(app))
+        if tiny
+          template 'templates/controller.rb.tt', destination_root(app, 'controllers.rb')
+          @helper_name = DEFAULT_HELPER_NAME
+          template 'templates/helper.rb.tt', destination_root(app, 'helpers.rb')
+          @short_name = 'notifier'
+          template 'templates/mailer.rb.tt', destination_root(app, 'mailers.rb')
+        else
+          empty_directory destination_root(app, 'controllers')
+          empty_directory destination_root(app, 'helpers')
+          empty_directory destination_root(app, 'views')
+          empty_directory destination_root(app, 'views', 'layouts')
+        end
+      end
+
+      ##
+      # Ensure that project name is valid, else raise an NameError.
+      #
+      # @param [String] name
+      #   Name of project.
+      #
+      # @return [Exception] Exception with error message if not valid.
+      #
+      # @example
+      #   valid_constant '1235Stuff'
+      #   valid_constant '#Abc'
+      #
+      def valid_constant?(name)
+        if name =~ /^\d/
+          raise ::NameError, "Project name #{name} cannot start with numbers"
+        elsif name =~ /^\W/
+          raise ::NameError, "Project name #{name} cannot start with non-word character"
+        end
+      end
+
+      ##
+      # Recognizes the path of application.
+      #
+      def recognize_path
+        options[:app] == '.' ? '/..' : '/../..'
+      end
+
+      ##
+      # Creates an empty directory with .keep file
+      #
+      def empty_directory_with_keep_file(destination, config = {})
+        empty_directory(destination, config)
+        keep_file(destination)
+      end
+
+      ##
+      # Creates an empty .keep file
+      #
+      def keep_file(destination)
+        create_file("#{destination}/.keep")
+      end
+
+      # Class methods for Thor generators to support the generators and component choices.
+      module ClassMethods
+        ##
+        # Defines a class option to allow a component to be chosen and add to component type list.
+        # Also builds the available_choices hash of which component choices are supported.
+        #
+        # @param [Symbol] name
+        #   Name of component.
+        # @param [String] caption
+        #   Description of the component.
+        # @param [Hash] options
+        #   Additional parameters for component choice.
+        #
+        # @example
+        #   component_option :test, "Testing framework", :aliases => '-t', :choices => [:bacon, :shoulda]
+        #
+        def component_option(name, caption, options = {})
+          (@component_types   ||= []) << name # TODO use ordered hash and combine with choices below
+          (@available_choices ||= Hash.new)[name] = options[:choices]
+          description = "The #{caption} component (#{options[:choices].join(', ')}, none)"
+          class_option name, :default => options[:default] || options[:choices].first, :aliases => options[:aliases], :desc => description
+        end
+
+        ##
+        # Definitions for the available customizable components.
+        #
+        def defines_component_options(options = {})
+          [
+            [ :orm,        'database engine',    { :aliases => '-d', :default => :none }],
+            [ :test,       'testing framework',  { :aliases => '-t', :default => :none }],
+            [ :mock,       'mocking library',    { :aliases => '-m', :default => :none }],
+            [ :script,     'javascript library', { :aliases => '-s', :default => :none }],
+            [ :renderer,   'template engine',    { :aliases => '-e', :default => :none }],
+            [ :stylesheet, 'stylesheet engine',  { :aliases => '-c', :default => :none }]
+          ].each do |name, caption, opts|
+            opts[:default] = '' if options[:default] == false
+            component_option name, caption, opts.merge(:choices => Dir["#{File.dirname(__FILE__)}/components/#{name.to_s.pluralize}/*.rb"].map{|lib| File.basename(lib, '.rb').to_sym})
+          end
+        end
+
+        ##
+        # Tell Tennpipes that for this Thor::Group it is a necessary task to run.
+        #
+        def require_arguments!
+          @require_arguments = true
+        end
+
+        ##
+        # Return true if we need an arguments for our Thor::Group.
+        #
+        def require_arguments?
+          @require_arguments
+        end
+
+        ##
+        # Returns the compiled list of component types which can be specified.
+        #
+        def component_types
+          @component_types
+        end
+
+        ##
+        # Returns the list of available choices for the given component (including none).
+        #
+        # @param [Symbol] component
+        #   The type of the component module.
+        #
+        # @return [Array<Symbol>] Array of component choices.
+        #
+        # @example
+        #   available_choices_for :test
+        #   => [:shoulda, :bacon, :riot, :minitest]
+        #
+        def available_choices_for(component)
+          @available_choices[component] + [:none]
+        end
+      end
+    end
+  end
+end