thorero 0.9.4.4 → 0.9.4.5

data/lib/merb-core/vendor/facets/inflect.rb

@@ -0,0 +1,345 @@
+module Language
+
+module English
+
+  # = English Nouns Number Inflection.
+  #
+  # This module provides english singular <-> plural noun inflections.
+  module Inflect
+
+    @singular_of = {}
+    @plural_of = {}
+
+    @singular_rules = []
+    @plural_rules = []
+
+    class << self
+      # Defines a general inflection exception case.
+      #
+      # ==== Parameters
+      # singular<String>::
+      #   singular form of the word
+      # plural<String>::
+      #   plural form of the word
+      #
+      # ==== Examples
+      #
+      # Here we define erratum/errata exception case:
+      #
+      # Language::English::Inflector.word "erratum", "errata"
+      #
+      # In case singular and plural forms are the same omit
+      # second argument on call:
+      #
+      # Language::English::Inflector.word 'information'
+      def word(singular, plural=nil)
+        plural = singular unless plural
+        singular_word(singular, plural)
+        plural_word(singular, plural)
+      end
+
+      def clear(type = :all)
+        if type == :singular || type == :all
+          @singular_of = {}
+          @singular_rules = []
+          @singularization_rules, @singularization_regex = nil, nil
+        end
+        if type == :plural || type == :all
+          @singular_of = {}
+          @singular_rules = []
+          @singularization_rules, @singularization_regex = nil, nil
+        end
+      end
+
+
+      # Define a singularization exception.
+      #
+      # ==== Parameters
+      # singular<String>::
+      #   singular form of the word
+      # plural<String>::
+      #   plural form of the word
+      def singular_word(singular, plural)
+        @singular_of[plural] = singular
+        @singular_of[plural.capitalize] = singular.capitalize
+      end
+
+      # Define a pluralization exception.
+      #
+      # ==== Parameters
+      # singular<String>::
+      #   singular form of the word
+      # plural<String>::
+      #   plural form of the word
+      def plural_word(singular, plural)
+        @plural_of[singular] = plural
+        @plural_of[singular.capitalize] = plural.capitalize
+      end
+
+      # Define a general rule.
+      #
+      # ==== Parameters
+      # singular<String>::
+      #   ending of the word in singular form
+      # plural<String>::
+      #   ending of the word in plural form
+      # whole_word<Boolean>::
+      #   for capitalization, since words can be
+      #   capitalized (Man => Men)      #
+      # ==== Examples
+      # Once the following rule is defined:
+      # Language::English::Inflector.rule 'y', 'ies'
+      #
+      # You can see the following results:
+      # irb> "fly".plural
+      # => flies
+      # irb> "cry".plural
+      # => cries
+      # Define a general rule.
+
+      def rule(singular, plural, whole_word = false)
+        singular_rule(singular, plural)
+        plural_rule(singular, plural)
+        word(singular, plural) if whole_word
+      end
+
+      # Define a singularization rule.
+      #
+      # ==== Parameters
+      # singular<String>::
+      #   ending of the word in singular form
+      # plural<String>::
+      #   ending of the word in plural form
+      #
+      # ==== Examples
+      # Once the following rule is defined:
+      # Language::English::Inflector.singular_rule 'o', 'oes'
+      #
+      # You can see the following results:
+      # irb> "heroes".singular
+      # => hero
+      def singular_rule(singular, plural)
+        @singular_rules << [singular, plural]
+      end
+
+      # Define a plurualization rule.
+      #
+      # ==== Parameters
+      # singular<String>::
+      #   ending of the word in singular form
+      # plural<String>::
+      #   ending of the word in plural form
+      #
+      # ==== Examples
+      # Once the following rule is defined:
+      # Language::English::Inflector.singular_rule 'fe', 'ves'
+      #
+      # You can see the following results:
+      # irb> "wife".plural
+      # => wives
+      def plural_rule(singular, plural)
+        @plural_rules << [singular, plural]
+      end
+
+      # Read prepared singularization rules.
+      def singularization_rules
+        if defined?(@singularization_regex) && @singularization_regex
+          return [@singularization_regex, @singularization_hash]
+        end
+        # No sorting needed: Regexen match on longest string
+        @singularization_regex = Regexp.new("(" + @singular_rules.map {|s,p| p}.join("|") + ")$", "i")
+        @singularization_hash  = Hash[*@singular_rules.flatten].invert
+        [@singularization_regex, @singularization_hash]
+      end
+
+      # Read prepared pluralization rules.
+      def pluralization_rules
+        if defined?(@pluralization_regex) && @pluralization_regex
+          return [@pluralization_regex, @pluralization_hash]
+        end
+        @pluralization_regex = Regexp.new("(" + @plural_rules.map {|s,p| s}.join("|") + ")$", "i")
+        @pluralization_hash  = Hash[*@plural_rules.flatten]
+        [@pluralization_regex, @pluralization_hash]
+      end
+
+      attr_reader :singular_of, :plural_of
+
+      # Convert an English word from plurel to singular.
+      #
+      #   "boys".singular      #=> boy
+      #   "tomatoes".singular  #=> tomato
+      #
+      # ==== Parameters
+      # word<String>:: word to singularize
+      #
+      # ==== Returns
+      # <String>:: singularized form of word
+      #
+      # ==== Notes
+      # Aliased as singularize (a Railism)
+      def singular(word)
+        if result = singular_of[word]
+          return result.dup
+        end
+        result = word.dup
+        regex, hash = singularization_rules
+        result.sub!(regex) {|m| hash[m]}
+        singular_of[word] = result
+        return result
+      end
+
+      # Alias for #singular (a Railism).
+      #
+      alias_method(:singularize, :singular)
+
+      # Convert an English word from singular to plurel.
+      #
+      #   "boy".plural     #=> boys
+      #   "tomato".plural  #=> tomatoes
+      #
+      # ==== Parameters
+      # word<String>:: word to pluralize
+      #
+      # ==== Returns
+      # <String>:: pluralized form of word
+      #
+      # ==== Notes
+      # Aliased as pluralize (a Railism)
+      def plural(word)
+        # special exceptions
+        return "" if word == ""
+        if result = plural_of[word]
+          return result.dup
+        end
+        result = word.dup
+        regex, hash = pluralization_rules
+        result.sub!(regex) {|m| hash[m]}
+        plural_of[word] = result
+        return result
+      end
+
+      # Alias for #plural (a Railism).
+      alias_method(:pluralize, :plural)
+    end
+
+    # One argument means singular and plural are the same.
+
+    word 'equipment'
+    word 'information'
+    word 'money'
+    word 'species'
+    word 'series'
+    word 'fish'
+    word 'sheep'
+    word 'moose'
+    word 'hovercraft'
+    word 'grass'
+    word 'rain'
+    word 'milk'
+    word 'rice'
+    word 'plurals'
+
+    # Two arguments defines a singular and plural exception.
+
+    word 'Swiss'     , 'Swiss'
+    word 'life'      , 'lives'
+    word 'wife'      , 'wives'
+    word 'goose'     , 'geese'
+    word 'criterion' , 'criteria'
+    word 'alias'     , 'aliases'
+    word 'status'    , 'statuses'
+    word 'axis'      , 'axes'
+    word 'crisis'    , 'crises'
+    word 'testis'    , 'testes'
+    word 'potato'    , 'potatoes'
+    word 'tomato'    , 'tomatoes'
+    word 'buffalo'   , 'buffaloes'
+    word 'torpedo'   , 'torpedoes'
+    word 'quiz'      , 'quizzes'
+    word 'matrix'    , 'matrices'
+    word 'vertex'    , 'vertices'
+    word 'index'     , 'indices'
+    word 'ox'        , 'oxen'
+    word 'mouse'     , 'mice'
+    word 'louse'     , 'lice'
+    word 'thesis'    , 'theses'
+    word 'thief'     , 'thieves'
+    word 'analysis'  , 'analyses'
+    word 'erratum'   , 'errata'
+    word 'phenomenon', 'phenomena'
+    word 'octopus'   , 'octopi'
+    word 'thesaurus' , 'thesauri'
+    word 'movie'     , 'movies'
+    word 'cactus'    , 'cacti'
+    word 'plus'      , 'plusses'
+    word 'cross'     , 'crosses'
+    word 'medium'    , 'media'
+    word 'cow'       , 'kine'
+    word 'datum'     , 'data'
+    word 'basis'     , 'bases'
+    word 'diagnosis' , 'diagnoses'    
+    
+    # One-way singularization exception (convert plural to singular).
+
+    # General rules.
+    rule 'person' , 'people', true
+    rule 'shoe'   , 'shoes', true
+    rule 'hive'   , 'hives', true
+    rule 'man'    , 'men', true
+    rule 'child'  , 'children', true
+    rule 'news'   , 'news', true
+    rule 'rf'   , 'rves'
+    rule 'af'   , 'aves'
+    rule 'ero'  , 'eroes'
+    rule 'man'  , 'men'
+    rule 'ch'   , 'ches'
+    rule 'sh'   , 'shes'
+    rule 'ss'   , 'sses'
+    rule 'ta'   , 'tum'
+    rule 'ia'   , 'ium'
+    rule 'ra'   , 'rum'
+    rule 'ay'   , 'ays'
+    rule 'ey'   , 'eys'
+    rule 'oy'   , 'oys'
+    rule 'uy'   , 'uys'
+    rule 'y'    , 'ies'
+    rule 'x'    , 'xes'
+    rule 'lf'   , 'lves'
+    rule 'ffe'  , 'ffes'
+    rule 'afe'  , 'aves'
+    rule 'ouse' , 'ouses'
+    # more cases of words ending in -oses not being singularized properly
+    # than cases of words ending in -osis
+#    rule 'osis' , 'oses'
+    rule 'ox'   , 'oxes'
+    rule 'us'   , 'uses'
+    rule ''     , 's'
+
+    # One-way singular rules.
+
+    singular_rule 'of' , 'ofs' # proof
+    singular_rule 'o'  , 'oes' # hero, heroes
+    singular_rule 'f'  , 'ves'
+
+    # One-way plural rules.
+
+    #plural_rule 'fe' , 'ves' # safe, wife
+    plural_rule 's'   , 'ses'
+    plural_rule 'ive' , 'ives' # don't want to snag wife
+    plural_rule 'fe'  , 'ves'  # don't want to snag perspectives  
+    
+
+  end
+end
+end
+
+class String
+  def singular
+    Language::English::Inflect.singular(self)
+  end
+  alias_method(:singularize, :singular)
+  def plural
+    Language::English::Inflect.plural(self)
+  end
+  alias_method(:pluralize, :plural)
+end

