ramaze 0.1.0 → 0.1.1

data/lib/ramaze/template/markaby.rb

@@ -15,33 +15,27 @@ module Ramaze
         # Also tries to render the template.
         # In Theory you can use this standalone, this has not been tested though.
 
-        def transform controller, options = {}
-          action, parameter, file, bound = *super
-
-          unless controller.private_methods.include?(action)
-            reaction = controller.__send__(action, *parameter)
-            template =
-              if file
-                transform_file(controller, file)
-              elsif reaction.respond_to?(:to_str)
-                reaction
-              end
-            return template if template
-          end
+        def transform action
+          result, file = result_and_file(action)
 
-          raise Error::NoAction, "No Action found for `#{action}' on #{controller.class}"
+          result = transform_file(file, action) if file
+          result.to_s
         end
 
-        def transform_file controller, file
-          ivs = {}
-          controller.instance_variables.each do |iv|
-            ivs[iv.gsub('@', '').to_sym] = controller.instance_variable_get(iv)
-          end
+        def transform_file file, action
+          controller = action.controller
+          ivs = extract_ivs(controller)
+
           controller.send(:mab, ivs) do
-            instance_eval(File.read(file))
+            instance_eval(file)
+          end
+        end
+
+        def extract_ivs(controller)
+          controller.instance_variables.inject({}) do |hash, iv|
+            sym = iv.gsub('@', '').to_sym
+            hash.merge! sym => controller.instance_variable_get(iv)
           end
-        rescue Object => ex
-          raise Error::Template, ex.message, ex.backtrace
         end
       end
     end

data/lib/ramaze/template/remarkably.rb

@@ -0,0 +1,28 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'remarkably/engines/html'
+
+module Ramaze
+  module Template
+    class Remarkably < Template
+      Controller.register_engine self, %w[ rem ]
+
+      class << self
+        def transform action
+          result, file = result_and_file(action)
+
+          result = transform_file(file, action) if file
+          result.to_s
+        end
+
+        def transform_file(file, action)
+          action.controller.instance_eval do
+            args = action.params
+            instance_eval(file)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ramaze/tool/mime.rb

@@ -1,6 +1,8 @@
 #          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
+require 'yaml'
+
 module Ramaze
   module Tool
     module MIME

data/lib/ramaze/tool/record.rb

@@ -0,0 +1,6 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  Record = []
+end

data/lib/ramaze/trinity/request.rb

@@ -12,7 +12,7 @@ module Ramaze
   # The purpose of this class is to act as a simple wrapper for Rack::Request
   # and provide some convinient methods for our own use.
 
-  module Request
+  class Request < ::Rack::Request
     class << self
 
       # get the current request out of Thread.current[:request]
@@ -24,33 +24,6 @@ module Ramaze
       end
     end
 
-    # shortcut for request.params[key]
-
-    def [](key)
-      params[key.to_s]
-    end
-
-    # shortcut for request.params[key] = value
-
-    def []=(key, value)
-      params[key.to_s] = value
-    end
-
-    # like Hash#values_at
-
-    def values_at(*keys)
-      keys.map{|key| params[key] }
-    end
-
-
-    # the referer of the client or '/'
-
-    def referer
-      env['HTTP_REFERER'] || '/'
-    end
-
-    alias referrer referer
-
     # you can access the original @request via this method_missing,
     # first it tries to match your method with any of the HTTP parameters
     # then, in case that fails, it will relay to @request
@@ -61,35 +34,52 @@ module Ramaze
       super
     end
 
-    def self.included(klass)
-      klass.class_eval do
-        unless defined?(fullpath)
-          def fullpath
-            path = script_name + path_info
-            path << "?" << query_string  unless query_string.empty?
-            path
-          end
-        end
-
-        unless defined?(rack_params)
-          alias rack_params params
-
-          def params
-            ps = rack_params
-            temp = Hash.new{|h,k| h[k] = {}}
+    unless defined?(rack_params)
+      alias rack_params params
 
