manveru-ramaze 2009.01 → 2009.04

data/lib/proto/spec/main.rb

@@ -1,25 +1,21 @@
 require 'ramaze'
-require 'ramaze/spec/helper'
+require 'ramaze/spec'
 
 require __DIR__('../start')
+Ramaze.options.roots = __DIR__('../')
 
 describe MainController do
-  behaves_like 'http', 'xpath'
-  ramaze :view_root => __DIR__('../view'),
-         :public_root => __DIR__('../public')
+  behaves_like :mock
 
-  it 'should show start page' do
-    got = get('/')
-    got.status.should == 200
-    puts got.body
-    got.at('//title').text.strip.should ==
-      MainController.new.index
+  should 'show start page' do
+    get('/').status.should == 200
+    last_response['Content-Type'].should == 'text/html'
+    last_response.should =~ /<h1>Welcome to Ramaze!<\/h1>/
   end
 
-  it 'should show /notemplate' do
-    got = get('/notemplate')
-    got.status.should == 200
-    got.at('//div').text.strip.should ==
-      MainController.new.notemplate
+  should 'show /notemplate' do
+    get('/notemplate').status.should == 200
+    last_response['Content-Type'].should == 'text/html'
+    last_response.should =~ /there is no 'notemplate\.xhtml' associated with this action/
   end
 end

data/lib/proto/start.rb

@@ -1,12 +1,8 @@
-require 'rubygems'
-require 'ramaze'
+# Use this file directly like `ruby start.rb` if you don't want to use the
+# `ramaze start` command.
+# All application related things should go into `app.rb`, this file is simply
+# for options related to running the application locally.
 
-# Add directory start.rb is in to the load path, so you can run the app from
-# any other working path
-$LOAD_PATH.unshift(__DIR__)
+require File.expand_path('app', File.dirname(__FILE__))
 
-# Initialize controllers and models
-require 'controller/init'
-require 'model/init'
-
-Ramaze.start :adapter => :webrick, :port => 7000
+Ramaze.start(:adapter => :webrick, :port => 7000, :file => __FILE__)

data/lib/proto/view/index.xhtml

@@ -1,34 +1,41 @@
-<p>Ramaze is working correctly with this application, now you can start
-working.</p>
+<p>
+  Ramaze is working correctly with this application, now you can start working.
+</p>
 
-<p>To start you can modify:
-<ol>
-  <li>
-    <code>view/index.xhtml</code>, this page.
-  </li>
-  <li>
-    <code>view/page.xhtml</code>, the layout for this page.
-  </li>
-  <li>
-    <code>controller/main.rb</code>, where you can change the header of this
-    page and the <a href="/notemplate">notemplate</a> action
-  </li>
-</ol>
+<p>
+  To start you can modify:
+  <ol>
+    <li>
+      <code>view/index.xhtml</code>, this page.
+    </li>
+    <li>
+      <code>view/page.xhtml</code>, the layout for this page.
+    </li>
+    <li>
+      <code>controller/main.rb</code>, where you can change the header of this
+      page and the <a href="/notemplate">notemplate</a> action
+    </li>
+  </ol>
 </p>
 
-<p>For more documentation, check out <a href="http://ramaze.net">www.ramaze.net</a>, which includes:
-<ul>
-  <li>a <a href="http://ramaze.net/getting-started">getting started</a> guide</li>
-  <li>some <a href="http://ramaze.net/screencasts">screencasts</a></li>
-  <li>and an <a href="http://ramaze.rubyforge.org/tutorial/todolist.html">introductory tutorial</a></li>
-</ul>
+<p>For more documentation, check out <a href="http://ramaze.net">ramaze.net</a> and <a href="http://wiki.ramaze.net">wiki.ramaze.net</a>, which includes:
+  <ul>
+    <li>a <a href="http://wiki.ramaze.net/Walkthrough">getting started</a> guide</li>
+    <li>some <a href="http://wiki.ramaze.net/Screencasts">screencasts</a></li>
+    <li>and an <a href="http://wiki.ramaze.net/Tutorials/Todolist">introductory tutorial</a></li>
+  </ul>
 </p>
 