data/lib/merb-core/version.rb

@@ -0,0 +1,11 @@
+module Merb
+  VERSION = '0.9.4' unless defined?(Merb::VERSION)
+
+  # Merb::RELEASE meanings:
+  # 'dev'   : unreleased
+  # 'pre'   : pre-release Gem candidates
+  #  nil    : released
+  # You should never check in to trunk with this changed.  It should
+  # stay 'dev'.  Change it to nil in release tags.
+  RELEASE = 'dev' unless defined?(Merb::RELEASE)
+end

data/spec/private/config/adapter_spec.rb

@@ -0,0 +1,32 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+MERB_BIN = File.dirname(__FILE__) + "/../../../bin/merb"
+
+describe Merb::Config do
+  before do
+    ARGV.replace([])
+    Merb::Server.should_receive(:start).and_return(nil)
+  end
+  
+  it "should load the runner adapter by default" do
+    Merb.start 
+    Merb::Config[:adapter].should == "runner"
+  end
+  
+  it "should load mongrel adapter when running `merb`" do
+    load(MERB_BIN)
+    Merb::Config[:adapter].should == "mongrel"
+  end
+
+  it "should override adapter when running `merb -a other`" do
+    ARGV.push *%w[-a other]
+    load(MERB_BIN)
+    Merb::Config[:adapter].should == "other"
+  end  
+  
+  it "should load irb adapter when running `merb -i`" do
+    ARGV << '-i'
+    load(MERB_BIN)
+    Merb::Config[:adapter].should == "irb"
+  end
+end