-            ps.each do |key, value|
-              outer_key, inner_key = key.scan(/^(.+)\[(.*?)\]$/).first
-              if outer_key and inner_key
-                temp[outer_key][inner_key] = value
-              else
-                temp[key] = value
-              end
-            end
-
-            temp
+      # Wrapping Request#params to support a one-level hash notation.
+      # It doesn't support anything really fancy, so be conservative in its use.
+      #
+      # Example Usage:
+      #
+      #  # Template:
+      #
+      #  <form action="/paste">
+      #    <input type="text" name="paste[name]" />
+      #    <input type="text" name="paste[syntax]" />
+      #    <input type="submit" />
+      #  </form>
+      #
+      #  # In your Controller:
+      #
+      #  def paste
+      #    name, syntax = request.params['paste'].values_at('name', 'syntax')
+      #    paste = Paste.create_with(:name => name, :syntax => syntax)
+      #    redirect '/'
+      #  end
+      #
+      #  # Or, easier:
+      #
+      #  def paste
+      #    paste = Paste.create_with(request.params)
+      #    redirect '/'
+      #  end
+
+      def params
+        ps = rack_params
+        temp = {}
+
+        ps.each do |key, value|
+          outer_key, inner_key = key.scan(/^(.+)\[(.*?)\]$/).first
+          if outer_key and inner_key
+            temp[outer_key] ||= {}
+            temp[outer_key][inner_key] = value
+          else
+            temp[key] = value
           end
         end
+
+        temp
       end
     end
   end

data/lib/ramaze/trinity/response.rb

@@ -2,7 +2,7 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
-  module Response
+  class Response < ::Rack::Response
     class << self
 
       # get the current response out of Thread.current[:response]

data/lib/ramaze/trinity/session.rb

@@ -22,7 +22,7 @@ module Ramaze
       old = @hash.dup
       result = @hash.send(*args, &block)
       unless old == @hash
-        Session.current.sessions[Session.current.session_id] = self
+        Cache.sessions[Session.current.session_id] = self
       end
       result
     end
@@ -53,14 +53,19 @@ module Ramaze
 
     SESSION_KEY = '_ramaze_session_id'
 
-    trait :finalize => [:finalize_flash]
+    IP_CACHE = Hash.new{|h,k| h[k] = []}
 
-    trait :ip_cache => Hash.new{|h,k| h[k] = []}
-
-    trait :ip_cache_limit => 1000
+    IP_CACHE_LIMIT = 1000
 
     class << self
 
+      # called from Ramaze::startup and adds Cache.sessions if cookies are
+      # enabled
+
+      def startup(options = {})
+        Cache.add(:sessions) if Global.cookies
+      end
+
       # answers with Thread.current[:session] which holds the current session
       # set by the Dispatcher#setup_environment.
 
@@ -73,34 +78,18 @@ module Ramaze
     # given to us from Dispatcher#setup_environment.
     #
     # sets @session_id and @session_flash
-    #
-    # will set Thread.main[:session_cache] to an instance of
-    # Ramaze::Global.cache if no cache for the sessions is initialized yet
 
     def initialize request
       @session_id = (request.cookies[SESSION_KEY] || random_key)
-      ip_cache = ancestral_trait[:ip_cache]
+      ip_cache = IP_CACHE
       ip = request.remote_addr
       ip_cache[ip] << @session_id
 
-      if ip_cache[ip].size >= ancestral_trait[:ip_cache_limit]
+      if ip_cache[ip].size > IP_CACHE_LIMIT
         sessions.delete(ip_cache[ip].shift)
       end
 
       @flash = Ramaze::SessionFlash.new
-
-      unless sessions
-        global_cache = Ramaze::Global.cache
-
-        if global_cache.respond_to?(:new)
-          cache = global_cache.new
-        else
-          cache = constant("::Ramaze::#{global_cache}")
-          cache = cache.new if cache.respond_to?(:new)
-        end
-
-        Thread.main[:session_cache] = cache
-      end
     end
 
     # relay all messages we don't understand to the currently active session
@@ -116,10 +105,10 @@ module Ramaze
       sessions[session_id] ||= SessionHash.new
     end
 
-    # shortcut to Thread.main[:session_cache]
+    # shortcut to Cache.sessions
 
     def sessions
-      Thread.main[:session_cache]
+      Cache.sessions
     end
 
     # generate a random (and hopefully unique) id for the current session.
@@ -140,28 +129,17 @@ module Ramaze
       Digest::SHA256.hexdigest(h)
     end
 
-    # send each element of the trait[:finalize]
-    # this is at the moment used for flash_finalize.
-
-    def finalize
-      ancestral_trait[:finalize].each do |meth|
-        send meth
-      end
-    end
-
     def inspect
       current.inspect
     end
 