-<p>You can also read the
-<a href="http://ramaze.rubyforge.org/rdoc/files/doc/README.html">rdocs</a> or browse
-around the <a href="http://source.ramaze.net">Ramaze source code</a>.
+<p>
+You can also read the
+<a href="http://ramaze.rubyforge.org/rdoc/files/doc/README.html">rdocs</a>
+or browse around the
+<a href="http://source.ramaze.net">Ramaze source code</a>.
 </p>
 
-<p>For help with Ramaze, visit the <a href="irc://chat.freenode.net/ramaze">#ramaze on irc.freenode.net</a> (you can use <a href="http://java.freenode.net/?channel=ramaze">this browser-based frontend</a>),
-or post on the <a href="http://groups.google.com/group/ramaze">Ramaze Google Group</a>.
-  </p>
+<p>
+For help with Ramaze, visit <a href="irc://chat.freenode.net/ramaze">#ramaze on irc.freenode.net</a>.<br />
+You can use <a href="http://embed.mibbit.com/?server=irc.freenode.net&channel=#ramaze,#ruby-lang&forcePrompt=true">Mibbit</a>, an AJAX based IRC client or <a href="http://java.freenode.net/?channel=ramaze">the official freenode irc java applet</a>.
+<br />
+Feel free to post to the <a href="http://groups.google.com/group/ramaze">Ramaze Google Group</a>, your first mail has to go through moderation, so please be patient.
+</p>

data/lib/ramaze/app.rb

@@ -0,0 +1,124 @@
+module Ramaze
+  # An application is a collection of controllers and options that have a
+  # common name.
+  # Every application has a location it dispatches from, this behaves similar
+  # to Rack::URLMap.
+
+  AppMap = Innate::URLMap.new
+
+  def self.to(object)
+    app_name = object.ancestral_trait[:app]
+    App[app_name].to(object)
+  end
+
+  # App is the superclass for applications and acts as their prototype when it
+  # comes to configuration.
+  #
+  # An application consists of options, a location, and a list of objects. The
+  # objects are usually {Controller}s.
+  #
+  # The options are inherited, the basics are set in Ramaze.options, from there
+  # to Ramaze::App.options, and finally into every instance of App.
+  #
+  # This allows to collect {Controller}s of your application into a common
+  # group that can easily be used in other applications, while retaining the
+  # original options.
+  #
+  # Every instance of {App} is mapped in {AppMap}, which is the default
+  # location to #call from Rack.
+  #
+  # Additionally, every {App} can have custom locations for
+  # root/public/view/layout directories, which allows reuse beyond directory
+  # boundaries.
+  #
+  # In contrast to Innate, where all Nodes share the same middleware, {App}
+  # also has a subset of middleware that handles serving static files, routes
+  # and rewrites.
+  #
+  # To indicate that a {Controller} belongs to a specific application, you can
+  # pass a second argument to {Controller::map}
+  #
+  # @example adding Controller to application
+  #
+  #   class WikiController < Ramaze::Controller
+  #     map '/', :wiki
+  #   end
+  #
+  # The App instance will be created for you and if you don't use any other
+  # applications in your code there is nothing else you have to do. Others can
+  # now come and simply reuse your code in their own applications.
+  #
+  # There is some risk of name collisions if everybody calls their app `:wiki`,
+  # but given that you only use one foreign app of this kind might give less
+  # reason for concern.
+  #
+  # If you still try to use two apps with the same name, you have to be
+  # careful, loading one first, renaming it, then loading the second one.
+  #
+  # The naming of an App has no influence on any other aspects of dispatching
+  # or configuration.
+  class App
+    include Innate::Optioned
+
+    # options not found here will be looked up in Ramaze.options
+    options.dsl do
+      o "Unique identifier for this application",
+        :name, :pristine
+    end
+
+    APP_LIST = {}
+
+    attr_reader :name, :location, :url_map, :options
+
+    def initialize(name, location)
+      @name = name.to_sym
+      @url_map = Innate::URLMap.new
+      self.location = location
+
+      APP_LIST[@name] = self
+
+      @options = self.class.options.sub(@name)
+    end
+
+    def sync
+      AppMap.map(location, self)
+    end
+
+    def location=(location)
+      @location = location.to_str.freeze
+      sync
+    end
+
+    def call(env)
+      to_app.call(env)
+    end
+
+    def to_app
+      files = Ramaze::Files.new(*public_roots)
+      app = Current.new(Route.new(url_map), Rewrite.new(url_map))
+      Rack::Cascade.new([files, app])
+    end
+
+    def map(location, object)
+      url_map.map(location, object)
+    end
+
+    def to(object)
+      return unless mapped = url_map.to(object)
+      [location, mapped].join('/').squeeze('/')
+    end
+
+    def public_roots
+      roots, publics = [*options.roots], [*options.publics]
+      roots.map{|root| publics.map{|public| ::File.join(root, public) }}.flatten
+    end
+
+    def self.find_or_create(name, location = '/')
+      self[name] || new(name, location)
+    end
+
+    def self.[](name)
+      APP_LIST[name.to_sym]
+    end
+  end
+end

