ramaze 0.3.9.1 → 2008.06

data/lib/ramaze/option/dsl.rb

@@ -0,0 +1,45 @@
+#          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
+# All files in this distribution are subject to the terms of the Ruby license.
+
+module Ramaze
+  module Option
+    class DSL
+      attr_reader :holder
+
+      def initialize(holder, &block)
+        @holder = holder
+        @config = {}
+        instance_eval(&block) if block_given?
+      end
+
+      def o(doc, key, value, options = {})
+        @config[key] = [doc, value, options]
+
+        holder.add_option(key, value, complain = false)
+        holder.trait[key] = options.merge(:doc => doc)
+      end
+
+      # to generate a new sorted source file from the config, was only used to
+      # merge new and old DSL.
+      def output
+        @config.keys.sort_by{|k,v| k.to_s }.each do |key|
+          doc, value, options = @config[key]
+          puts "o %s," % doc.dump
+
+          if options.empty?
+            puts "  %p, %p" % [key, value]
+          else
+            format = options.map{|(k,v)| '%p => %p' % [k,v]}.join(', ')
+            puts "  %p, %p, %s" % [key, value, format]
+          end
+
+          puts
+        end
+      end
+    end
+
+    def self.dsl(&block)
+      Option::DSL.new(&block)
+    end
+  end
+end

data/lib/ramaze/option/holder.rb

@@ -0,0 +1,153 @@
+#          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/option/merger'
+
+module Ramaze
+  module Option
+    class Holder
+      include Merger
+
+      def initialize(options = {})
+        @members = Set.new
+
+        options.each do |key, value|
+          add_option(key, value, complain = false)
+        end
+      end
+
+      def add_option(key, value, complain = true)
+        Log.warn("Adding #{key} to #{self}") if complain
+
+        self.class.class_eval do
+          attr_reader key unless method_defined?(key)
+          attr_writer key unless method_defined?("#{key}=")
+        end
+
+        self[key] = value
+      end
+
+      def [](key)
+        __send__(key)
+      end
+
+      def []=(key, value)
+        @members << key.to_s.to_sym
+        __send__("#{key}=", value)
+      end
+
+      include Enumerable
+
+      def each
+        @members.each do |member|
+          yield member, self[member]
+        end
+      end
+
+      def startup(options)
+        options.each do |key, value|
+          self[key] = value
+        end
+
+        merge!(ARGV)
+        merge!(ENV)
+
+        self.root ||= File.dirname(File.expand_path(runner))
+        [self.load_engines].flatten.compact.each do |engine|
+          Ramaze::Template.const_get(engine)
+        end
+      end
+
+      # batch-assignment of key/value from hash, yields self if a block is given.
+      def setup(hash = {})
+        merge!(hash)
+        yield(self) if block_given?
+      end
+
+      # Modified options
+
+      def port=(number)
+        @port = number.to_i
+      end
+
+      def public_root=(pr)
+        @public_root = pr
+      end
+
+      # Find a suitable public_root, if none of these is a directory just use the
+      # currently set one.
+      def public_root
+        [ @public_root,
+          root/@public_root
+        ].find{|path| File.directory?(path) } || @public_root
+      end
+
+      def view_root=(vr)
+        @view_root = vr
+      end
+
+      # Find a suitable view_root, if none of these is a directory just use
+      # the currently set one.
+      def view_root
+        [ @view_root,
+          root/@view_root,
+          root/'template',
+        ].find{|path| File.directory?(path) } || @view_root
+      end
+
+      def template_root=(tr)
+        Ramaze::deprecated "Global.template_root=", "Global.view_root="
+        self.view_root = tr
+      end
+
+      def template_root
+        Ramaze::deprecated "Global.template_root", "Global.view_root"
+        self.view_root
+      end
+
+      def adapter
+        find_from_aliases(@adapter, :adapter_aliases, Ramaze::Adapter, "ramaze/adapter")
+      end
+
+      def cache
+        find_from_aliases(@cache, :cache_aliases, Ramaze, "ramaze/cache")
+      end
+
+      def sourcereload=(interval)
+        if interval
+          if interval.is_a?(Numeric)
+            @sourcereload = interval
+            Ramaze::SourceReload.restart
+          else
+            Log.warn("sourcereload= %p not Numeric, ignoring." % interval)
+          end
+        else
+          @sourcereload = interval
+          Ramaze::SourceReload.shutdown
+        end
+      end
+
+      private
+
+      def find_from_aliases(name, alias_key, mod, path)
+        case name
+        when String, Symbol
+          name = name.to_s
+          name = self[alias_key][name] || name
+          find_require(name, mod, path)
+        else
+          name
+        end
+      end
+
+      def find_require(name, mod, path)
+        class_name = name.to_s
+        file_path = File.join(path, class_name.downcase)
+
+        require(file_path) unless mod.const_defined?(class_name)
+
+        mod.const_get(class_name)
+      end
+    end
+  end
+end

