rjspotter-ramaze 2009.06.29

data/lib/ramaze/controller.rb

@@ -0,0 +1,104 @@
+#          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 Controller
+    include Innate::Traited
+    include Innate::Node
+
+    # we are no mapped node
+    Innate::Node::NODE_LIST.delete(self)
+
+    # call our setup method one startup
+    Ramaze.options.setup << self
+
+    CONTROLLER_LIST = Set.new
+
+    trait :app => :pristine
+    trait :skip_controller_map => false
+
+    def self.inherited(into)
+      Innate::Node.included(into)
+      into.helper(:layout)
+      CONTROLLER_LIST << into
+      into.trait :skip_node_map => true
+    end
+
+    def self.setup
+      case CONTROLLER_LIST.size
+      when 0
+        require 'ramaze/controller/default'
+      when 1
+        controller = CONTROLLER_LIST.to_a.first
+
+        begin
+          controller.mapping
+        rescue
+          controller.map '/'
+        end
+
+        controller.setup_procedure
+      else
+        CONTROLLER_LIST.each do |controller|
+          controller.setup_procedure
+        end
+      end
+    end
+
+    def self.setup_procedure
+      unless ancestral_trait[:provide_set]
+        engine(:Etanni)
+        trait(:provide_set => false)
+      end
+
+      return if trait[:skip_controller_map]
+
+      map(generate_mapping(name))
+    end
+
+    def self.engine(name)
+      provide(:html, name.to_sym)
+    end
+
+    def self.mapping
+      Ramaze.to(self)
+    end
+
+    IRREGULAR_MAPPING = {
+      'Controller' => nil,
+      'MainController' => '/'
+    }
+
+    def self.generate_mapping(klass_name = self.name)
+      chunks = klass_name.to_s.split(/::/)
+      return if chunks.empty?
+
+      last = chunks.last
+      return IRREGULAR_MAPPING[last] if IRREGULAR_MAPPING.key?(last)
+
+      last.sub!(/Controller$/, '')
+      '/' << chunks.map{|chunk| chunk.snake_case }.join('/')
+    end
+
+    def self.map(location, app_name = nil)
+      if app_name
+        trait :app => app_name
+      else
+        app_name = ancestral_trait[:app]
+      end
+
+      trait :skip_controller_map => true
+
+      App.find_or_create(app_name).map(location, self)
+    end
+
+    def self.app
+      App[ancestral_trait[:app]]
+    end
+
+    def self.options
+      return unless app = self.app
+      app.options
+    end
+  end
+end

data/lib/ramaze/controller/default.rb

@@ -0,0 +1,12 @@
+module Ramaze
+  Log.debug "Default controller invoked"
+
+  class DefaultController < Ramaze::Controller
+    map '/'
+
+    def lobster
+      require 'rack/lobster'
+      respond Rack::Lobster::LobsterString
+    end
+  end
+end

data/lib/ramaze/current.rb

@@ -0,0 +1,7 @@
+module Ramaze
+  class Current < Innate::Current
+    def setup(env, request = Request, response = Response, session = Session)
+      super
+    end
+  end
+end

data/lib/ramaze/files.rb

@@ -0,0 +1,24 @@
+module Ramaze
+  # Serving multiple public directories made easy.
+  class Files
+    def initialize(*roots)
+      @roots = roots.flatten.map{|root| File.expand_path(root.to_s) }
+      sync
+    end
+
+    def call(env)
+      @cascade.call(env)
+    end
+
+    def <<(path)
+      @roots << File.expand_path(path.to_s)
+      @roots.uniq!
+      sync
+    end
+
+    def sync
+      file_apps = @roots.map{|root| Rack::File.new(root) }
+      @cascade = Rack::Cascade.new(file_apps)
+    end
+  end
+end

data/lib/ramaze/gestalt.rb

