manveru-ramaze 2008.09 → 2008.10

data/lib/ramaze/snippets/divide.rb

@@ -6,6 +6,7 @@ class String
   # Usage:
   #   'a' / 'b' # => 'a/b'
   def / obj
+    Ramaze.deprecated('String#/', 'File::join')
     File.join(self, obj.to_s)
   end
 end
@@ -15,6 +16,7 @@ class Symbol
   # Usage:
   #   :dir/:file # => 'dir/file'
   def / obj
+    Ramaze.deprecated('Symbol#/', 'File::join(sym.to_s)')
     self.to_s / obj
   end
 end

data/lib/ramaze/snippets/numeric/time.rb

@@ -41,7 +41,7 @@ module Ramaze
 
       # 365.25 days in a year
       def years
-        self * 883612800
+        self * 31557600
       end
       alias year years
 

data/lib/ramaze/snippets/object/acquire.rb

@@ -27,12 +27,9 @@ module Ramaze
       #   # require 'src/foo.rb' and 'src/bar.so' and 'src/foobar/baz.rb'
       #   acquire 'src/*', 'src/foobar/*'
 
-      def acquire *globs
-        globs.flatten.each do |glob|
-          Dir[glob].each do |file|
-            require file if file =~ /\.(rb|so)$/
-          end
-        end
+      def acquire(*globs)
+        Ramaze.deprecated('Object#acquire', 'Ramaze::acquire')
+        Ramaze.acquire(*globs)
       end
     end
 

data/lib/ramaze/snippets/ordered_set.rb

@@ -22,23 +22,30 @@ class OrderedSet < BlankSlate
     @set.uniq!
   end
 
+  %w[ push unshift << ].each do |meth|
+    class_eval %[
+      def #{meth} *args
+        @set.delete(*args)
+        @set.#{meth}(*args)
+      end
+    ]
+  end
+
+  def []= *args
+    @set.map! do |e|
+      if ::Array === args.last
+        args.last.include?(e) ? nil : e
+      else
+        args.last == e ? nil : e
+      end
+    end
+    @set.__send__(:[]=, *args)
+    @set.compact!
+  end
+
   # Delegate everything, but controlled, keep elements unique.
   # Warning, this is not really atomic.
   def method_missing(meth, *args, &block)
-    case meth.to_s
-    when /push|unshift|\<\</
-      @set.delete(*args)
-    when '[]='
-      @set.map! do |e|
-        if ::Array === args.last
-          args.last.include?(e) ? nil : e
-        else
-          args.last == e ? nil : e
-        end
-      end
-    end
     @set.__send__(meth, *args, &block)
-  ensure
-    @set.compact! if meth == :[]=
   end
 end

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

@@ -6,7 +6,8 @@ module Ramaze
   def self.deprecated(from, to = nil)
     message = "%s is deprecated"
     message << ", use %s instead" unless to.nil?
-    Log.warn(message % [from, to])
+    message << " - from: %p"
+    Log.warn(message % [from, to, caller[1]])
   end
 
   def self.const_missing(name)

data/lib/ramaze/tool/localize.rb

@@ -63,10 +63,14 @@ module Ramaze
 
         def call(response, options = {})
           return response unless trait[:enable]
-          return response if response.body.nil?
-          return response if response.body.respond_to?(:read)
-          response.body = localize_body(response.body, options)
-          response
+
+          body = []
+
+          response.body.each do |chunk|
+            body << localize_body(chunk, options)
+          end
+
+          response.body = body
         end
 
         # Localizes a response body.  It reacts to a regular expression as given

data/lib/ramaze/tool/mime.rb

@@ -9,7 +9,7 @@ module Ramaze
     module MIME
 
       # the mime_types.yaml as full path, we use a copy of mongrels.
-      trait :types => YAML.load_file(BASEDIR/'ramaze'/'tool'/'mime_types.yaml')
+      trait :types => YAML.load_file(File.join(BASEDIR, 'ramaze/tool/mime_types.yaml'))
 
       class << self
 

data/lib/ramaze/tool/project_creator.rb

@@ -5,7 +5,8 @@ require 'fileutils'
 require 'find'
 
 class ProjectCreator
-  PROTO = ['~/.proto/']
+  PROTO = []
+  PROTO << '~/.proto/' if ENV["HOME"] # Guard against Windows
   attr_accessor :name, :options
 
   def initialize(name, options = {})

data/lib/ramaze/version.rb