data/lib/ramaze/option/merger.rb

@@ -0,0 +1,108 @@
+module Ramaze
+  module Option
+    module Merger
+
+      # Pass it anything that may work as option: ENV, hashes, ARGV...
+      # it will figure out how to get config from it and modify Global.
+      def merge!(obj, &block)
+        case obj
+        when ENV
+          merge_prefixed!(obj)
+        else
+          if obj.respond_to?(:each_pair)
+            obj.each_pair do |key, value|
+              self[key] = value
+            end
+          elsif obj.respond_to?(:each)
+            merge_cli!(obj, &block)
+          end
+        end
+
+        self
+      end
+
+      # Prefixed options, mostly useful for filtering out from ENV.
+      # by default the prefix is case-insensitive and set to ramaze_ - that
+      # works for keys like:
+      #     $ RAMAZE_PORT=80 ruby start.rb
+      #     $ ramaze_port=80 ruby start.rb
+      #     $ Ramaze_Port=80 ruby start.rb
+      def merge_prefixed!(obj, prefix = 'ramaze_')
+        opts = {}
+        obj.each do |key, value|
+          next unless key =~ /^#{prefix}(.*)/i
+          opts[$1.downcase] = value
+        end
+        merge! opts
+      end
+
+      # Only destructive for now, should non-destructive keep both Global and
+      # the obj original?
+
+      def merge_cli!(obj, &block)
+        option_parser(&block).parse!(obj)
+      end
+
+      def option_parser(bin = 'ramaze')
+        require 'optparse'
+        require 'abbrev'
+
+        OptionParser.new{|opt|
+          ruby_version = "ruby #{RUBY_VERSION} (#{RUBY_RELEASE_DATE}) [#{RUBY_PLATFORM}]"
+          ramaze_version = "Ramaze Version #{VERSION}"
+          version = "#{ramaze_version}, on #{ruby_version}"
+
+          opt.banner = "Usage: #{bin} start.rb [OPTIONS]"
+          opt.define_head version
+
+          yield(opt) if block_given?
+
+          opt.separator ''
+          opt.separator 'Global options, value in [] shows default.'
+
+          Global.each do |key, value|
+            long_option = "--#{key}"
+            options = Global.trait.fetch(key, {})
+            doc, cli, short = options.values_at(:doc, :cli, :short)
+            short_option = "-#{short}" if short
+
+            next unless cli or short
+
+            case cli || value
+            when Integer
+              option = [short_option, "#{long_option} NUM", Integer, doc]
+            when String, Symbol
+              option = [short_option, "#{long_option} STRING", String, doc]
+            when Array
+              next unless cli
+              cli = cli.map{|c| c.to_s }
+              list = "  " << cli.join(', ')
+              doc = "[#{value}] #{doc}"
+              aliases = cli.abbrev
+              option = [short_option, "#{long_option} CHOICE", cli, doc, list]
+            else
+              option = [short_option, long_option, doc]
+            end
+
+            option.delete(nil)
+
+            opt.on(*option){|o| Ramaze::Global[key] = o }
+          end
+
+          opt.separator ''
+          opt.separator 'Common options:'
+
+          opt.on('-h', '--help', 'Show this message') do
+            puts opt
+            exit
+          end
+
+          opt.on('-v', '--version', "Show version") do
+            puts version
+            exit
+          end
+        }
+      end
+    end
+  end
+end

