manveru-ramaze 2009.04.01 → 2009.04.08

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/controller/default.rb

@@ -3,5 +3,10 @@ module Ramaze
 
   class DefaultController < Ramaze::Controller
     map '/'
+
+    def lobster
+      require 'rack/lobster'
+      respond Rack::Lobster::LobsterString
+    end
   end
 end

data/lib/ramaze/helper.rb

@@ -1,22 +1,12 @@
 #          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
-    EXPOSE = LOOKUP = Innate::Helper::EXPOSE
-
-    def self.included(into)
-      into.extend(HelperAccess)
-      into.__send__(:include, Trinity)
-    end
+require 'innate/helper'
 
-    # assign some of the default helpers that have no overrides
-    Innate::HelpersHelper.each(:cgi, :aspect, :redirect, :send_file) do |mod|
-      Helper.const_set(mod.name.split('::').last, mod)
-    end
-  end
+module Ramaze
+  Helper = Innate::Helper
+  Innate::HelpersHelper.options.paths << File.dirname(__FILE__)
 
-  Innate::HelpersHelper.add_path(File.dirname(__FILE__))
-  Innate::HelpersHelper.add_path('')
-  Innate::HelpersHelper.add_pool(Ramaze::Helper)
+  require 'ramaze/helper/flash'
+  require 'ramaze/helper/link'
 end

data/lib/ramaze/helper/httpdigest.rb

@@ -83,7 +83,7 @@ module Ramaze
         httpdigest_failure unless nonce == session_nonce and opaque == session_opaque
 
         ha1 = httpdigest_lookup(username, realm, &block)
-        a2 = [request.request_method,request.fullpath]
+        a2 = [request.request_method,request.request_uri]
         a2 << Digest::MD5.hexdigest(request.body.read) if qop == "auth-int"
         ha2 = Digest::MD5.hexdigest( a2.join(':') )
         md5 = Digest::MD5.hexdigest([ha1, nonce, nc, cnonce, qop, ha2].join(':'))

data/lib/ramaze/helper/link.rb

@@ -5,13 +5,10 @@ require 'innate/helper/link'
 
 module Ramaze
   module Helper
+    # This is a modification of Innate::Helper::Link to respect the routing of
+    # Ramaze
     # NOTE: The A/R/Rs methods have been deprecated.
     module Link
-      include Innate::Helper::Link
-
-      def self.included(into)
-        into.extend(self)
-      end
 
       # @return [String]
       # @see Innate::Helper#anchor

data/lib/ramaze/helper/partial.rb

@@ -1,24 +1,99 @@
-require 'innate/helper/partial'
+#          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
+
+    # = Helper::Partial
+    #
+    # Please note that this helper is deprecated in favor of # Helper::Render,
+    # it has been removed from Innate and remains in Ramaze until 2009.05.
+    #
+    # === Example Usage
+    #
+    #   class MyController
+    #     def index
+    #     end
+    #
+    #     def list
+    #       plain = request['plain']
+    #       "Hello World from List!  Plain List == #{plain}"
+    #     end
+    #   end
+    #
+    #
+    #   <html>
+    #     <head><title>Partial Render Index</title></head>
+    #     <body>
+    #       #{render_partial(Rs(:list), 'plain' => true)}
+    #     </body>
+    #   </html>
     module Partial
-      include Innate::Helper::Partial
+      module_function
+
+      # Renders a url 'inline'.
+      #
+      # +url+      normal URL, like you'd use for redirecting.
+      # +options+  optional, will be used as request parameters.
+      #
+      # Issues a mock request to the given +url+ with +options+ turned into
+      # query arguments.
+      def render_partial(url, options = {})
+        Ramaze.deprecated('Helper::Partial#render_partial', 'Helper::Render#render_full')
+
+        uri = URI(url)
+        query = options # Innate::Current.request.params.merge(options)
+        uri.query = Rack::Utils.build_query(query)
+
+        body = nil
+
+        Innate::Mock.session do |session|
+          cookie = Innate::Current.session.cookie
+          session.cookie = cookie
+          body = session.get(uri.to_s, options).body
+        end
 
-      def self.included(into)
-        into.extend(self)
-        into.extend(Innate::Helper::Partial)
+        body
       end
 
-      def partial_content(name, variables = {})
-        action = resolve(name.to_s)
+      # Render the template file in view_root of the
+      # current controller.
+      #
+      # TODO:
+      # * Doesn't work for absolute paths, but there are no specs for that yet.
+      # * the local variable hack isn't working because innate allocates a new
+      #   binding.
+      #   For now one can simply use instance variables, which I prefer anyway.
+      #
+      # the local binding hack:
+      #
+      #   variables.each do |key, value|
+      #     value = "ObjectSpace._id2ref(#{value.object_id})"
+      #     eval "#{key} = #{value}", action.binding
+      #   end
 
-        action.layout = nil
+      def render_template(path, variables = {})
+        Ramaze.deprecated('Helper::Partial#render_template')
+        path = path.to_s
+
+        ext = File.extname(path)
+        basename = File.basename(path, ext)
+
+        action = Innate::Current.action.dup
+        action.layout    = nil
+        action.view      = action.node.find_view(basename, 'html')
+        action.method    = action.node.find_method(basename, action.params)
 
-        action.instance = action.node.new
         action.variables = action.variables.merge(variables)
+        action.sync_variables(action)
+
+        return action.call if action.valid?
+        raise(ArgumentError, "cannot render %p" % path)
+      end
 