data/spec/private/config/config_spec.rb

@@ -0,0 +1,202 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Merb::Config do
+  before do
+    Merb::Config.setup
+  end
+
+  it "should be able to yield the configuration via #use" do
+    res = nil
+    Merb::Config.use {|c| res = c}
+    res.should == Merb::Config.defaults
+  end
+
+  it "should be able to get a configuration key" do
+    Merb::Config[:host].should == "0.0.0.0"
+  end
+
+  it "should be able to set a configuration key" do
+    Merb::Config[:bar] = "Hello"
+    Merb::Config[:bar].should == "Hello"
+  end
+
+  it "should be able to #delete a configuration key" do
+    Merb::Config[:bar] = "Hello"
+    Merb::Config[:bar].should == "Hello"
+    Merb::Config.delete(:bar)
+    Merb::Config[:bar].should == nil
+  end
+
+  it "should be able to #fetch a key that does exist" do
+    Merb::Config.fetch(:host, "192.168.2.1").should == "0.0.0.0"
+  end
+
+  it "should be able to #fetch a key that does exist" do
+    Merb::Config.fetch(:bar, "heylo").should == "heylo"
+  end
+
+  it "should be able to dump to YAML" do
+    Merb::Config.to_yaml.should == Merb::Config.instance_variable_get("@configuration").to_yaml
+  end
+
+  it "should support -u to set the user to run Merb as" do
+    Merb::Config.parse_args(["-u", "tester"])
+    Merb::Config[:user].should == "tester"
+  end
+
+  it "should support -G to set the group to run Merb as" do
+    Merb::Config.parse_args(["-G", "tester"])
+    Merb::Config[:group].should == "tester"
+  end
+
+  it "should support -d to daemonize Merb" do
+    Merb::Config.parse_args(["-d"])
+    Merb::Config[:daemonize].should == true
+  end
+
+  it "should support -c to set the number of cluster nodes" do
+    Merb::Config.parse_args(["-c", "4"])
+    Merb::Config[:cluster].should == "4"
+  end
+
+  it "should support -p to set the port number" do
+    Merb::Config.parse_args(["-p", "6000"])
+    Merb::Config[:port].should == "6000"
+  end
+
+  it "should support -o to set the socket filename" do
+    Merb::Config.parse_args(["-o", "merb.2.sock"])
+    Merb::Config[:socket_file].should == "merb.2.sock"
+  end
+
+  it "should support --socket-file to set the socket filename" do
+    Merb::Config.parse_args(["--socket-file", "app.thin.0.sock"])
+    Merb::Config[:socket_file].should == "app.thin.0.sock" # 0 is default socket #
+  end
+
+  it "should support -s to set the socket number" do
+    Merb::Config.parse_args(["-s", "0"])
+    Merb::Config[:socket].should == "0"
+  end
+
+  it "should support --socket to set the socket number" do
+    Merb::Config.parse_args(["--socket", "3"])
+    Merb::Config[:socket].should == "3"
+  end
+
+  it "should support -P to set the PIDfile" do
+    Merb::Config.parse_args(["-P", "pidfile"])
+    Merb::Config[:pid_file].should == "pidfile"
+  end
+
+  it "should have server return PIDfile setting as is with no cluster nodes" do
+    Merb::Config.parse_args(["-P", "pidfile", "-p", "6000"])
+    Merb::Server.pid_file(6000).should == "pidfile"
+    Merb::Server.pid_files.should == ["pidfile"]
+  end
+
+  it "should support setting of PIDfile with cluster nodes" do
+    Merb::Config.parse_args(["-P", "/tmp/merb.pidfile", "-c", "2", "-p", "6000"])
+    Merb::Server.pid_file(6000).should == "/tmp/merb.6000.pidfile"
+    Merb::Server.pid_file(6001).should == "/tmp/merb.6001.pidfile"
+
+    Dir.should_receive(:[]).with("/tmp/merb.*.pidfile")
+    Merb::Server.pid_files
+  end
+
+  it "should support default PIDfile setting" do
+    Merb::Config.parse_args(["-p", "6000"])
+    Merb::Server.pid_file(6000).should == Merb.log_path / "merb.6000.pid"
+
+    Dir.should_receive(:[]).with(Merb.log_path / "merb.*.pid")
+    Merb::Server.pid_files
+  end
+
+  it "should support -h to set the hostname" do
+    Merb::Config.parse_args(["-h", "hostname"])
+    Merb::Config[:host].should == "hostname"
+  end
+
+  it "should support -i to specify loading IRB" do
+    Merb::Config.parse_args(["-i"])
+    Merb::Config[:adapter].should == "irb"
+  end
+
+  it "should support -l to specify the log level" do
+    Merb::Config.parse_args(["-l", "debug"])
+    Merb::Config[:log_level].should == :debug
+  end
+
+  it "should support -L to specify the location of the log file" do
+    Merb::Config.parse_args(["-L", "log_file"])
+    Merb::Config[:log_file].should == "log_file"
+  end
+
+  it "should support -r to specify a runner" do
+    Merb::Config.parse_args(["-r", "foo_runner"])
+    Merb::Config[:runner_code].should == "foo_runner"
+    Merb::Config[:adapter].should == "runner"
+  end
+
+  it "should support -R to specify a rackup file" do
+    Merb::Config.parse_args(["-R", "config.ru"])
+    Merb::Config[:rackup].should == "config.ru"
+  end
+
+  it "should support -K for a graceful kill" do
+    Merb::Server.should_receive(:kill).with("all", 1)
+    Merb.start(["-K", "all"])
+  end
+
+  it "should support -k for a hard kill" do
+    Merb::Server.should_receive(:kill).with("all", 9)
+    Merb.start(["-k", "all"])
+  end
+
+  it "should support -X off to turn off the mutex" do
+    Merb::Config.parse_args(["-X", "off"])
+    Merb::Config[:use_mutex].should == false
+  end
+
+  it "should support -X on to turn off the mutex" do
+    Merb::Config.parse_args(["-X", "on"])
+    Merb::Config[:use_mutex].should == true
+  end
+
+  it "should take Merb.disable into account" do
+    Merb::Config[:disabled_components].should == []
+    Merb::Config[:disabled_components] << :foo
+    Merb.disable(:bar)
+    Merb.disable(:buz, :fux)
+    Merb::Config[:disabled_components].should == [:foo, :bar, :buz, :fux]
+    Merb.disabled?(:foo).should == true
+    Merb.disabled?(:foo, :buz).should == true
+  end
+
+  it "should take Merb.testing? into account" do
+    $TESTING.should == true
+    Merb::Config[:testing].should be_nil
+    Merb.should be_testing
+    $TESTING = false
+    Merb.should_not be_testing
+    Merb::Config[:testing] = true
+    Merb.should be_testing
+    $TESTING = true; Merb::Config[:testing] = false # reset
+  end
+
+  it "supports -V to turn on verbose mode" do
+    Merb::Config[:verbose] = false
+    Merb::Config.parse_args(["-V"])
+    Merb::Config[:verbose].should be(true)
+  end
+
+  it "supports --verbose to turn on verbose mode" do
+    Merb::Config[:verbose] = false
+    Merb::Config.parse_args(["--verbose"])
+    Merb::Config[:verbose].should be(true)
+  end
+
+  it "has verbose mode turned off by default" do
+    Merb::Config[:verbose].should be(false)
+  end
+end