@@ -2,5 +2,5 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 module Ramaze
-  VERSION = "2008.09"
+  VERSION = "2008.10"
 end

data/lib/ramaze.rb

@@ -79,6 +79,8 @@ module Ramaze
     # each class in trait[:essentials] by calling ::startup on them.
 
     def startup options = {}
+      options = options.to_hash
+
       force = options.delete(:force)
       force ||= !trait[:started]
 

data/rake_tasks/coverage.rake

@@ -2,7 +2,6 @@
 # All files in this distribution are subject to the terms of the Ruby license.
 
 require 'rake'
-require 'lib/ramaze/snippets/divide'
 
 spec_base = File.expand_path('spec/ramaze/')
 example_base = File.expand_path('examples')
@@ -10,10 +9,10 @@ snippets_base = File.expand_path('spec/snippets')
 # ignore files with these paths
 ignores = [ './*', './helper/*', './ramaze/adapter.rb', './ramaze/request.rb', ]
 
-files = Dir[spec_base/'**'/'*.rb'] +
-        Dir[example_base/'**/spec'/'*.rb']
+files = Dir["#{spec_base}/**/*.rb"] +
+        Dir["#{example_base}/**/spec/*.rb"]
 ignores.each do |ignore|
-  ignore_files = Dir[spec_base/ignore]
+  ignore_files = Dir["#{spec_base}/#{ignore}"]
   ignore_files.each do |ignore_file|
     files.delete File.expand_path(ignore_file)
   end
@@ -35,7 +34,7 @@ task :coverage => :clean do
   # IMHO, ideally we should have
   # * 100% coverage of ramaze with pure tests
   # * 100% coverage with non-pure functional tests
-  pure_specs =  Dir[snippets_base/'**/*.rb'].entries
+  pure_specs =  Dir["#{snippets_base}/**/*.rb"].entries
   sys(COV_CMD % ["no-","t", pure_specs.join(' ')])
 
   files.each do |file|

data/rake_tasks/spec.rake

@@ -11,18 +11,18 @@ task 'spec' do
   non_verbose, non_fatal = ENV['non_verbose'], ENV['non_fatal']
   require 'scanf'
 
-  root = File.expand_path(File.dirname(__FILE__)/'..')
-  libpath = root/'lib'
+  root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+  libpath = "#{root}/lib"
 
-  specs = Dir[root/'spec/{ramaze,examples,snippets,contrib}/**/*.rb'] +
-    Dir[root/'examples/**/spec/**/*.rb']
+  specs = Dir["#{root}/spec/{ramaze,examples,snippets,contrib}/**/*.rb"] +
+    Dir["#{root}/examples/**/spec/**/*.rb"]
 
   ignore = [
-    root/'spec/ramaze/request.rb',
+    "#{root}/spec/ramaze/request.rb",
   ].map{|i| Dir[i].map{|f| File.expand_path(f) }}.flatten
 
   config = RbConfig::CONFIG
-  bin = config['bindir']/config['ruby_install_name']
+  bin = File.join(config['bindir'], config['ruby_install_name'])
 
   result_format = '%d tests, %d assertions, %d failures, %d errors'
 

data/ramaze.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "ramaze"
-  s.version = "2008.09"
+  s.version = "2008.10"
 
   s.summary = "Ramaze is a simple and modular web framework"
   s.description = "Ramaze is a simple and modular web framework"
@@ -429,6 +429,7 @@ Gem::Specification.new do |s|
  "lib/ramaze/log/knotify.rb",
  "lib/ramaze/log/logger.rb",
  "lib/ramaze/log/logging.rb",
+ "lib/ramaze/log/rotatinginformer.rb",
  "lib/ramaze/log/syslog.rb",
  "lib/ramaze/log/xosd.rb",
  "lib/ramaze/option",

data/spec/contrib/profiling.rb

@@ -15,14 +15,14 @@ Ramaze::Log.loggers << Ramaze::Logger::Informer.new(output)
 
 describe 'Profiling' do
   behaves_like "http"
-  ramaze :public_root => __DIR__/:public
+  ramaze :public_root => File.join(__DIR__, 'public')
 
   it "should profile" do
     output = StringIO.new
     Ramaze::Log.loggers << Ramaze::Logger::Informer.new(output)
 
     get('/')
-    output.string.should =~ /Thread ID:\s\d+/
+    output.string.should =~ /Thread ID:\s-?\d+/
     output.string.should =~ /Total:/
     output.string.should =~ /self\s+total\s+self\s+wait\s+child\s+call/
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: manveru-ramaze
 version: !ruby/object:Gem::Version 
