ramaze 0.1.0 → 0.1.1

data/lib/ramaze/http_status.rb

@@ -1,66 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-module Ramaze
-  STATUS_CODE = {
-    # 1xx Informational (Request received, continuing process.)
-
-    :continue                         => 100,
-    :switching_protocols              => 101,
-
-    # 2xx Success (The action was successfully received, understood, and accepted.)
-
-    :ok                               => 200,
-    :created                          => 201,
-    :accepted                         => 202,
-    :non_authorative_information      => 203,
-    :no_content                       => 204,
-    :resent_content                   => 205,
-    :partial_content                  => 206,
-    :multi_status                     => 207,
-
-    # 3xx Redirection (The client must take additional action to complete the request.)
-
-    :multiple_choices                 => 300,
-    :moved_permamently                => 301,
-    :moved_temporarily                => 302,
-    :found                            => 302,
-    :see_other                        => 303,
-    :not_modified                     => 304,
-    :use_proxy                        => 305,
-    :switch_proxy                     => 306,
-    :temporary_redirect               => 307,
-
-    # 4xx Client Error (The request contains bad syntax or cannot be fulfilled.)
-
-    :bad_request                      => 400,
-    :unauthorized                     => 401,
-    :payment_required                 => 402,
-    :forbidden                        => 403,
-    :not_found                        => 404,
-    :method_not_allowed               => 405,
-    :not_aceptable                    => 406,
-    :proxy_authentication_required    => 407,
-    :request_timeout                  => 408,
-    :conflict                         => 409,
-    :gone                             => 410,
-    :length_required                  => 411,
-    :precondition_failed              => 412,
-    :request_entity_too_large         => 413,
-    :request_uri_too_long             => 414,
-    :unsupported_media_type           => 415,
-    :requested_range_not_satisfiable  => 416,
-    :expectation_failed               => 417,
-    :retry_with                       => 449,
-
-    # 5xx Server Error (The server failed to fulfill an apparently valid request.)
-
-    :internal_server_error            => 500,
-    :not_implemented                  => 501,
-    :bad_gateway                      => 502,
-    :service_unavailable              => 503,
-    :gateway_timeout                  => 504,
-    :http_version_not_supported       => 505,
-    :bandwidth_limit_exceeded         => 509, # (not official)
-  }
-end

data/lib/ramaze/snippets/hash/keys_to_sym.rb

@@ -1,19 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-class Hash
-
-  # convert all keys in the Hash to symbols.
-
-  def keys_to_sym!
-    each do |key, value|
-      self[key.to_sym] = delete(key)
-    end
-  end
-
-  # answer with a new Hash with all keys as symbols.
-
-  def keys_to_sym
-    dup.keys_to_sym!
-  end
-end

data/lib/ramaze/snippets/kernel/method.rb