data/lib/ramaze/cache/localmemcache.rb

@@ -0,0 +1,56 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'localmemcache'
+
+module Ramaze
+  class Cache
+
+    # Cache based on the localmemcache library which utilizes mmap to share
+    # strings in memory between ruby instances.
+    class LocalMemCache
+      include Cache::API
+
+      OPTIONS = {
+        :size_mb    => 1024,
+        :serialize  => true,
+        :serializer => ::Marshal, # something that responds to ::load and ::dump
+      }
+
+      # Connect to localmemcache
+      def cache_setup(host, user, app, name)
+        @namespace = [host, user, app, name].compact.join('-')
+
+        options = {:namespace => @namespace}.merge(OPTIONS)
+
+        @serialize = options.delete(:serialize)
+        @serializer = options.delete(:serializer)
+
+        @store = ::LocalMemCache.new(options)
+      end
+
+      # Wipe out _all_ data in localmemcached, use with care.
+      def cache_clear
+        ::LocalMemCache.clear_namespace(@namespace)
+      end
+
+      def cache_delete(*args)
+        super{|key| @store.delete(key.to_s) }
+      end
+
+      # NOTE:
+      #   * We have no way of knowing whether the value really is nil, we
+      #     assume you wouldn't cache nil and return the default instead.
+      def cache_fetch(*args)
+        super{|key|
+          value = @store[key.to_s]
+          @serializer.load(value) if value
+        }
+      end
+
+      def cache_store(*args)
+        super{|key, value| @store[key.to_s] = @serializer.dump(value) }
+      end
+    end
+  end
+end

data/lib/ramaze/cache/memcache.rb

@@ -0,0 +1,99 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'memcache'
+
+module Ramaze
+  class Cache
+
+    # Cache based on the memcache library which utilizes the memcache-daemon to
+    # store key/value pairs in namespaces.
+    #
+    # Please read the documentation of memcache-client for further methods.
+    #
+    # It is highly recommended to install memcache-client_extensions for
+    # a bit of speedup and more functionality
+    class MemCache
+      include Cache::API
+
+      # +:multithread+: May be turned off at your own risk.
+      #    +:readonly+: You most likely want that to be false.
+      #     +:servers+: Array containing at least one of:
+      #                 MemCache::Server instance
+      #                 Strings like "localhost", "localhost:11211", "localhost:11211:1"
+      #                 That accord to "host:port:weight", only host is required.
+      OPTIONS = {
+        :multithread => true,
+        :readonly    => false,
+        :servers     => ['localhost:11211:1'],
+      }
+
+      # Connect to memcached
+      def cache_setup(host, user, app, name)
+        @namespace = [host, user, app, name].compact.join('-')
+        options = {:namespace => @namespace}.merge(OPTIONS)
+        servers = options.delete(:servers)
+        @store = ::MemCache.new(servers, options)
+      end
+
+      # Wipe out _all_ data in memcached, use with care.
+      def cache_clear
+        @store.flush_all
+      rescue ::MemCache::MemCacheError => e
+        Log.error(e)
+        nil
+      end
+
+      #
+      def cache_delete(*keys)
+        super{|key| @store.delete(key) }
+      rescue ::MemCache::MemCacheError => e
+        Log.error(e)
+        nil
+      end
+
+      # NOTE:
+      #   * We have no way of knowing whether the value really is nil, we
+      #     assume you wouldn't cache nil and return the default instead.
+      def cache_fetch(key, default = nil)
+        value = @store[key]
+        value.nil? ? default : value
+      rescue ::MemCache::MemCacheError => e
+        Log.error(e)
+        nil
+      end
+
+      def cache_store(key, value, options = {})
+        ttl = options[:ttl] || 0
+        @store.set(key, value, ttl)
+        value
+      rescue ::MemCache::MemCacheError => e
+        Log.error(e)
+        nil
+      end
+
+      # statistics about usage
+      def stats; @store.stats; end
+
+      # current namespace
+      def namespace; @store.namespace; end
+
+      # switch to different namespace
+      def namespace=(ns) @namespace = @store.namespace = ns; end
+
+      # state of compression (true/false)
+      def compression; @store.compression; end
+
+      # turn compression on or off
+      def compression=(bool); @store.compression = bool; end
+
+      # For everything else that we don't care to document right now.
+      def method_missing(*args, &block)
+        @store.__send__(*args, &block)
+      rescue ::MemCache::MemCacheError => e
+        Log.error(e)
+        nil
+      end
+    end
+  end
+end