-  version: "2008.09"
+  version: "2008.10"
 platform: ruby
 authors: 
 - Michael 'manveru' Fellinger
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-08-13 00:00:00 -07:00
+date: 2008-12-15 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -443,6 +443,7 @@ files:
 - lib/ramaze/log/knotify.rb
 - lib/ramaze/log/logger.rb
 - lib/ramaze/log/logging.rb
+- lib/ramaze/log/rotatinginformer.rb
 - lib/ramaze/log/syslog.rb
 - lib/ramaze/log/xosd.rb
 - lib/ramaze/option

data/lib/ramaze/contrib/auto_params/get_args.rb

@@ -1,58 +0,0 @@
-# from merb/core_ext/get_args.rb
-begin
-  require 'parse_tree'
-  require 'ruby2ruby'
-
-  class ParseTreeArray < Array
-    def self.translate(*args)
-      self.new(ParseTree.translate(*args))
-    end
-
-    def deep_array_node(type = nil)
-      each do |node|
-        return ParseTreeArray.new(node) if node.is_a?(Array) && (!type || node[0] == type)
-        next unless node.is_a?(Array)
-        return ParseTreeArray.new(node).deep_array_node(type)
-      end
-      nil
-    end
-
-    def arg_nodes
-      self[1..-1].inject([]) do |sum,item|
-        sum << [item] unless item.is_a?(Array)
-        sum
-      end
-    end
-
-    def get_args
-      arg_node = deep_array_node(:args)
-      return nil unless arg_node
-      args = arg_node.arg_nodes
-      default_node = arg_node.deep_array_node(:block)
-      return args unless default_node
-      lasgns = default_node[1..-1]
-      lasgns.each do |asgn|
-        args.assoc(asgn[1]) << eval(RubyToRuby.new.process(asgn[2]))
-      end
-      args
-    end
-
-  end
-
-  module GetArgs
-    def get_args
-      klass, meth = self.to_s.split(/ /).to_a[1][0..-2].split("#")
-      klass = $` if klass =~ /\(/
-      ParseTreeArray.translate(Object.const_get(klass), meth).get_args
-    end
-  end
-
-  class UnboundMethod
-    include GetArgs
-  end
-
-  class Method
-    include GetArgs
-  end
-rescue LoadError
-end

data/lib/ramaze/contrib/auto_params.rb

@@ -1,135 +0,0 @@
-# auto_params.rb
-#
-# AutoParams implements action parameterization ala merb 0.4 and Nitro
-# using ruby2ruby and ParseTree
-#
-# Usage:
-#
-#   Ramaze.contrib :auto_params
-#
-# Then, for example,
-#
-#   def search(query) end
-#
-# can be accessed via
-#
-#   - /search?query=findthis, which calls search('findthis')
-#   - /search/findthis                    search('findthis')
-#   - /search/findthis?query=andthis      search(['findthis', 'andthis'])
-#
-# For more examples, take a look at spec/contrib/auto_params.rb
-#
-# Note: A simpler alternative for similar functionality would be:
-#
-#   def search(query = request['query']) end
-#
-
-require __DIR__/:auto_params/:get_args
-
-module Ramaze
-
-  module Contrib
-    class AutoParams
-      def self.startup
-        Ramaze::Cache.add :args
-      end
-    end
-  end
-
-  class Action
-
-    # with parameterization, params may include
-    #   arrays: /num?n=1&n=2 becomes [['1','2']] for def num(n) end
-    #   nil: /calc?w=10&d=2 becomes ['10', nil, '2'] for def calc(w, h, d) end
-
-    def params=(*par)
-      par = *par
-      self[:params] = par.map{ |pa|
-        case pa
-        when Array
-          pa.map{|p| Rack::Utils.unescape(p)}
-        when nil
-          nil
-        else
-          Rack::Utils.unescape(pa)
-        end
-      } unless par.nil?
-      self[:params] ||= []
-    end
-
-  end
-
-  class Controller
-
-    # ignore cache when request.params is interesting
-
-    def self.cached(path)
-      if found = Cache.resolved[path]
-        if found.respond_to?(:relaxed_hash)
-
-          # don't use cache if we need to add request.params entries to the Action
-          if args = Cache.args[found.method]
-            param_keys = request.params.keys
-            return nil if args.find{|k,v| param_keys.include?(k.to_s) }
-          end
-
-          return found.dup
-        else
-          Log.warn("Found faulty `#{path}' in Cache.resolved, deleting it for sanity.")
-          Cache.resolved.delete path
-        end
-      end
-
-      nil
-    end
-
-    # use Method#get_args to insert values from request.params into Action#params
-
-    def self.resolve_method(name, *params)
-      if method = [ name, name.gsub('__','/') ].find{|n|
-          cached_action_methods.include?(n) }
-        meth = instance_method(method)
-        arity = meth.arity
-
-        if meth.respond_to? :get_args
-          unless args = Cache.args[name]
-            if args = meth.get_args
-              args = args.select{|e| e.to_s !~ /^\*/}
-            else
-              args = []
-            end
-            Cache.args[name] = args
-          end
-
-          param_keys = request.params.keys
-
-          # if there are missing args, or keys in request.params that match expected args
-          if args.size > params.size or args.find{|k,v| param_keys.include?(k.to_s) }
-            args.each_with_index do |(name, val), i|
-              r_params = request.params[name.to_s]
-              if params[i] and r_params and r_params.size > 0
-                params[i] = [params[i], r_params].flatten
-              else
-                params[i] ||= r_params
-              end
-            end
-
-            # strip trailing nils so default argument values are used
-            params.reverse.each{|e| if e.nil? then params.pop else break end }
-          end
-
-          argity = args.select{|e| e.size==1}.size..args.size
-        else
-          argity = arity..arity
-        end
-
-        if arity < 0 or argity.include? params.size
-          return method, params
-        end
-      end
-      return nil, []
-    end
-
-  end
-
-end

