manveru-innate 2009.04.01 → 2009.04.08

data/lib/innate/helper/cgi.rb

@@ -6,36 +6,46 @@ module Innate
 
   module Helper
     module CGI
-      # shortcut for Rack::Utils.escape
-      def url_encode(*args)
-        Rack::Utils.escape(*args.map{|a| a.to_s })
+      module_function
+
+      # Shortcut for Rack::Utils.escape
+      #
+      # @param [#to_s] input
+      # @return [String] URI-encoded representation of +input+
+      def url_encode(input)
+        Rack::Utils.escape(input.to_s)
       end
+      alias u url_encode
 
-      # shortcut for Rack::Utils.unescape
-      def url_decode(*args)
-        Rack::Utils.unescape(*args.map{|a| a.to_s })
+      # Shortcut for Rack::Utils.unescape
+      #
+      # @param [#to_s] input
+      # @return [String] URI-decoded representation of +input+
+      def url_decode(input)
+        Rack::Utils.unescape(input.to_s)
       end
 
-      # shortcut for Rack::Utils.escape_html
-      def html_escape(string)
-        Rack::Utils.escape_html(string)
+      # Shortcut for Rack::Utils.escape_html
+      #
+      # @param [#to_s] input
+      # @return [String]
+      def html_escape(input)
+        Rack::Utils.escape_html(input.to_s)
       end
 
-      # shortcut for CGI.unescapeHTML
-      def html_unescape(string)
-        ::CGI.unescapeHTML(string.to_s)
+      # Shortcut for CGI.unescapeHTML
+      #
+      # @param [#to_s] input
+      # @return [String]
+      def html_unescape(input)
+        ::CGI.unescapeHTML(input.to_s)
       end
 
       # safely escape all HTML and code