data/lib/ramaze/cache/sequel.rb

@@ -0,0 +1,67 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  class Cache
+
+    # Cache based on a Sequel model using relational databases.
+    class Sequel
+      include Cache::API
+
+      class Table < ::Sequel::Model(:ramaze_cache)
+        set_schema do
+          primary_key :id
+          string :key
+          string :value
+          time :expires
+          index :key, :unique => true
+        end
+
+        transform :value => [
+          lambda{|value| ::Marshal.load(value.unpack('m*')[0]) },
+          lambda{|value| [::Marshal.dump(value)].pack('m*') }
+        ]
+      end
+
+      # Setup the table, not suitable for multiple apps yet.
+      def cache_setup(host, user, app, name)
+        @namespace = [host, user, app, name].compact.join(':')
+        Table.create_table unless Table.table_exists?
+        @store = Table
+      end
+
+      # Wipe out _all_ data in the table, use with care.
+      def cache_clear
+        Table.delete_all
+      end
+
+      # Delete records for given +keys+
+      def cache_delete(*keys)
+        super do |key|
+          record = @store[:key => namespaced(key)]
+          record.delete if record
+        end
+      end
+
+      def cache_fetch(key, default = nil)
+        super{|key| @store[:key => namespaced(key)] }
+      end
+
+      def cache_store(key, value, options = {})
+        key = namespaced(key)
+        ttl = options[:ttl]
+        expires = Time.now + ttl if ttl
+
+        record = @store[:key => key].update(:value => value, :expires => expires)
+        record.value
+      rescue
+        record = @store.create(:key => key, :value => value, :expires => expires)
+        record.value
+      end
+
+      def namespaced(key)
+        [@namespace, key].join(':')
+      end
+    end
+  end
+end

data/lib/ramaze/cache.rb

@@ -1,114 +1,19 @@
-#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-require 'ramaze/cache/memory'
+require 'innate/cache'
 
 module Ramaze
-  autoload :YAMLStoreCache, "ramaze/cache/yaml_store.rb"
-  autoload :MemcachedCache, "ramaze/cache/memcached.rb"
-  autoload :FileCache, "ramaze/cache/file.rb"
-
-  # This is the wrapper of all caches, providing mechanism
-  # for switching caching from one adapter to another.
+  Cache = Innate::Cache
 
   class Cache