data/spec/contrib/auto_params.rb

@@ -1,121 +0,0 @@
-require 'spec/helper'
-spec_require 'parse_tree', 'ruby2ruby'
-
-Ramaze.contrib :auto_params
-
-module AnotherController
-  Ramaze::Helper::LOOKUP << self
-
-  def another_page
-    'another page'
-  end
-
-  define_method('css/style.css') { 'style.css' }
-end
-
-class MainController < Ramaze::Controller
-  include AnotherController
-  engine :None
-
-  def search query
-    query.inspect
-  end
-
-  def create name, age = '?', occupation = nil
-    [name, age, occupation].compact.join(', ')
-  end
-
-  def show *args
-    args.join(', ')
-  end
-
-  def add item, price = 1.0, *args
-    [item, price, *args].join(', ')
-  end
-
-  def find width, height, depth
-    [width, height, depth].join(', ')
-  end
-
-  define_method('page') do
-    'page'
-  end
-end
-
-class GetArgsTest
-  def one(a, b, c) end
-  def two(a, b = 1, c = nil) end
-  def three(a, *args) end
-end
-
-describe 'Method#get_args' do
-  it 'should return a list of arguments' do
-    gat = GetArgsTest.new
-    gat.method(:one).get_args.should == [[:a], [:b], [:c]]
-    gat.method(:two).get_args.should == [[:a], [:b, 1], [:c, nil]]
-    gat.method(:three).get_args.should == [[:a], [:"*args"]]
-  end
-end
-
-describe 'Parameterized actions' do
-  behaves_like 'http'
-  ramaze
-
-  it 'should pass in values from request.params' do
-    get('/create/Aman/20').body.should == 'Aman, 20'
-    get('/create', :name => 'Aman', :age => 20).body.should == 'Aman, 20'
-
-    get('/create/Aman/20/Unemployed').body.should == 'Aman, 20, Unemployed'
-    get('/create', :name => 'Aman', :age => 20, :occupation => 'Unemployed').body.should == 'Aman, 20, Unemployed'
-
-    get('/create/Aman').body.should == 'Aman, ?'
-    get('/create', :name => 'Aman').body.should == 'Aman, ?'
-  end
-
-  it 'should insert nil for arguments not found' do
-    get('/find', :width => 10, :depth => 20).body.should == '10, , 20'
-  end
-
-  it 'should work with variable arguments' do
-    get('/show/1/2/3').body.should == '1, 2, 3'
-
-    get('/add/Shoe').body.should == 'Shoe, 1.0'
-    get('/add', :item => 'Shoe').body.should == 'Shoe, 1.0'
-
-    get('/add/Shoe/10.50/1/2/3').body.should == 'Shoe, 10.50, 1, 2, 3'
-    get('/add/Shoe/11.00').body.should == 'Shoe, 11.00'
-  end
-
-  it 'should not break existing methods' do
-    get('/search/Aman').body.should == '"Aman"'
-    get('/search', 'query=Aman').body.should == '"Aman"'
-    get('/search/tmm1', 'query=Aman').body.should == ['tmm1','Aman'].inspect
-  end
-
-  it 'should consolidate all values for the same key into an array' do
-    get('/add', 'item=Shoe&item=Shirt').body.should == 'Shoe, Shirt, 1.0'
-    get('/add/Pants', 'item=Shoe&item=Shirt').body.should == 'Pants, Shoe, Shirt, 1.0'
-    get('/add/Shoe', :item => 'Shirt').body.should == 'Shoe, Shirt, 1.0'
-  end
-end if method(:puts).respond_to? :get_args
-
-describe 'Normal behavior' do
-  behaves_like 'http'
-  ramaze
-
-  it 'should work with no arguments' do
-    get('/page').body.should == 'page'
-  end
-
-  it 'should raise no action' do
-    get('/none').body.should =~ /^No Action found/
-  end
-
-  it 'should work with included actions' do
-    get('/another_page').body.should == 'another page'
-  end
-
-  it 'should work with /' do
-    get('/css/style.css').body.should == 'style.css'
-  end
-end