-    private
-
     # at the end of a request delete the current[:FLASH] and assign it to
     # current[:FLASH_PREVIOUS]
     #
     # this is needed so flash can iterate over requests
     # and always just keep the current and previous key/value pairs.
 
-    def finalize_flash
+    def finalize
       old = delete(:FLASH)
       current[:FLASH_PREVIOUS] = old if old
     end

data/lib/ramaze/version.rb

@@ -5,7 +5,7 @@ module Ramaze #:nodoc:
   module Version #:nodoc:
     MAJOR = 0
     MINOR = 1
-    TINY  = 0
+    TINY  = 1
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/rake_tasks/gem.rake

@@ -17,8 +17,8 @@ spec =
         s.post_install_message = POST_INSTALL_MESSAGE
 
         s.add_dependency('rake', '>=0.7.3')
-        s.add_dependency('rspec', '>=0.9.1')
-        s.add_dependency('rack', '>=0.1.0')
+        s.add_dependency('rspec', '>=1.0.2')
+        s.add_dependency('rack', '>=0.2.0')
         # s.required_ruby_version = '>= 1.8.5'
 
         s.files = (RDOC_FILES + %w[Rakefile] + Dir["{examples,bin,doc,spec,lib,rake_tasks}/**/*"]).uniq

data/rake_tasks/maintaince.rake

@@ -119,7 +119,7 @@ task 'tutorial2html' do
 
   basefile = File.join('doc', 'tutorial', 'todolist')
 
-  content = File.read(basefile + '.txt')
+  content = File.read(basefile + '.mkd')
 
   html = BlueCloth.new(content).to_html
 
@@ -156,6 +156,47 @@ task 'tutorial2html' do
   File.open(basefile + '.html', 'w+'){|f| f.puts(wrap) }
 end
 
+task 'tutorial' => ['tutorial2html'] do
+  require 'hpricot'
+
+  system 'rake tutorial2html'
+
+  filename = 'doc/tutorial/todolist.html'
+  file = File.read(filename)
+  doc = Hpricot(file)
+
+  to_links = []
+
+  (doc/:h2).each do |h2|
+    text      = h2.inner_html
+    link_id   = text.gsub(' ', '_')
+    to_links << %{<a href="##{link_id}">#{text}</a>}
+    to_link   = %{<a name="#{link_id}"><h2>#{text}</h2></a>}
+
+    file.gsub!(h2.to_html, to_link)
+  end
+
+  links = to_links.join("</ol>\n    <ol>")
+  h1 = "<h1>To-do List Tutorial</h1>"
+  menu =
+%{
+  #{h1}
+
+<div class="menu">
+  <h3>Table of Contents</h3>
+  <li>
+    <ol>#{links}</ol>
+  </li>
+</div>
+}
+
+  file.gsub!(h1, menu)
+
+  File.open(filename, 'w+') do |f|
+    f.puts file
+  end
+end
+
 task 'authors' do
   changes = `darcs changes`
   authors = []

data/rake_tasks/spec.rake

@@ -0,0 +1,45 @@
+#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'rake'
+require 'spec/helper/layout'
+require 'lib/ramaze/snippets/string/DIVIDE'
+
+SPEC_BASE = File.expand_path('spec')
+
+# ignore files with these paths
+ignores = [ './*', './helper/*', './ramaze/adapter.rb', './ramaze/request.rb', ]
+
+files = Dir[SPEC_BASE/'**'/'*.rb']
+ignores.each do |ignore|
+  ignore_files = Dir[SPEC_BASE/ignore]
+  ignore_files.each do |ignore_file|
+    files.delete File.expand_path(ignore_file)
+  end
+end
+
+files.sort!
+
+spec_layout = Hash.new{|h,k| h[k] = []}
+
+files.each do |file|
+  name = file.gsub(/^#{SPEC_BASE}/, '.')
+  dir_name = File.dirname(name)[2..-1]
+  task_name = ([:test] + dir_name.split('/')).join(':')
+  spec_layout[task_name] << file
+end
+
+spec_layout.each do |task_name, specs|
+
+  desc task_name
+  task task_name => [:clean] do
+    wrap = SpecWrap.new(*specs)
+    wrap.run
+  end
+end
+
+desc "Test all"
+task "test:all" => [:clean] do
+  wrap = SpecWrap.new(*spec_layout.values.flatten)
+  wrap.run
+end