data/lib/ramaze/route.rb

@@ -41,18 +41,22 @@ module Ramaze
     trait[:routes] ||= Dictionary.new
 
     class << self
+      # Retrieve key from trait
       def [](key)
         trait[:routes][key]
       end
 
+      # Set key to value in trait
       def []=(key, value)
         trait[:routes][key] = value
       end
 
+      # remove all routes
       def clear
         trait[:routes].clear
       end
 
+      # Resolve path according to routes.
       def resolve(path)
         trait[:routes].each do |key, val|
           if key.is_a?(Regexp)
@@ -78,7 +82,16 @@ module Ramaze
     end
   end
 
-  def self.Route(name, &block)
-    Route[name] = block
+  class Rewrite < Route
+    trait[:routes] ||= Dictionary.new
+  end
+
+  # Shortcut for defining new routes.
+  def self.Route(name, value = nil, &block)
+    Route[name] = value || block
+  end
+
+  def self.Rewrite(name, value = nil, &block)
+    Rewrite[name] = value || block
   end
 end

data/lib/ramaze/setup.rb

@@ -0,0 +1,50 @@
+module Ramaze
+  def self.setup(start = true, &block)
+    SetupEnvironment.new(&block) if block_given?
+    self.start if start
+  end
+
+  class SetupEnvironment
+    # FIXME:
+    # * This is weird, class scope includes Global, yet it's skipped
+    #   by Ruby on the lookup only because it's not in the scope of the block
+    #   at the point of creation, shouldn't instance_eval take the binding of
+    #   the SetupEnvironment instance in acocunt?
+
+    def initialize(&block)
+      instance_eval(&block)
+    end
+
+    # Shortcut for Ramaze::Gems::gem
+    def gem(*args)
+      require 'ramaze/contrib/gems'
+      Ramaze::Gems::gem(*args)
+      Ramaze::Gems::setup
+    end
+
+    # Shortcut if you don't need specific versions but tons of gems
+    def gems(*args)
+      gems.each{|g| gem(g) }
+    end
+
+    def global(hash = nil)
+      if hash
+        Global.merge!(hash)
+      else
+        Global
+      end
+    end
+    alias option global
+  end
+end
+
+__END__
+Usage example:
+
+Ramaze.setup do
+  gem 'json'
+
+  option :middleware => true
+  global.adapter = :thin
+  option.port = 7000
+end

data/lib/ramaze/snippets/binding/locals.rb

@@ -5,7 +5,7 @@ class Binding
   # hash
   #   usage: x = 42; p binding.locals #=> {'x'=> 42}
   def locals
-    eval '
+    Kernel::eval '
       local_variables.inject({}){|h,v| h.update v => eval(v)}
     ', self
   end

data/lib/ramaze/snippets/dictionary.rb

@@ -290,11 +290,11 @@ module Ramaze
     end
 
     def reject( &block )
-      self.dup.delete_if &block
+      self.dup.delete_if(&block)
     end
 
     def reject!( &block )
-      hsh2 = reject &block
+      hsh2 = reject(&block)
       self == hsh2 ? nil : hsh2
     end
 
@@ -319,7 +319,7 @@ module Ramaze
     end
 
     def <<(kv)
-      push *kv
+      push(*kv)
     end
 
     def push( k,v )

data/lib/ramaze/snippets/divide.rb

@@ -1,20 +1,20 @@
 #          Copyright (c) 2008 Michael Fellinger m.fellinger@gmail.com
 # All files in this distribution are subject to the terms of the Ruby license.
 
-# A convenient way to do File.join
-#
-# Example:
-#   'a' / 'b'                      # -> 'a/b'
-#   File.dirname(__FILE__) / 'bar' # -> "ramaze/snippets/string/bar"
-
 class String
+  # A convenient way to do File.join
+  # Usage:
+  #   'a' / 'b' # => 'a/b'
   def / obj
     File.join(self, obj.to_s)
   end
 end
 
 class Symbol
+  # A convenient way to do File.join
+  # Usage:
+  #   :dir/:file # => 'dir/file'
   def / obj
     self.to_s / obj
   end
-end
+end