data/spec/snippets/divide.rb

@@ -1,19 +0,0 @@
-require 'lib/ramaze/spec/helper/snippets'
-
-describe 'String#/ and Symbol#/' do
-  it 'should join two strings' do
-    ('a' / 'b').should == 'a/b'
-  end
-
-  it 'should join a string and a symbol' do
-    ('a' / :b).should == 'a/b'
-  end
-
-  it 'should join two symbols' do
-    (:a / :b).should == 'a/b'
-  end
-
-  it 'should be usable in concatenation' do
-    ('a' / :b / :c).should == 'a/b/c'
-  end
-end

data/spec/snippets/object/acquire.rb

@@ -1,71 +0,0 @@
-require 'lib/ramaze/spec/helper/snippets'
-require 'fileutils'
-
-describe 'acquire' do
-  def require(name)
-    @required << name
-  end
-
-  before do
-    dir = 'tmp_dir_for_acquire'
-    FileUtils.mkdir_p(dir + '/sub')
-
-    %w[ foo.rb bar.rb baz.so baz.yml sub/baz.rb ].
-      each do |path|
-      FileUtils.touch("#{dir}/#{path}")
-    end
-
-    @required = []
-  end
-
-  it 'should not load a single file' do
-    acquire 'tmp_dir_for_acquire/foo'
-    @required.should == []
-  end
-
-  it 'should load dir' do
-    acquire 'tmp_dir_for_acquire/sub/*'
-    @required.should == %w[
-      tmp_dir_for_acquire/sub/baz.rb]
-  end
-
-  it 'should be aliased to acquire' do
-    acquire 'tmp_dir_for_acquire/sub/*'
-    @required.should.not.be.empty
-  end
-
-  it 'should load {so,rb}, not others' do
-    acquire 'tmp_dir_for_acquire/*'
-    @required.sort.should == %w[
-      tmp_dir_for_acquire/bar.rb
-      tmp_dir_for_acquire/baz.so
-      tmp_dir_for_acquire/foo.rb]
-  end
-
-  it 'should use globbing' do
-    acquire 'tmp_dir_for_acquire/ba*'
-    @required.sort.should == %w[
-      tmp_dir_for_acquire/bar.rb
-      tmp_dir_for_acquire/baz.so]
-  end
-
-  it 'should use recursive globbing' do
-    acquire 'tmp_dir_for_acquire/**/*'
-    @required.sort.should == %w[
-      tmp_dir_for_acquire/bar.rb
-      tmp_dir_for_acquire/baz.so
-      tmp_dir_for_acquire/foo.rb
-      tmp_dir_for_acquire/sub/baz.rb]
-  end
-
-  it 'should accept multiple arguments' do
-    acquire 'tmp_dir_for_acquire/*', 'tmp_dir_for_acquire/sub/*'
-    @required.sort.should == %w[
-      tmp_dir_for_acquire/bar.rb
-      tmp_dir_for_acquire/baz.so
-      tmp_dir_for_acquire/foo.rb
-      tmp_dir_for_acquire/sub/baz.rb]
-  end
-
-  FileUtils.rm_rf('tmp_dir_for_acquire')
-end