-      def h(string)
-        Rack::Utils.escape_html(string).gsub(/#([{@$]@?)/, '#\1')
+      def html_and_code_escape(input)
+        Rack::Utils.escape_html(input.to_s).gsub(/#([{@$]@?)/, '#\1')
       end
-
-      # one-letter versions help in case like #{h foo.inspect}
-      # ERb/ERuby/Rails compatible
-      alias u url_encode
-
-      module_function(:url_encode, :url_decode, :html_escape, :html_unescape, :h, :u)
+      alias h html_and_code_escape
     end
   end
 end

data/lib/innate/helper/render.rb

@@ -0,0 +1,80 @@
+module Innate
+  module Helper
+    module Render
+      # Enables you to simply call:
+      #
+      # @example of added functionality
+      #   YourController.render_partial(:foo, :x => 42)
+      #
+      def self.included(into)
+        into.extend(self)
+      end
+
+      # Renders the full action in the way a real request would.
+      #
+      # Please be aware that, if this is the first request from a client, you
+      # will not have access to the session in the action being rendered, as no
+      # actual session has been put into place yet.
+      #
+      # It should work as expected on any subsequent requests.
+      #
+      # As usual, patches welcome.
+      #
+      # @api external
+      # @see Mock.session
+      # @author manveru
+      def render_full(path, query = {})
+        uri = URI(path.to_s)
+        uri.query = Rack::Utils.build_query(query)
+
+        if cookie = request.env['HTTP_COOKIE']
+          Mock.session do |mock|
+            mock.cookie = cookie
+            return mock.get(uri.to_s).body
+          end
+        else
+          Mock.get(uri.to_s).body
+        end
+      end
+
+      # Renders an action without any layout.
+      # @api external
+      # @see render_custom
+      # @author manveru
+      def render_partial(action_name, variables = {})
+        render_custom(action_name, variables) do |action|
+          action.layout = nil
+        end
+      end
+
+      # Renders an action view, doesn't execute any methods and won't wrap it
+      # into a layout.
+      #
+      # @api external
+      # @see render_custom
+      # @author manveru
+      def render_view(action_name, variables = {})
+        render_custom(action_name, variables) do |action|
+          action.layout = nil
+          action.method = nil
+        end
+      end
+
+      def render_custom(action_name, variables = {})
+        action = resolve(action_name.to_s)
+
+        action.sync_variables(self.action)
+        action.instance = action.node.new
+        action.variables = action.variables.merge(variables)
+
+        yield(action) if block_given?
+
+        if action.valid?
+          action.render
+        else
+          Log.warn("Invalid action: %p" % action)
+        end
+      end
+    end
+  end
+end

data/lib/innate/mock.rb

@@ -39,9 +39,8 @@ module Innate
         hash['HTTP_COOKIE'] ||= @cookie if @cookie
         response = Mock::mock(method, path, hash)
 
-        if cookie = response['Set-Cookie']
-          @cookie = cookie
-        end
+        cookie = response['Set-Cookie']
+        @cookie = cookie if cookie
 
         response
       end

data/lib/innate/node.rb

@@ -28,7 +28,8 @@ module Innate
   module Node
     include Traited
 
-    DEFAULT_HELPERS = %w[aspect cgi flash link partial redirect send_file]
+    attr_reader :method_arities, :layout_templates, :view_templates
+
     NODE_LIST = Set.new
 
     # These traits are inherited into ancestors, changing a trait in an
@@ -56,8 +57,6 @@ module Innate
     # Upon inclusion we make ourselves comfortable.
     def self.included(into)
       into.__send__(:include, Helper)
-      into.helper(*DEFAULT_HELPERS)
-
       into.extend(Trinity, self)
 
       NODE_LIST << into
@@ -372,6 +371,7 @@ module Innate
       end
 
       node.update_method_arities
+      node.update_template_mappings
       node.fill_action(action, name)
     end
 
@@ -537,12 +537,10 @@ module Innate
       @method_arities
     end
 
-    attr_reader :method_arities
-
     # Try to find the best template for the given basename and wish and respect
     # aliased views.
     #
-    # @param [#to_s] file
+    # @param [#to_s] action_name
     # @param [#to_s] wish
     #
     # @return [String, nil] depending whether a template could be found
@@ -550,11 +548,11 @@ module Innate
     # @api external
     # @see Node#to_template Node#find_aliased_view
     # @author manveru
-    def find_view(file, wish)
-      aliased = find_aliased_view(file, wish)
+    def find_view(action_name, wish)
+      aliased = find_aliased_view(action_name, wish)
       return aliased if aliased
 
-      to_view(file, wish)
+      to_view(action_name, wish)
     end
 
     # Try to find the best template for the given basename and wish.
@@ -562,7 +560,7 @@ module Innate
     # This method is mostly here for symetry with {to_layout} and to allow you
     # overriding the template lookup easily.
     #
-    # @param [#to_s] file
+    # @param [#to_s] action_name
     # @param [#to_s] wish
     #
     # @return [String, nil] depending whether a template could be found
@@ -571,9 +569,9 @@ module Innate
     # @see {Node#find_view} {Node#to_template} {Node#root_mappings}
     #      {Node#view_mappings} {Node#to_template}
     # @author manveru
-    def to_view(file, wish)
-      path = [root_mappings].concat(view_mappings) << file
-      to_template(path, wish)
+    def to_view(action_name, wish)
+      return unless files = view_templates[wish.to_s]
+      files[action_name.to_s]
     end
 
     # Aliasing one view from another.
@@ -611,9 +609,9 @@ module Innate
       trait[:alias_view][to.to_s] = node ? [from.to_s, node] : from.to_s
     end
 
-    # Resolve one level of aliasing for the given +file+ and +wish+.
+    # Resolve one level of aliasing for the given +action_name+ and +wish+.
     #
-    # @param [String] file
+    # @param [String] action_name
     # @param [String] wish
     #
     # @return [nil, String] the absolute path to the aliased template or nil
@@ -621,18 +619,21 @@ module Innate
     # @api internal
     # @see Node::alias_view Node::find_view
     # @author manveru
-    def find_aliased_view(file, wish)
-      aliased_file, aliased_node = ancestral_trait[:alias_view][file]
+    def find_aliased_view(action_name, wish)
+      aliased_name, aliased_node = ancestral_trait[:alias_view][action_name]
+      return unless aliased_name
+
       aliased_node ||= self
-      aliased_node.find_view(aliased_file, wish) if aliased_file
+      aliased_node.update_view_mappings
+      aliased_node.find_view(aliased_name, wish)
     end
 
-    # Find the best matching file for the layout, if any.
+    # Find the best matching action_name for the layout, if any.
     #
     # This is mostly an abstract method that you might find handy if you want
     # to do vastly different layout lookup.
     #
-    # @param [String] file
+    # @param [String] action_name
     # @param [String] wish
     #
     # @return [nil, String] the absolute path to the template or nil
@@ -640,9 +641,9 @@ module Innate
     # @api external
     # @see {Node#to_template} {Node#root_mappings} {Node#layout_mappings}
     # @author manveru
-    def to_layout(file, wish)
-      path = [root_mappings].concat(layout_mappings) << file
-      to_template(path, wish)
+    def to_layout(action_name, wish)
+      return unless files = layout_templates[wish.to_s]
+      files[action_name.to_s]
     end
 
     # Define a layout to use on this Node.
@@ -727,11 +728,11 @@ module Innate
       result = nil
 
       atoms.size.downto(0) do |len|
-        action = atoms[0...len].join('__')
+        action_name = atoms[0...len].join('__')
         params = atoms[len..-1]
-        action = 'index' if action.empty? and params != ['index']
+        action_name = 'index' if action_name.empty? and params != ['index']
 
-        return result if result = yield(action, params)
+        return result if result = yield(action_name, params)
       end
 
       return nil
@@ -781,31 +782,59 @@ module Innate
     #      Node#path_glob Node#ext_glob
     # @author manveru
     def to_template(path, wish)
-      return unless exts = ext_glob(wish)
-      glob = "#{path_glob(*path)}.#{exts}"
-      found = Dir[glob].uniq
+      to_view(path, wish) || to_layout(path, wish)
+    end
 
-      count = found.size
-      Log.warn("%d views found for %p" % [count, glob]) if count > 1
+    def update_template_mappings
+      update_view_mappings
+      update_layout_mappings
+    end
 
-      found.first
+    def update_view_mappings
+      paths = possible_paths_for(view_mappings)
+      @view_templates = update_mapping_shared(paths)
     end
 
-    # Produce a glob that can be processed by Dir::[] matching the possible
-    # paths to the given +elements+.
-    #
-    # The +elements+ are an Array that may be nested one level, take care to
-    # splat if you try to pass an existing Array.
-    #
-    # @return [String] glob matching possible paths to the given +elements+
-    #
-    # @api internal
-    # @see Node#to_template
-    # @author manveru
-    def path_glob(*elements)
-      File.join(elements.map{|element|
-        "{%s}" % [*element].map{|e| e.to_s.gsub('__', '/') }.join(',')
-      }).gsub(/\/\{\/?\}\//, '/')
+    def update_layout_mappings
+      paths = possible_paths_for(layout_mappings)
+      @layout_templates = update_mapping_shared(paths)
+    end
+
+    def update_mapping_shared(paths)
+      mapping = {}
+
+      provides.each do |wish_key, engine|
+        wish = wish_key[/(.*)_handler/, 1]
+        ext_glob = ext_glob(wish)
+
+        paths.reverse_each do |path|
+          ::Dir.glob(::File.join(path, "/**/*.#{ext_glob}")) do |file|
+            case file.sub(path, '').gsub('/', '__')
+            when /^(.*)\.(.*)\.(.*)$/
+              action_name, wish_ext, engine_ext = $1, $2, $3
+            when /^(.*)\.(.*)$/
+              action_name, wish_ext, engine_ext = $1, 'html', $2
+            when /.*/
+              p $1
+            end
+
+            mapping[wish_ext] ||= {}
+            mapping[wish_ext][action_name] = file
+          end
+        end
+      end
+
+      return mapping
+    end
+
+    def possible_paths_for(mappings)
+      root_mappings.map{|root_mapping|
+        mappings.first.map{|outer_mapping|
+          mappings.last.map{|inner_mapping|
+            File.join(root_mapping, outer_mapping, inner_mapping, '/')
+          }
+        }
+      }.flatten
     end
 
     # Produce a glob that can be processed by Dir::[] matching the extensions
@@ -842,7 +871,7 @@ module Innate
     # @api external
     # @author manveru
     def root_mappings
-      [*options.roots].dup
+      [*options.roots].flatten
     end
 
     # Set the paths for lookup below the Innate.options.views paths.
@@ -873,7 +902,7 @@ module Innate
       paths = [*ancestral_trait[:views]]
       paths = [mapping] if paths.empty?
 
-      [*options.views] + paths
+      [[*options.views].flatten, [*paths].flatten]
     end
 
     # Set the paths for lookup below the Innate.options.layouts paths.
@@ -904,7 +933,7 @@ module Innate
       paths = [*ancestral_trait[:layouts]]
       paths = [mapping] if paths.empty?
 
-      [*options.layouts] + paths
+      [[*options.layouts].flatten, [*paths].flatten]
     end
 
     def options

data/lib/innate/options.rb

@@ -2,7 +2,7 @@ module Innate
   # this has to be run after a couple of other files have been required
 
   options.dsl do
-    o "Indicate that calls Innate::start will be ignored",
+    o "Innate::start will not start an adapter if true",
       :started, false
 
     o "Will send ::setup to each element during Innate::start",

data/lib/innate/request.rb

@@ -71,7 +71,7 @@ module Innate
     # Both +value+ and the elements of +keys+ will be turned into String by #to_s.
     def [](value, *keys)
       return super(value) if keys.empty?
-      [value, *keys].map{|k| super(k) }
+      [value, *keys].map{|key| super(key) }
     end
 
     # the full request URI provided by Rack::Request
@@ -94,8 +94,8 @@ module Innate
     #   # => {'name' => 'jason', 'job' => 'lumberjack'}
 
     def subset(*keys)
-      keys = keys.map{|k| k.to_s }
-      params.reject{|k,v| not keys.include?(k) }
+      keys = keys.map{|key| key.to_s }
+      params.reject{|key, value| not keys.include?(key) }
     end
 
     # Try to figure out the domain we are running on, this might work for some
@@ -137,25 +137,5 @@ module Innate
     rescue ArgumentError => ex
       raise ArgumentError, ex unless ex.message == 'invalid address'
     end
-
-    REQUEST_STRING_FORMAT = "#<%s params=%p cookies=%p env=%p>"
-
-    def to_s
-      REQUEST_STRING_FORMAT % [self.class, params, cookies, http_variables]
-    end
-    alias inspect to_s
-
-    # Pretty prints current action with parameters, cookies and enviroment
-    # variables.
-    def pretty_print(pp)
-      pp.object_group(self){
-        group = { 'params' => params, 'cookies' => cookies, 'env' => http_vars }
-        group.each do |name, hash|
-          pp.breakable
-          pp.text " @#{name}="
-          pp.nest(name.size + 3){ pp.pp_hash(hash) }
-        end
-      }
-    end
   end
 end