@@ -1,26 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-# This chunk of code redefines the #method method of Kernel to act more
-# dynamic.
-
-module Kernel
-  alias_method :method_get, :method unless defined? method_get
-
-  # get the object of the method you are currently in or any
-  # other out of the backtrace, as long as it is in the same
-  # instance and retrievable via method_get (which is the old #method).
-  #
-  #   class Foo
-  #     def bar
-  #       method
-  #     end
-  #   end
-  #
-  #   Foo.new.bar #=> #<Method: Foo#bar>
-
-  def method(n = 0)
-    return method_get(n) unless n.is_a? Integer
-    method_get caller.to_s.scan(/`(.*?)'/)[n].first rescue nil
-  end
-end

data/lib/ramaze/snippets/method/name.rb

@@ -1,22 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-# Modification for upcoming functionality in 1.9
-
-class Method
-
-  # name of the Method (example shows combination with the new Kernel#method)
-  #
-  #   class Foo
-  #     def bar
-  #       method.name
-  #     end
-  #   end
-  #
-  #   Foo.new.bar #=> 'bar'
-
-  def name
-    # parses things like <Method: A.d>
-    inspect.gsub(/#<Method: .*?[\.#](.*?)>/, '\1')
-  end
-end

data/lib/ramaze/snippets/ramaze/autoreload.rb

@@ -1,135 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'set'
-
-module Ramaze
-
-  RELOAD_ENV = {
-    :glob => /#{Dir.pwd}|ramaze/
-  }
-
-  class << self
-    def reload interval = 1
-      Inform.debug("initialize automatic file reload every #{interval} seconds")
-
-      Thread.new do
-        this = Thread.current
-        this[:task] = :autoreload
-
-        mtimes = {}
-
-        loop do
-          to_reload = all_reload_files.reject do |file|
-            mtime = File.mtime(file)
-            mtimes[file] ||= mtime
-            mtimes[file] == mtime
-          end
-
-          to_reload.each do |file|
-            sleep(interval / files.size.to_f)
-            Inform.debug("reload #{file}")
-            mtimes[file] = mtime if safe_load(file)
-          end
-        end
-      end
-    end
-
-    def all_reload_files
-      env = RELOAD_ENV
-
-      files, paths = $LOADED_FEATURES, $LOAD_PATH
-
-      unless env[:files] == files and env[:paths] == paths
-        env[:files], env[:paths] = files.dup, paths.dup
-        env[:map] = files.map do |file|
-          possible = paths.map{|pa| File.join(pa.to_s, file.to_s) }
-          possible.find{|po| File.exists?(po) }
-        end
-        env[:map] = env[:map].compact.sort
-      end
-
-      env[:map].select{|f| f =~ env[:glob] }
-    end
-
-    def safe_load(file)
-      load(file)
-      true
-    rescue Object => ex
-      Inform.error(ex)
-      false
-    end
-  end
-
-  # this method loops through all loaded/required files
-  # and re-loads them when they are updated.
-  # It takes one parameter, which is the interval in seconds
-  # with a default of 10.
-  # You can also safely kill all threads (except for the main)
-  # and it will just restart the autoreloader.
-
-  def self.autoreload interval = 10
-    Inform.debug("initialize autoreload with an interval of #{interval} seconds")
-
-    gatherer = Thread.new do
-      this = Thread.current
-      this[:task] = :autoreload
-
-      cache = {}
-      file_set = Set.new
-
-      loop do
-        files = file_set.dup
-        $LOADED_FEATURES.map do |file|
-          file = file.to_s
-          paths = $LOAD_PATH + ['']
-          correct_path = paths.find{|lp| File.exist?(File.join(lp.to_s, file))}
-          correct_file = File.expand_path(File.join(correct_path, file)) if correct_path
-
-          files << correct_file if correct_file
-        end
-
-        this[:files] = files
-
-        sleep_interval = this[:interval] ||= interval || 10
-        sleep sleep_interval
-      end
-    end
-
-    reloader = Thread.new do
-      this = Thread.current
-      this[:task] = :autoreload
-
-      cache = {}
-      this[:interval] = interval
-      sleep 0.1 until gatherer[:files] # wait for the gatherer
-
-      loop do
-        gatherer[:files].each do |file|
-          begin
-            current_time = File.mtime(file)
-            if last_time = cache[file]
-              unless last_time == current_time
-                Inform.info("autoreload #{file}")
-                load(file)
-                cache[file] = current_time
-              end
-            else
-              cache[file] = current_time
-            end
-          rescue Object => ex # catches errors when the load fails
-            # in case mtime fails
-            unless ex.message =~ /No such file or directory/
-              puts ex
-              puts ex.backtrace
-            end
-            # sleep a total of reloader[:interval],
-            # but spread it evenly on all files
-          end # begin
-          sleep_interval = this[:interval].to_f / gatherer[:files].size
-          sleep sleep_interval
-        end # each
-      end # loop
-    end # Thread.new
-  end # autoreload
-end # Ramaze

data/lib/ramaze/snippets/rdoc/usage_no_exit.rb

@@ -1,65 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'rdoc/ri/ri_paths'
-require 'rdoc/usage'
-
-# This is a little hack to enable RDoc to see through gems.
-#
-# Very evil, but until we get a better RDoc this will have to do.
-
-module RDoc
-  class << self
-
-    # a patch for RDocs::usage calling our Rdoc::ramazes_usage_no_exit
-
-    def ramazes_usage(*args)
-      exit_code = 0
-
-      if args.size > 0
-        status = args[0]
-        if status.respond_to?(:to_int)
-          exit_code = status.to_int
-          args.shift
-        end
-      end
-
-      # display the usage and exit with the given code
-      ramazes_usage_no_exit(*args)
-      exit(exit_code)
-    end
-
-    # Only a modfication of RDoc::usage_no_exit for the lookup of main_program,
-    # this would be buggy if used by the binary of the gem since $0 is
-    # different.
-    #
-    # Using caller to lookup the actual bin.
-
-    def ramazes_usage_no_exit(*args)
-      main_program_file = caller[1].sub(/:\d+$/, '')
-      comment = File.open(main_program_file) do |file|
-        find_comment(file)
-      end
-
-      comment = comment.gsub(/^\s*#/, '')
-
-      markup = SM::SimpleMarkup.new
-      flow_convertor = SM::ToFlow.new
-
-      flow = markup.convert(comment, flow_convertor)
-
-      format = "plain"
-
-      unless args.empty?
-        flow = extract_sections(flow, args)
-      end
-
-      options = RI::Options.instance
-      if args = ENV["RI"]
-        options.parse(args.split)
-      end
-      formatter = options.formatter.new(options, "")
-      formatter.display_flow(flow)
-    end
-  end
-end

data/spec/all.rb

@@ -1,32 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'spec/helper/layout'
-
-layout = {
-  'ramaze' => {
-    '.'         => '*',
-    'adapter'   => '*',
-    'helper'    => '*',
-    'inform'    => '*',
-    'request'   => '*',
-    'store'     => '*',
-    'template'  => '*',
-    'controller' => '*'
-    },
-  'examples' => {
-    '.' => '*',
-    'templates' => '*'
-  }
-}
-
-manually_add = %w[
-  ramaze/template ramaze/controller
-]
-manually_add.map!{|ma| File.expand_path("spec/#{ma}.rb") }
-
-layout = SpecLayout.new(File.dirname(__FILE__), layout)
-layout.gather
-layout.clean
-layout.files += manually_add
-layout.run

data/spec/ramaze/conf/locale_de.yaml

@@ -1,6 +0,0 @@
---- 
-a: ein
-hello: "Hallo, Welt!"
-is: ist
-test: Test
-this: Das

data/spec/ramaze/conf/locale_en.yaml

@@ -1,6 +0,0 @@
---- 
-a: a
-hello: "Hello, World!"
-is: is
-test: test
-this: this

data/spec/ramaze/dependencies.rb

@@ -1,16 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'spec/helper'
-
-testcase_requires 'rubygems'
-
-describe "dependencies" do
-  it "no gems" do
-    # rspec, systemu and syntax (loaded by rspec since 0.9)
-    # are used for testing
-    regex = /rspec|rack|systemu|syntax/
-    gems = $:.grep(/gems/).reject{|g| g =~ regex}
-    gems.should == []
-  end
-end

data/spec/ramaze/global.rb

@@ -1,44 +0,0 @@
-#          Copyright (c) 2006 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
-require 'spec/helper'
-
-describe "Ramaze::Global" do
-  it "just simple assignment and retrive" do
-    Ramaze::Global.some = :xxx
-    Ramaze::Global.some.should == :xxx
-  end
-
-  it "setup" do
-    Ramaze::Global.setup :a => :b
-    Ramaze::Global.a.should == :b
-    Ramaze::Global.some.should == :xxx
-    Ramaze::Global.setup :a => :c
-    Ramaze::Global.a.should == :c
-  end
-
-  it "more neat stuff" do
-    Ramaze::Global.update :a => :d, :foo => :bar
-    Ramaze::Global.a.should == :c
-    Ramaze::Global.foo.should == :bar
-  end
-
-  it "values_at" do
-    Ramaze::Global.values_at(:a, :foo).should == [:c, :bar]
-  end
-
-  it "getting thready" do
-    Ramaze::Global[:i] = 0
-    Thread.main[:i] = 0
-
-    (1..10).each do |i|
-      Thread.new do
-        Ramaze::Global[:i] += i
-        Thread.main[:i] += i
-      end
-    end
-
-    Ramaze::Global[:i].should == Thread.main[:i]
-    Ramaze::Global[:i].should == 55
-  end
-end