ramaze 0.3.9.1 → 2023.01.06

data/lib/proto/view/index.xhtml

@@ -1,34 +1,45 @@
-<p>Ramaze is working correctly with this application, now you can start
-working.</p>
+<p>
+    Congratulations, Ramaze is running fine and you can start working on your application.
+</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>
+    You can play around with this prototype by changing the following:
 </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>
+    <li>
+        <code>view/index.xhtml</code>: the content of this page.
+    </li>
+    <li>
+        <code>layout/default.xhtml</code>: the layout for this page.
+    </li>
+    <li>
+        <code>controller/main.rb</code>: the controller responsible for server this page.
+    </li>
 </ul>
+
+<p>
+    For more information, check out <a href="http://ramaze.net">ramaze.net</a> and
+    <a href="http://ramaze.net/documentation/index.html">the documentation</a>.
+    <br />
+    You can also read the
+    <a href="http://doc.rubyists.com/ramaze%2binnate/">YARD documentation</a>
+    or browse around the <a href="https://github.com/ramaze/ramaze">Ramaze source code</a>.
 </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>
+    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&amp;channel=%23ramaze,%23ruby-lang&amp;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>.
 </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>
+    Feel free to post to the
+    <a href="https://groups.google.com/forum/#!forum/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,198 @@
+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
+
+  #:nodoc:
+  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 {Ramaze::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 {Ramaze::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 {Ramaze::Controller} belongs to a specific application,
+  # you can pass a second argument to {Ramaze::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
+
+    ##
+    # Finds or creates an application for the given name and URI.
+    #
+    # @author Michael Fellinger
+    # @param  [String] name The name of the application.
+    # @param  [String] location The URI to which the app is mapped.
+    # @return [Ramaze::App]
+    #
+    def self.find_or_create(name, location = nil)
+      location = '/' if location.nil? && name == :pristine
+      self[name] || new(name, location)
+    end
+
+    ##
+    # Returns the application for the given name.
+    #
+    # @author Michael Fellinger
+    # @param  [String] name The name of the application.
+    # @return [Ramaze::App]
+    #
+    def self.[](name)
+      APP_LIST[name.to_sym]
+    end
+
+    ##
+    # Creates a new instance of the application and sets the name and location.
+    #
+    # @author Michael Fellinger
+    # @since  30-06-2009
+    # @param  [String] name The name of the application.
+    # @param  [String] location The location to which the application is mapped.
+    #
+    def initialize(name, location = nil)
+      @name = name.to_sym
+      @url_map = Innate::URLMap.new
+      self.location = location if location
+
+      APP_LIST[@name] = self
+
+      @options = self.class.options.sub(@name)
+    end
+
+    ##
+    # Syncs the instance of the current application with Ramaze::AppMap.
+    #
+    # @author Michael Fellinger
+    # @since  30-06-2009
+    #
+    def sync
+      AppMap.map(location, self)
+    end
+
+    ##
+    # Sets the location and syncs the application.
+    #
+    # @author Michael Fellinger
+    # @since  30-06-2009
+    #
+    def location=(location)
+      @location = location.to_str.freeze
+      sync
+    end
+
+    ##
+    # Allows the application to be called as a Rack middleware.
+    #
+    # @author Michael Fellinger
+    # @since  30-06-2009
+    # @param  [Hash] env The environment hash.
+    #
+    def call(env)
+      to_app.call(env)
+    end
+
+    ##
+    # Converts the application to a Rack compatible class.
+    #
+    # @author Michael Fellinger
+    # @since  30-06-2009
+    # @return [Rack::Cascade]
+    #
+    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
+
+    ##
+    # Maps an object to the given URI.
+    #
+    # @author Michael Fellinger
+    # @since  30-06-2009
+    # @param  [String] location The URI to map the object to.
+    # @param  [Object] object The object (usually a controller) to map to the
+    #  URI.
+    #
+    def map(location, object)
+      url_map.map(location, object)
+    end
+
+    ##
+    # Returns a URI to the given object.
+    #
+    # @author Michael Fellinger
+    # @since  30-06-2009
+    # @param  [Object] object An object for which to generate the URI.
+    #
+    def to(object)
+      return unless mapped = url_map.to(object)
+      [location, mapped].join('/').squeeze('/')
+    end
+
+    ##
+    # Returns an array containing all the public directories for each root
+    # directory.
+    #
+    # @author Michael Fellinger
+    # @since  30-06-2009
+    # @return [Array]
+    #
+    def public_roots
+      roots, publics = [*options.roots], [*options.publics]
+      roots.map{|root| publics.map{|public| ::File.join(root, public) }}.flatten
+    end
+  end # App
+end # Ramaze

data/lib/ramaze/bin/create.rb

@@ -0,0 +1,92 @@
+require 'fileutils'
+
+module Ramaze
+  #:nodoc:
+  module Bin
+    ##
+    # Simple command that allows users to easily create a new application based
+    # on the prototype that ships with Ramaze.
+    #
+    # Usage:
+    #
+    #    ramaze create blog
+    #
+    # @author Yorick Peterse
+    # @since  21-07-2011
+    #
+    class Create
+      Description = 'Creates a new Ramaze application'
+
+      Banner = <<-TXT.strip
+Allows developers to easily create new Ramaze applications based on the
+prototype that ships with Ramaze.
+
+Usage:
+  ramaze create [NAME] [OPTIONS]
+
+Example:
+  ramaze create blog
+      TXT
+
+      ##
+      # Creates a new instance of the command and sets the options for
+      # OptionParser.
+      #
+      # @author Yorick Peterse
+      # @since  21-07-2011
+      #
+      def initialize
+        @options = {
+          :force => false
+        }
+
+        @opts = OptionParser.new do |opt|
+          opt.banner         = Banner
+          opt.summary_indent = '  '
+
+          opt.separator "\nOptions:\n"
+
+          opt.on('-f', '--force', 'Overwrites existing directories') do
+            @options[:force] = true
+          end
+
+          opt.on('-h', '--help', 'Shows this help message') do
+            puts @opts
+            exit
+          end
+        end
+      end
+
+      ##
+      # Runs the command based on the specified command line arguments.
+      #
+      # @author Yorick Peterse
+      # @since  21-07-2011
+      # @param  [Array] argv Array containing all command line arguments.
+      #
+      def run(argv = [])
+        @opts.parse!(argv)
+
+        path  = argv.delete_at(0)
+        proto = __DIR__('../../proto')
+
+        abort 'You need to specify a name for your application' if path.nil?
+
+        if File.directory?(path) and @options[:force] === false
+          abort 'The specified application already exists, use -f to overwrite it'
+        end
+
+        if File.directory?(path) and @options[:force] === true
+          FileUtils.rm_rf(path)
+        end
+
+        begin
+          FileUtils.cp_r(proto, path)
+          puts "The application has been generated and saved in #{path}"
+        rescue
+          abort 'The application could not be generated'
+        end
+      end
+    end # Create
+  end # Bin
+end # Ramaze

data/lib/ramaze/bin/runner.rb

@@ -0,0 +1,127 @@
+require 'optparse'
+require 'pathname'
+
+require __DIR__('create')
+
+module Ramaze
+  #:nodoc:
+  module Bin
+    ##
+    # Module used for running a particular command based on the specified
+    # command line arguments.
+    #
+    # Usage:
+    #
+    #    ramaze --help # Shows a help message
+    #    ramaze -h     # Shows a help message as well
+    #    ramaze -v     # Shows the version of Ramaze
+    #
+    #    ramaze [COMMAND] # Runs [COMMAND]
+    #
+    # @author Yorick Peterse
+    # @since  21-07-2011
+    #
+    module Runner
+      Commands = {
+        :create  => Ramaze::Bin::Create,
+      }
+
+      Banner = <<-TXT.strip
+Ramaze is a simple, light and modular open-source web application
+framework written in Ruby.
+
+Usage:
+  ramaze [COMMAND] [OPTIONS]
+
+Example:
+  ramaze create blog
+      TXT
+
+      ##
+      # Runs a particular command based on the specified array.
+      #
+      # @example
+      #  Ramaze::Bin::Runner.run(ARGV)
+      #  Ramaze::Bin::Runner.run(['start', '--help'])
+      #
+      # @author Yorick Peterse
+      # @since  21-07-2011
+      # @param  [Array] argv An array containing command line arguments, set to
+      #  ARGV by default.
+      #
+      def self.run(argv=ARGV)
+        op = OptionParser.new do |opt|
+          opt.banner         = Banner
+          opt.summary_indent = '  '
+
+          opt.separator "\nCommands:\n  #{commands_info.join("\n  ")}"
+
+          # Show all the common options
+          opt.separator "\nOptions:\n"
+
+          # Show the version of Ramaze
+          opt.on('-v', '--version', 'Shows the version of Ramaze') do
+            puts Ramaze::VERSION
+            exit
+          end
+
+          opt.on('-h', '--help', 'Shows this help message') do
+            puts op
+            exit
+          end
+        end
+
+        op.order!(argv)
+
+        # Show a help message if no command has been specified
+        if !argv[0]
+          puts op.to_s
+          exit
+        end
+
+        cmd = argv.delete_at(0).to_sym
+
+        if Commands.key?(cmd)
+          cmd = Commands[cmd].new
+          cmd.run(argv)
+        else
+          abort 'The specified command is invalid'
+        end
+      end
+
+      ##
+      # Generates an array of "rows" where each row contains the name and
+      # description of a command. The descriptions of all commands are aligned
+      # based on the length of the longest command name.
+      #
+      # @author Yorick Peterse
+      # @since  21-07-2011
+      # @return [Array]
+      #
+      def self.commands_info
+        cmds    = []
+        longest = Commands.map { |name, klass| name.to_s }.sort[0].size
+
+        Commands.each do |name, klass|
+          name = name.to_s
+          desc = ''
+
+          # Try to extract the command description
+          if klass.respond_to?(:const_defined?) \
+          and klass.const_defined?(:Description)
+            desc = klass.const_get(:Description)
+          end
+
+          # Align the description based on the length of the name
+          while name.size <= longest do
+            name += ' '
+          end
+
+          cmds.push(["#{name}    #{desc}"])
+        end
+
+        return cmds
+      end
+    end # Runner
+  end # Bin
+end # Ramaze

data/lib/ramaze/cache/lru.rb

@@ -0,0 +1,88 @@
+#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the MIT license.
+
+module Ramaze
+  class Cache
+    ##
+    # Cache class that uses {Ramaze::LRUHash} as a storage engine. This cache
+    # has the advantage that unlike Innate::Cache::Memory it does not leak
+    # memory over time when using the cache for sessions.
+    #
+    # @example
+    #  Ramaze::Cache.options.session = Ramaze::Cache::LRU
+    #  Ramaze.setup_dependencies
+    #
+    # @author Michael Fellinger
+    # @since  17-07-2009
+    #
+    class LRU
+      include Cache::API
+
+      # Hash containing all the options for the cache.
+      OPTIONS = {
+        # expiration in seconds
+        :expiration => nil,
+        # maximum elements in the cache
+        :max_count => 10000,
+        # maximum total memory usage of the cache
+        :max_total => nil,
+        # maximum memory usage of an element of the cache
+        :max_value => nil,
+      }
+
+      ##
+      # Prepares the cache by creating a new instance of Ramaze::LRUHash using
+      # the options set in {Ramaze::Cache::LRU::OPTIONS}.
+      #
+      # @author Michael Fellinger
+      # @since  17-07-2009
+      #
+      def cache_setup(host, user, app, name)
+        @store = Ramaze::LRUHash.new(OPTIONS)
+      end
+
+      ##
+      # Clears the entire cache.
+      #
+      # @author Michael Fellinger
+      # @since  17-07-2009
+      #
+      def cache_clear
+        @store.clear
+      end
+
+      ##
+      # Stores a set of data in the cache.
+      #
+      # @author Michael Fellinger
+      # @since  17-07-2009
+      # @see    Innate::Cache::API#cache_store
+      #
+      def cache_store(*args)
+        super { |key, value| @store[key] = value }
+      end
+
+      ##
+      # Retrieves a set of data from the cache.
+      #
+      # @author Michael Fellinger
+      # @since  17-07-2009
+      # @see    Innate::Cache::API#cache_fetch
+      #
+      def cache_fetch(*args)
+        super { |key| @store[key] }
+      end
+
+      ##
+      # Deletes a set of data from the cache
+      #
+      # @author Michael Fellinger
+      # @since  17-07-2009
+      # @see    Innate::Cache::API#cache_delete
+      #
+      def cache_delete(*args)
+        super { |key| @store.delete(key) }
+      end
+    end # LRU
+  end # Cache
+end # Ramaze