-        action.render if action.valid?
+      def render_action(method, *params)
+        Ramaze.deprecated('Helper::Partial#render_action', 'Helper::Render#render_full')
+        render_partial(r(method), *params)
       end
     end
   end

data/lib/ramaze/request.rb

@@ -93,5 +93,25 @@ module Ramaze
       env.reject{|key, value| key.to_s !~ INTERESTING_HTTP_VARIABLES }
     end
     alias http_vars http_variables
+
+    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_variables }
+        group.each do |name, hash|
+          pp.breakable
+          pp.text " @#{name}="
+          pp.nest(name.size + 3){ pp.pp_hash(hash) }
+        end
+      }
+    end
   end
 end

data/lib/ramaze/snippets/ramaze/deprecated.rb

@@ -1,6 +1,5 @@
 module Ramaze
   DEPRECATED_CONSTANTS = {
-    :ThreadAccessor => :StateAccessor,
     :BASEDIR        => :ROOT,
     :Template       => :View,
     :Optional       => :Optioned,

data/lib/ramaze/spec.rb

@@ -25,3 +25,13 @@ module Ramaze
 
   middleware!(:spec){|m| m.run(AppMap) }
 end
+
+shared :rack_test do
+  require 'rack/test'
+
+  extend Rack::Test::Methods
+
+  def app
+    Ramaze.middleware(:spec)
+  end
+end

data/lib/ramaze/tool/create.rb

@@ -0,0 +1,48 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'ramaze/tool/project_creator'
+
+module Ramaze
+  module Tool
+
+    # Create is a simple class used to create new projects based on the proto
+    # directory.
+    #
+    # It is primarly used for this command:
+    #
+    #   ramaze --create project
+    #
+    # where project is the directory you want the content put into.
+
+    class Create
+
+      # Default options passed to Create::create
+      #   :proto  is the directory to duplicate
+      #   :amend  no files may be overwritten but missing files will be added
+      #   :force  will overwrite existing files
+      #   :layout copy one subdirectory in +proto+
+
+      DEFAULT = {
+        :proto => File.join(ROOT, 'proto'),
+        :amend => false,
+        :force => false,
+        :layout => '/',
+      }
+
+      # Using ProjectCreator to copy all files and directories from lib/proto
+      # to another location.
+      # +options+ are described in the DEFAULT constant and should be:
+      #   :force  => (true|false|nil)
+      #   :amend  => (true|false|nil)
+      #   :layout => (String|nil)
+      #   :proto  => String
+
+      def self.create(project, options = {})
+        options = DEFAULT.merge(options)
+        creator = ProjectCreator.new(project, options)
+        creator.create
+      end
+    end
+  end
+end

data/lib/ramaze/tool/project_creator.rb

@@ -0,0 +1,111 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+require 'fileutils'
+require 'find'
+
+class ProjectCreator
+  PROTO = []
+  PROTO << '~/.proto/' if ENV["HOME"] # Guard against Windows
+  attr_accessor :name, :options
+
+  def initialize(name, options = {})
+    @name, @options = name, options
+  end
+
+  def target
+    File.expand_path(name)
+  end
+
+  def proto
+    PROTO.map!{|pr| File.expand_path(pr) }
+    proto = options[:proto] ||= PROTO.find{|f| File.directory?(f) }
+    layout = options[:layout] ||= '/'
+    File.expand_path(File.join(proto, layout))
+  end
+
+  def create_root?
+    return true unless File.directory?(target)
+    return true if amend? or force?
+    fatal "%p is a directory, choose different project name or use --amend/--force" % target
+  end
+
+  def got_proto?
+    return true if File.directory?(proto)
+    fatal "Cannot create, %p doesn't exist, use --proto or create the proto directory" % proto
+  end
+
+  def create
+    got_proto?
+
+    puts "Found proto at: %p, proceeding...\n\n" % proto
+    mkdir(relate('/')) if create_root?
+    proceed
+  end
+
+  def proceed
+    files, directories = partition{|path| File.file?(path) }
+    proceed_directories(directories)
+    proceed_files(files)
+  end
+
+  def proceed_files(files)
+    files.each{|file| copy(file, relate(file)) }
+  end
+
+  def proceed_directories(dirs)
+    dirs.each{|dir| mkdir(relate(dir)) }
+  end
+
+  def mkdir(dir)
+    exists = File.directory?(dir)
+    return if exists and amend?
+    return if exists and not force?
+    puts "mkdir(%p)" % dir
+    FileUtils.mkdir_p(dir)
+  end
+
+  def copy(from, to)
+    return unless copy_check(to)
+    puts "copy(%p, %p)" % [from, to]
+    FileUtils.cp(from, to)
+    post_process(to)
+  end
+
+  def copy_check(to)
+    exists = File.file?(to)
+    return if exists and amend?
+    return if exists and not force?
+    return true
+  end
+
+  # Think about a useful way to process the generated files it should be
+  # possible to substitute some things like the project name in the
+  # configuration
+
+  def post_process(file)
+    return
+    source = File.read(file)
+    File.open(file, 'w+') do |io|
+      io.write(source.gsub('$project', "'#@name'"))
+    end
+  end
+
+  def relate(path)
+    File.join(target, path.to_s.sub(proto, ''))
+  end
+
+  def amend?; options[:amend] end
+  def force?; options[:force] end
+
+  def fatal(message)
+    warn message
+    exit 1
+  end
+
+  def each
+    Dir["#{proto}/**/*"].each{|path| yield(path) }
+  end
+
+  include Enumerable
+end