@@ -0,0 +1,132 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+=begin rdoc
+Example:
+
+  require 'ramaze'
+  require 'ramaze/gestalt'
+
+  page = Ramaze::Gestalt.build{
+    title = 'Hello, World!'
+
+    html do
+      head{ title(title) }
+      body do
+        h1(title)
+        p 'I count to 10'
+        ('1'..'10').each do |count|
+          div(:style => 'width: 25px; height: 25px'){ count }
+        end
+      end
+    end
+  }
+=end
+
+module Ramaze
+
+  # Gestalt is the custom HTML/XML builder for Ramaze, based on a very simple
+  # DSL it will build your markup.
+
+  class Gestalt
+    attr_accessor :out
+
+    # The default way to start building your markup.
+    # Takes a block and returns the markup.
+    #
+    # Example:
+    #   html =
+    #     Gestalt.build do
+    #       html do
+    #         head do
+    #           title "Hello, World!"
+    #         end
+    #         body do
+    #           h1 "Hello, World!"
+    #         end
+    #       end
+    #     end
+    #
+
+    def self.build(&block)
+      self.new(&block).to_s
+    end
+
+    # Gestalt.new is like ::build but will return itself.
+    # you can either access #out or .to_s it, which will
+    # return the actual markup.
+    #
+    # Useful for distributed building of one page.
+
+    def initialize(&block)
+      @out = []
+      instance_eval(&block) if block_given?
+    end
+
+    # catching all the tags. passing it to _gestalt_build_tag
+
+    def method_missing(meth, *args, &block)
+      _gestalt_call_tag meth, args, &block
+    end
+
+    # workaround for Kernel#p to make <p /> tags possible.
+
+    def p(*args, &block)
+      _gestalt_call_tag :p, args, &block
+    end
+
+    # workaround for Kernel#select to make <select></select> work
+    def select(*args, &block)
+      _gestalt_call_tag(:select, args, &block)
+    end
+
+    def _gestalt_call_tag(name, args, &block)
+      if args.size == 1 and args[0].kind_of? Hash
+        # args are just attributes, children in block...
+        _gestalt_build_tag name, args[0], &block
+      elsif args[1].kind_of? Hash
+        # args are text and attributes ie. a('mylink', :href => '/mylink')
+        _gestalt_build_tag(name, args[1], args[0], &block)
+      else
+        # no attributes, but text
+        _gestalt_build_tag name, {}, args, &block
+      end
+    end
+
+    # build a tag for `name`, using `args` and an optional block that
+    # will be yielded
+
+    def _gestalt_build_tag(name, attr = {}, text = [])
+      @out << "<#{name}"
+      @out << attr.map{|(k,v)| %[ #{k}="#{_gestalt_escape_entities(v)}"] }.join
+      if text != [] or block_given?
+        @out << ">"
+        @out << _gestalt_escape_entities([text].join)
+        if block_given?
+          text = yield
+          @out << text.to_str if text != @out and text.respond_to?(:to_str)
+        end
+        @out << "</#{name}>"
+      else
+        @out << ' />'
+      end
+    end
+
+    def _gestalt_escape_entities(s)
+      s.to_s.gsub(/&/, '&amp;').
+        gsub(/"/, '&quot;').
+        gsub(/'/, '&apos;').
+        gsub(/</, '&lt;').
+        gsub(/>/, '&gt;')
+    end
+
+    def tag(name, *args, &block)
+      _gestalt_call_tag(name.to_s, args, &block)
+    end
+
+    def to_s
+      @out.join
+    end
+    alias to_str to_s
+  end
+end

data/lib/ramaze/helper.rb

@@ -0,0 +1,13 @@
+#          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/helper'
+
+module Ramaze
+  Helper = Innate::Helper
+  Innate::HelpersHelper.options.paths << File.dirname(__FILE__)
+
+  require 'ramaze/helper/flash'
+  require 'ramaze/helper/link'
+  require 'ramaze/helper/layout'
+end

data/lib/ramaze/helper/auth.rb

@@ -0,0 +1,84 @@
+#          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
+  module Helper
+
+    # A simple way to do authentication without a model.
+    # Please have a look at the docs of Auth#auth_login.
+    #
+    # If you want to do authentication with a model see Helper::User instead.
+    module Auth
+      Helper::LOOKUP << self
+      include Ramaze::Traited
+
+      trait :auth_table => {}
+      trait :auth_hashify => lambda{|pass| Digest::SHA1.hexdigest(pass) }
+      trait :auth_post_only => false
+
+      def self.included(into)
+        into.helper(:stack)
+      end
+
+      def login
+        return auth_template if trait[:auth_post_only] and !request.post?
+        @username, password = request[:username, :password]
+        answer(request.referer) if auth_login(@username, password)
+        return auth_template
+      end
+
+      def logout
+        auth_logout
+        answer(request.referer)
+      end
+
+      private
+
+      def login_required
+        call(r(:login)) unless logged_in?
+      end
+
+      # @return [true false] whether user is logged in right now
+      def logged_in?
+        !!session[:logged_in]
+      end
+
+      # @return
+      def auth_login(user, pass)
+        return unless user and pass
+        return if user.empty? or pass.empty?
+        return unless table = ancestral_trait[:auth_table]
+        return unless hashify = ancestral_trait[:auth_hashify]
+
+        if table.respond_to?(:to_sym) or table.respond_to?(:to_str)
+          table = send(table)
+        elsif table.respond_to?(:call)
+          table = table.call
+        end
+
+        return unless table[user] == hashify.call(pass)
+
+        session[:logged_in] = true
+        session[:username] = user
+      end
+
+      def auth_logout
+        session.delete(:logged_in)
+        session.delete(:username)
+      end
+
+      # @return [String] template for auth
+      def auth_template
+        <<-TEMPLATE.strip!
+<form method="post" action="#{r(:login)}">
+  <ul style="list-style:none;">
+    <li>Username: <input type="text" name="username" value="#@username"/></li>
+    <li>Password: <input type="password" name="password" /></li>
+    <li><input type="submit" /></li>
+  </ul>
+</form>
+        TEMPLATE
+      end
+    end
+  end
+end

data/lib/ramaze/helper/bench.rb

@@ -0,0 +1,41 @@
+require 'benchmark'
+
+module Ramaze
+  module Helper
+
+    # Little helper to give you a hand when benching parts of actions
+    module Bench
+
+      # Will first run an empty loop to determine the overhead it imposes, then
+      # goes on to yield your block +iterations+ times.
+      #
+      # The last yielded return value will be returned upon completion of the
+      # benchmark and the result of the benchmark itself will be sent to
+      # Log.info
+      #
+      # Example:
+      #
+      #   class MainController < Ramaze::Controller
+      #     def index
+      #       @users = bench{ User.all }
+      #       @tags = bench{ Article.tags }
+      #     end
+      #   end
+      #
+      # This will show something like following in your log:
+      # [..] INFO   Bench ./start.rb:3:in `index': 0.121163845062256
+      # [..] INFO   Bench ./start.rb:4:in `index': 2.234987235098341
+      #
+      # So now we know that the Article.tags call takes the most time and
+      # should be improved.
+      def bench(iterations = 1)
+        result = nil
+        from = caller[0]
+        delta = Benchmark.realtime{ iterations.times{ nil }}
+        taken = Benchmark.realtime{ iterations.times{ result = yield }}
+        Log.info "Bench #{from}: #{taken - delta}"
+        return result
+      end
+    end
+  end
+end

data/lib/ramaze/helper/cache.rb

@@ -0,0 +1,117 @@
+#          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
+  module Helper
+
+    # Caching of simple objects and whole action responses.
+    module Cache
+
+      # Setup needed traits, add the singleton methods and add the caches used
+      # by this helper.
+      #
+      # @param [Class] into Class that this Module is included into
+      # @author manveru
+      def self.included(into)
+        into.extend(SingletonMethods)
+        into.add_action_wrapper(6.0, :cache_wrap)
+        into.trait[:cache_action] ||= Set.new
+        Ramaze::Cache.add(:action, :cache_helper_value)
+      end
+
+      # @param [Action] action The currently wrapped action
+      # @yield The next block in wrap_action_call
+      # @return [String] the response body
+      # @see Innate::Node#wrap_action_call
+      # @author manveru
+      def cache_wrap(action)
+        cache = Innate::Cache.action
+
+        ancestral_trait[:cache_action].each do |cache_action|
+          temp  = cache_action.dup
+          block = temp.delete(:key)
+          ttl   = temp.delete(:ttl)
+
+          if temp.all?{|key, value| action[key] == value }
+            cache_key = action.full_path
+            cache_key << "_#{action.instance.instance_eval(&block).to_s}" if block
+
+            if cached = cache[cache_key]
+              action.options[:content_type] = cached[:type]
+            else
+              cached = {
+                :body => catch(:respond) { yield },
+                :type => response['Content-Type']
+              }
+
+              if ttl
+                cache.store(cache_key, cached, :ttl => ttl)
+              else
+                cache.store(cache_key, cached)
+              end
+            end
+
+            return cached[:body]
+          end
+        end
+
+        yield
+      end
+
+      # This method is used to access Ramaze::Cache.cache_helper_value.
+      # It provides an easy way to cache long-running computations, gathering
+      # external resources like RSS feeds or DB queries that are the same for
+      # every user of an application.
+      # This method changes behaviour if a block is passed, which can be used
+      # to do lazy computation of the cached value conveniently when using a
+      # custom TTL or longer expressions that don't fit on one line with ||=.
+      #
+      # @usage Example to get the cache object directly
+      #
+      #   count = cache_value[:count] ||= Article.count
+      #
+      # @usage Example with block
+      #
+      #   count = cache_value(:count){ Article.count }
+      #   count = cache_value(:count, :ttl => 60){ Article.count }
+      #
+      # @return [Object] The cache wrapper assigned for :cache_helper_value
+      # @see Innate::Cache
+      # @author manveru
+      def cache_value(key = nil, options = {})
+        cache = Ramaze::Cache.cache_helper_value
+
+        if key and block_given?
+          if found = cache[key]
+            found
+          else
+            cache.store(key, yield, options)
+          end
+        else
+          cache
+        end
+      end
+
+      module SingletonMethods
+        # This method allows you to cache whole actions.
+        #
+        # @example Basic usage
+        #
+        #   class Foo < Ramaze::Controller
+        #     helper :cache
+        #     cache_action :method => :bar
+        #
+        #     def bar
+        #       rand
+        #     end
+        #   end
+        #
+        def cache_action(hash, &block)
+          hash[:key] = block if block_given?
+          hash[:method] = hash[:method].to_s
+          trait[:cache_action] << hash
+        end
+      end
+    end
+  end
+end