Module: Innate::HelpersHelper

### Home Classes Methods

### In Files

- lib/innate/helper.rb

### Methods

- #each
- #each_extend
- #each_include
- #find_helper
- #get
- #try_require

### Included Modules

- Innate::Optioned

### Class/Module Index

Quicksearch

- Innate
- Innate::Action
- Innate::Adapter
- Innate::Cache
- Innate::Cache::API
- Innate::Cache::DRb
- Innate::Cache::FileBased
- Innate::Cache::Marshal
- Innate::Cache::Memory
- Innate::Cache::YAML
- Innate::Current
- Innate::Etanni
- Innate::Helper
- Innate::Helper::Aspect
- Innate::Helper::Aspect::SingletonMethods
- Innate::Helper::CGI
- Innate::Helper::Flash
- Innate::Helper::Link
- Innate::Helper::Redirect
- Innate::Helper::Render
- Innate::HelperAccess
- Innate::HelpersHelper
- Innate::LRUHash
- Innate::LogHub
- Innate::Mock
- Innate::Mock::Session
- Innate::Node
- Innate::Optioned
- Innate::Optioned::SingletonMethods
- Innate::Options
- Innate::Request
- Innate::Response
- Innate::Rewrite
- Innate::Route
- Innate::Session
- Innate::Session::Flash
- Innate::SingletonMethods
- Innate::StateAccessor
- Innate::Traited
- Innate::Trinity
- Innate::URLMap
- Innate::View
- Innate::View::ERB
- Innate::View::Etanni
- Innate::View::None
- Logger
- Logger::ColorFormatter
- Object

No matching classes.

# Innate::HelpersHelper

Here come the utility methods used from the HelperAccess#helper method, we do this to keep method count at a minimum and because HelpersHelper is such an awesome name that just can't be wasted.

Usage if you want to only extend with helpers:

    class Hi
      Innate::HelpersHelper.each_extend(self, :cgi, :link, :aspect)
    end

Usage if you only want to include helpers:

    class Hi
      Innate::HelpersHelper.each_include(self, :cgi, :link, :aspect)
    end

Usage for iteration:

    Innate::HelpersHelper.each(:cgi, :link, :aspect) do |mod|
      p mod
    end

Usage for translating helpers to modules:

    p Innate::HelpersHelper.each(:cgi, :link, :aspect)

### Constants

EXTS

### Public Instance Methods

each(*names) click to toggle source

Yield all the modules we can find for the given names of helpers, try to require them if not available.

NOTE: Unlike usual each, this will actually return an Array of the found

    modules instead of the given +*names+

Usage:

    Innate::HelpersHelper.each(:cgi, :link, :aspect) do |mod|
      p mod
    end

    # File lib/innate/helper.rb, line 102
    def each(*names)
      names.map do |name|
        if name.class == Module
          yield(name) if block_given?
          name
        elsif mod = get(name)
          yield(mod) if block_given?
          mod
        elsif try_require(name)
          redo
        else
          raise LoadError, "Helper #{name} not found"
        end
      end
    end

each_extend(into, *names, &block) click to toggle source

Shortcut to extend `into` with Helper modules corresponding to +*names+. `into` has to respond to extend.

Usage:

    class Hi
      Innate::HelpersHelper.each_extend(self, :cgi, :link, :aspect)
    end

    # File lib/innate/helper.rb, line 126
    def each_extend(into, *names, &block)
      return if names.empty?
      into.extend(*each(*names, &block))
    end

each_include(into, *names, &block) click to toggle source

Shortcut to include Helper modules corresponding to +*names+ on `into`. `into` has to respond to include. #__send__(:include) is used in case include raises due to being private/protected

in case include is a private/protected method.

Usage:

    class Hi
      Innate::HelpersHelper.each_include(self, :cgi, :link, :aspect)
    end

    # File lib/innate/helper.rb, line 143
    def each_include(into, *names, &block)
      return if names.compact.empty?
      into.__send__(:include, *each(*names, &block))
    end

find_helper(name) click to toggle source

    # File lib/innate/helper.rb, line 175
    def find_helper(name)
      options.paths.uniq.find do |path|
        base = ::File.join(path, 'helper', name)
        options.exts.find do |ext|
          full = "#{base}.#{ext}"
          return full if ::File.file?(full)
        end
      end
    end

get(name) click to toggle source

Based on a simple set of rules we will first construct the most likely name for the helper and then grep the constants in the Innate::Helper module for any matches.

helper :foo_bar # => FooBar helper :foo # => Foo

    # File lib/innate/helper.rb, line 154
    def get(name)
      module_name = /^#{name.to_s.dup.delete('_')}(?:helper)?$/

      options.namespaces.each do |namespace|
        found = namespace.constants.grep(module_name).first
        return namespace.const_get(found) if found
      end

      nil
    end

try_require(name) click to toggle source

Figure out files that might have the helper we ask for and then require the first we find, if any.

    # File lib/innate/helper.rb, line 167
    def try_require(name)
      if found = find_helper(name.to_s)
        require(found) || true
      else
        raise(LoadError, "Helper #{name} not found")
      end
    end

[Validate]

Generated with the Darkfish Rdoc Generator 2.