-    include Enumerable
-
-    # Holds all the instances of Cache that are being added.
-    CACHES = {} unless defined?(CACHES)
-
-    attr_accessor :cache
-
-    class << self
-
-      # Initializes the Cache for the general caches Ramaze uses.
-      # Cache#startup is called by Ramaze#startup, when initializing the
-      # Ramaze.trait(:essentials).
-
-      def startup(options)
-        Cache.add :compiled, :actions, :patterns,
-                  :resolved, :shield, :action_methods
-      end
-
-      # This will define a method to access a new cache directly over
-      # singleton-methods on Cache.
-      #---
-      # The @cache_name is internally used for caches which do not save
-      # different caches in different namespaces, for example memcached.
-      #+++
-
-      def add *keys
-        keys.each{|key|
-          klass = Global.cache_alternative.fetch(key, Global.cache)
-          add_on(key, klass)
-        }
-        Log.dev("Added caches for: #{keys.join(', ')}")
-      end
-
-      # Define a new cache available by Cache::key
-      def add_on(key, cache_class)
-        CACHES[key] = new(cache_class)
-        CACHES[key].instance_variable_set("@cache_name", key)
-        eval("def self.%s; CACHES[%p]; end" % [key, key])
-      end
-
-    end
-
-    # Initializes the cache, defined by Global.cache
-    def initialize(cache = Global.cache)
-      @cache = cache.new
-    end
-
-    # Gets the value for the given key, or +nil+ if not found.
-    def [](key)
-      fetch(key)
-    end
-
-    # Sets _key_ to _value_ with an infinite time to live.
-    def []=(key, value)
-      store(key, value)
-    end
-
-    # Empties this cache.
-    def clear
-      @cache.clear
-    end
-
-    # Deletes each passed key from this cache.
-    def delete(*args)
-      args.each do |arg|
-        @cache.delete("#{@cache_name}:#{arg}")
-      end
-    end
-
-    # Gets the value of the given key, or _default_ if not found.
-    def fetch(key, default = nil)
-      return default unless entry = @cache["#{@cache_name}:#{key}"]
-      return entry[:value] if entry[:expires].nil? || entry[:expires] > Time.now
-      @cache.delete("#{@cache_name}:#{key}")
-      default
-    end
-
-    alias get fetch
-
-    # Sets key to value. Supports the following options:
-    #   [+:ttl+] time to live in seconds
-    def store(key, value, opts = {})
-      opts = {:ttl => opts} if opts.is_a?(Integer)
-      @cache["#{@cache_name}:#{key}"] = {
-        :expires => opts[:ttl] ? Time.now + opts[:ttl].to_i : nil,
-        :value   => value
-      }
-      value
-    end
-
-    alias set store
+    autoload :LocalMemCache, 'ramaze/cache/localmemcache'
+    autoload :MemCache,      'ramaze/cache/memcache'
+    autoload :Sequel,        'ramaze/cache/sequel'
 
-    # Answers with value for each key.
-    def values_at(*keys)
-      values = []
-      keys.each {|key| values << fetch(key) }
-      values
+    def self.clear_after_reload
+      action.clear if respond_to?(:action)
+      action_value.clear if respond_to?(:action_value)
     end
   end
 end

data/lib/ramaze/contrib/app_graph.rb

@@ -0,0 +1,64 @@
+require 'set'
+
+# require 'ramaze/contrib/app_graph'
+#
+# graph = AppGraph.new
+# graph.generate
+# graph.show
+
+class AppGraph
+  def initialize
+    @out = Set.new
+  end
+
+  def generate
+    Ramaze::AppMap.to_hash.each do |location, app|
+      connect(location => app.name)
+
+      app.url_map.to_hash.each do |c_location, c_node|
+        connect(app.name => c_node)
+        connect(c_node.mapping => c_node)
+
+        c_node.update_template_mappings
+        c_node.view_templates.each do |wish, mapping|
+          mapping.each do |action_name, template|
+            action_path = File.join(c_node.mapping, action_name)
+            connect(c_node => action_path, action_path => template)
+          end
+        end
+
+        c_node.update_method_arities
+        c_node.method_arities.each do |method, arity|
+          action_path = File.join(c_node.mapping, method.to_s)
+          connect(action_path => "#{c_node}##{method}[#{arity}]", c_node => action_path)
+        end
+      end
+    end
+  end
+
+  def connect(hash)
+    hash.each do |from, to|
+      @out << ("  %p -> %p;" % [from.to_s, to.to_s])
+    end
+  end
+
+  def write_dot
+    File.open('graph.dot', 'w+') do |dot|
+      dot.puts 'digraph appmap {'
+      dot.puts(*@out)
+      dot.puts '}'
+    end
+  end
+
+  def show
+    write_dot
+    options = {
+      'rankdir' => 'LR',
+      'splines' => 'true',
+      'overlap' => 'false',
+    }
+    args = options.map{|k,v| "-G#{k}=#{v}" }
+    system("dot -O -Tpng #{args.join(' ')} graph.dot")
+    system('feh graph.dot.png')
+  end
+end

data/lib/ramaze/contrib/email.rb

@@ -30,6 +30,8 @@ require 'net/smtp'
 
 module Ramaze
   class EmailHelper
+    include Innate::Traited
+
     # Required to be set
     trait :smtp_server => 'smtp.your-isp.com'
     trait :smtp_helo_domain => 'your.helo.domain.com'