rjspotter-ramaze 2009.06.29

data/lib/proto/spec/main.rb

@@ -0,0 +1,20 @@
+require 'ramaze'
+require 'ramaze/spec/bacon'
+
+require __DIR__('../app')
+
+describe MainController do
+  behaves_like :rack_test
+
+  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
+
+  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

@@ -0,0 +1,8 @@
+# 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.
+
+require File.expand_path('app', File.dirname(__FILE__))
+
+Ramaze.start(:adapter => :webrick, :port => 7000, :file => __FILE__)

data/lib/proto/view/index.xhtml

@@ -0,0 +1,41 @@
+<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>
+
+<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>
+
+<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.rb

@@ -0,0 +1,87 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+# Namespace for Ramaze
+#
+# THINK:
+#   * for now, we don't extend this with Innate to keep things clean. But we
+#     should eventually do it for a simple API, or people always have to find
+#     out whether something is in Innate or Ramaze.
+#     No matter which way we go, we should keep references point to the
+#     original location to avoid too much confusion for core developers.
+module Ramaze
+  ROOT = File.expand_path(File.dirname(__FILE__)) unless defined?(Ramaze::ROOT)
+
+  unless $LOAD_PATH.any?{|lp| File.expand_path(lp) == ROOT }
+    $LOAD_PATH.unshift(ROOT)
+  end
+
+  # 3rd party
+  require 'innate'
+
+  @options = Innate.options
+  class << self; attr_accessor :options; end
+
+  # vendored, will go into rack-contrib
+  require 'vendor/etag'
+  require 'vendor/route_exceptions'
+
+  # Ramaze itself
+  require 'ramaze/version'
+  require 'ramaze/log'
+  require 'ramaze/snippets'
+  require 'ramaze/helper'
+  require 'ramaze/view'
+  require 'ramaze/controller'
+  require 'ramaze/cache'
+  require 'ramaze/reloader'
+  require 'ramaze/setup'
+  require 'ramaze/app'
+  require 'ramaze/files'
+  require 'ramaze/middleware_compiler'
+  require 'ramaze/plugin'
+  require 'ramaze/request'
+  require 'ramaze/current'
+
+  # Usually it's just mental overhead to remember which module has which
+  # constant, so we just assign them here as well.
+  # This will not affect any of the module functions on Innate, you still have
+  # to reference the correct module for them.
+  # We do not set constants already set from the requires above.
+  Innate.constants.each do |const|
+    begin
+      Ramaze.const_get(const)
+    rescue NameError
+      Ramaze.const_set(const, Innate.const_get(const))
+    end
+  end
+
+  extend Innate::SingletonMethods
+
+  options[:middleware_compiler] = Ramaze::MiddlewareCompiler
+
+  middleware! :dev do |m|
+    m.use Rack::Lint
+    m.use Rack::CommonLogger, Ramaze::Log
+    m.use Rack::ShowExceptions
+    m.use Rack::ShowStatus
+    m.use Rack::RouteExceptions
+    m.use Rack::ContentLength
+    m.use Rack::ConditionalGet
+    m.use Rack::ETag
+    m.use Rack::Head
+    m.use Ramaze::Reloader
+    m.run Ramaze::AppMap
+  end
+
+  middleware! :live do |m|
+    m.use Rack::CommonLogger, Ramaze::Log
+    m.use Rack::RouteExceptions
+    m.use Rack::ShowStatus
+    m.use Rack::ContentLength
+    m.use Rack::ConditionalGet
+    m.use Rack::ETag
+    m.use Rack::Head
+    m.run Ramaze::AppMap
+  end
+end

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.rb

@@ -0,0 +1,19 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'innate/cache'
+
+module Ramaze
+  Cache = Innate::Cache
+
+  class Cache
+    autoload :LocalMemCache, 'ramaze/cache/localmemcache'
+    autoload :MemCache,      'ramaze/cache/memcache'
+    autoload :Sequel,        'ramaze/cache/sequel'
+
+    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/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
+        @store.clear
+      end
+
+      def cache_delete(*args)
+        super{|key| @store.delete(key.to_s); 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(*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,124 @@
+#          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
+    #
+    # NOTE: There is a big issue with persisting sessions in memcache, not only
+    #       can they be dropped at any time, essentially logging the user out
+    #       without them noticing, but there is also a low limit to the maximum
+    #       time-to-live. After 30 days, your session will be dropped, no
+    #       matter what.
+    #       Please remember that memcache is, first of all, a cache, not a
+    #       persistence mechanism.
+    #
+    # NOTE: If you try to set a higher ttl than allowed, your stored key/value
+    #       will be expired immediately.
+    class MemCache
+      MAX_TTL = 2592000
+
+      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)
+        @warned = false
+      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); nil }
+      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
+
+        if ttl > MAX_TTL
+          unless @warned
+            Log.warn('MemCache cannot set a ttl greater than 2592000 seconds.')
+            Log.warn('Modify Ramaze.options.session.ttl to a value <= of that.')
+            @warned = true
+          end
+
+          ttl = MAX_TTL
+        end
+
+        @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