merb 0.5.3 → 0.9.2

data/lib/merb/core_ext/inflector.rb

@@ -1,275 +0,0 @@
-require 'singleton'
-
-# The Inflector transforms words from singular to plural, class names to table names, modularized class names to ones without,
-# and class names to foreign keys. The default inflections for pluralization, singularization, and uncountable words are kept
-# in inflections.rb.
-module Inflector
-  # A singleton instance of this class is yielded by Inflector.inflections, which can then be used to specify additional
-  # inflection rules. Examples:
-  #
-  #   Inflector.inflections do |inflect|
-  #     inflect.plural /^(ox)$/i, '\1\2en'
-  #     inflect.singular /^(ox)en/i, '\1'
-  #
-  #     inflect.irregular 'octopus', 'octopi'
-  #
-  #     inflect.uncountable "equipment"
-  #   end
-  #
-  # New rules are added at the top. So in the example above, the irregular rule for octopus will now be the first of the
-  # pluralization and singularization rules that is runs. This guarantees that your rules run before any of the rules that may
-  # already have been loaded.
-  class Inflections
-    include Singleton
-
-    attr_reader :plurals, :singulars, :uncountables
-
-    def initialize
-      @plurals, @singulars, @uncountables = [], [], []
-    end
-
-    # Specifies a new pluralization rule and its replacement. The rule can either be a string or a regular expression.
-    # The replacement should always be a string that may include references to the matched data from the rule.
-    def plural(rule, replacement)
-      @plurals.insert(0, [rule, replacement])
-    end
-
-    # Specifies a new singularization rule and its replacement. The rule can either be a string or a regular expression.
-    # The replacement should always be a string that may include references to the matched data from the rule.
-    def singular(rule, replacement)
-      @singulars.insert(0, [rule, replacement])
-    end
-
-    # Specifies a new irregular that applies to both pluralization and singularization at the same time. This can only be used
-    # for strings, not regular expressions. You simply pass the irregular in singular and plural form.
-    #
-    # Examples:
-    #   irregular 'octopus', 'octopi'
-    #   irregular 'person', 'people'
-    def irregular(singular, plural)
-      plural(Regexp.new("(#{singular[0,1]})#{singular[1..-1]}$", "i"), '\1' + plural[1..-1])
-      singular(Regexp.new("(#{plural[0,1]})#{plural[1..-1]}$", "i"), '\1' + singular[1..-1])
-    end
-
-    # Add uncountable words that shouldn't be attempted inflected.
-    #
-    # Examples:
-    #   uncountable "money"
-    #   uncountable "money", "information"
-    #   uncountable %w( money information rice )
-    def uncountable(*words)
-      (@uncountables << words).flatten!
-    end
-
-    # Clears the loaded inflections within a given scope (default is :all). Give the scope as a symbol of the inflection type,
-    # the options are: :plurals, :singulars, :uncountables
-    #
-    # Examples:
-    #   clear :all
-    #   clear :plurals
-    def clear(scope = :all)
-      case scope
-        when :all
-          @plurals, @singulars, @uncountables = [], [], []
-        else
-          instance_variable_set "@#{scope}", []
-      end
-    end
-  end
-
-  extend self
-
-  def inflections
-    if block_given?
-      yield Inflections.instance
-    else
-      Inflections.instance
-    end
-  end
-
-  # Returns the plural form of the word in the string.
-  #
-  # Examples
-  #   "post".pluralize #=> "posts"
-  #   "octopus".pluralize #=> "octopi"
-  #   "sheep".pluralize #=> "sheep"
-  #   "words".pluralize #=> "words"
-  #   "the blue mailman".pluralize #=> "the blue mailmen"
-  #   "CamelOctopus".pluralize #=> "CamelOctopi"
-  def pluralize(word)
-    result = word.to_s.dup
-
-    if inflections.uncountables.include?(result.downcase)
-      result
-    else
-      inflections.plurals.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
-      result
-    end
-  end
-
-  # The reverse of pluralize, returns the singular form of a word in a string.
-  #
-  # Examples
-  #   "posts".singularize #=> "post"
-  #   "octopi".singularize #=> "octopus"
-  #   "sheep".singluarize #=> "sheep"
-  #   "word".singluarize #=> "word"
-  #   "the blue mailmen".singularize #=> "the blue mailman"
-  #   "CamelOctopi".singularize #=> "CamelOctopus"
-  def singularize(word)
-    result = word.to_s.dup
-
-    if inflections.uncountables.include?(result.downcase)
-      result
-    else
-      inflections.singulars.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
-      result
-    end
-  end
-
-  # By default, camelize converts strings to UpperCamelCase. If the argument to camelize
-  # is set to ":lower" then camelize produces lowerCamelCase.
-  #
-  # camelize will also convert '/' to '::' which is useful for converting paths to namespaces
-  #
-  # Examples
-  #   "active_record".camelize #=> "ActiveRecord"
-  #   "active_record".camelize(:lower) #=> "activeRecord"
-  #   "active_record/errors".camelize #=> "ActiveRecord::Errors"
-  #   "active_record/errors".camelize(:lower) #=> "activeRecord::Errors"
-  def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
-    if first_letter_in_uppercase
-      lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
-    else
-      lower_case_and_underscored_word.first + camelize(lower_case_and_underscored_word)[1..-1]
-    end
-  end
-
-  # Capitalizes all the words and replaces some characters in the string to create
-  # a nicer looking title. Titleize is meant for creating pretty output. It is not
-  # used in the Rails internals.
-  #
-  # titleize is also aliased as as titlecase
-  #
-  # Examples
-  #   "man from the boondocks".titleize #=> "Man From The Boondocks"
-  #   "x-men: the last stand".titleize #=> "X Men: The Last Stand"
-  def titleize(word)
-    humanize(underscore(word)).gsub(/\b([a-z])/) { $1.capitalize }
-  end
-
-  # The reverse of +camelize+. Makes an underscored form from the expression in the string.
-  #
-  # Changes '::' to '/' to convert namespaces to paths.
-  #
-  # Examples
-  #   "ActiveRecord".underscore #=> "active_record"
-  #   "ActiveRecord::Errors".underscore #=> active_record/errors
-  def underscore(camel_cased_word)
-    camel_cased_word.to_s.gsub(/::/, '/').
-      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-      gsub(/([a-z\d])([A-Z])/,'\1_\2').
-      tr("-", "_").
-      downcase
-  end
-
-  # Replaces underscores with dashes in the string.
-  #
-  # Example
-  #   "puni_puni" #=> "puni-puni"
-  def dasherize(underscored_word)
-    underscored_word.gsub(/_/, '-')
-  end
-
-  # Capitalizes the first word and turns underscores into spaces and strips _id.
-  # Like titleize, this is meant for creating pretty output.
-  #
-  # Examples
-  #   "employee_salary" #=> "Employee salary"
-  #   "author_id" #=> "Author"
-  def humanize(lower_case_and_underscored_word)
-    lower_case_and_underscored_word.to_s.gsub(/_id$/, "").gsub(/_/, " ").capitalize
-  end
-
-  # Removes the module part from the expression in the string
-  #
-  # Examples
-  #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections"
-  #   "Inflections".demodulize #=> "Inflections"
-  def demodulize(class_name_in_module)
-    class_name_in_module.to_s.gsub(/^.*::/, '')
-  end
-
-  # Create the name of a table like Rails does for models to table names. This method
-  # uses the pluralize method on the last word in the string.
-  #
-  # Examples
-  #   "RawScaledScorer".tableize #=> "raw_scaled_scorers"
-  #   "egg_and_ham".tableize #=> "egg_and_hams"
-  #   "fancyCategory".tableize #=> "fancy_categories"
-  def tableize(class_name)
-    pluralize(underscore(class_name))
-  end
-
-  # Create a class name from a table name like Rails does for table names to models.
-  # Note that this returns a string and not a Class. (To convert to an actual class
-  # follow classify with constantize.)
-  #
-  # Examples
-  #   "egg_and_hams".classify #=> "EggAndHam"
-  #   "post".classify #=> "Post"
-  def classify(table_name)
-    # strip out any leading schema name
-    camelize(singularize(table_name.to_s.sub(/.*\./, '')))
-  end
-
-  # Creates a foreign key name from a class name.
-  # +separate_class_name_and_id_with_underscore+ sets whether
-  # the method should put '_' between the name and 'id'.
-  #
-  # Examples
-  #   "Message".foreign_key #=> "message_id"
-  #   "Message".foreign_key(false) #=> "messageid"
-  #   "Admin::Post".foreign_key #=> "post_id"
-  def foreign_key(class_name, separate_class_name_and_id_with_underscore = true)
-    underscore(demodulize(class_name)) + (separate_class_name_and_id_with_underscore ? "_id" : "id")
-  end
-
-  # Constantize tries to find a declared constant with the name specified
-  # in the string. It raises a NameError when the name is not in CamelCase
-  # or is not initialized.
-  #
-  # Examples
-  #   "Module".constantize #=> Module
-  #   "Class".constantize #=> Class
-  def constantize(camel_cased_word)
-    unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
-      raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
-    end
-
-    Object.module_eval("::#{$1}", __FILE__, __LINE__)
-  end
-
-  # Ordinalize turns a number into an ordinal string used to denote the
-  # position in an ordered sequence such as 1st, 2nd, 3rd, 4th.
-  #
-  # Examples
-  #   ordinalize(1)     # => "1st"
-  #   ordinalize(2)     # => "2nd"
-  #   ordinalize(1002)  # => "1002nd"
-  #   ordinalize(1003)  # => "1003rd"
-  def ordinalize(number)
-    if (11..13).include?(number.to_i % 100)
-      "#{number}th"
-    else
-      case number.to_i % 10
-        when 1: "#{number}st"
-        when 2: "#{number}nd"
-        when 3: "#{number}rd"
-        else    "#{number}th"
-      end
-    end
-  end
-end
-
-require File.dirname(__FILE__) + '/inflections'

data/lib/merb/core_ext/kernel.rb

@@ -1,242 +0,0 @@
-module Kernel
-  # Loads the given string as a gem.
-  # An optional second parameter of a version string can be specified and is passed to rubygems.
-  # If rubygems cannot find the gem it requires the string as a library.
-  
-  # Note that this new version tries to load the file via ROOT/gems first before moving off to
-  # the system gems (so if you have a lower version of a gem in ROOT/gems, it'll still get loaded)
-  
-  def dependency(name, *ver)
-    begin
-      # If it's not in ROOT/gems, skip to the next attempt
-      raise LoadError unless File.directory?(Merb.root / "gems")
-      
-      # cache the gem path
-      begin
-        # Clear out the paths and reset them to Merb
-        Gem.use_paths(Merb.root / "gems", [Merb.root / "gems"])
-        
-        # Try activating the gem (Failure will raise a LoadError)
-        Gem.activate(name, true, *ver)
-        Merb.logger.info("#{Time.now.httpdate}: loading gem '#{name}' from #{__app_file_trace__.first} ...")
-      ensure
-        # Either way, set the gem path back to normal
-        Gem.clear_paths
-      end
-
-    # If we couldn't load the gem or there was no ROOT/gems, try again, now with the full gem path
-    rescue LoadError
-      begin
-        # Try activating again
-        Gem.activate(name, true, *ver)
-        Merb.logger.info("#{Time.now.httpdate}: loading gem '#{name}' from #{__app_file_trace__.first} ...")
-      rescue LoadError
-        # Failed requiring as a gem, let's try loading with a normal require.
-        require name
-      end
-    end
-  end
-  
-  # Loads both gem and library dependencies that are passed in as arguments.
-  # Each argument can be:
-  #   String - single dependency
-  #   Hash   - name => version
-  #   Array  - string dependencies
-  
-  def dependencies(*args)
-    args.each do |arg|
-      case arg
-        when String : dependency(arg)
-        when Hash   : arg.each { |r,v| dependency(r, v) }
-        when Array  : arg.each { |r|   dependency(r)    }
-      end
-    end
-  end
-    
-  # Requires the library string passed in.
-  # If the library fails to load then it will display a helpful message.
-  
-  def requires(library)
-    # TODO: Extract messages out into a messages file. This will also be the first step towards internationalization.
-    # TODO: adjust this message once logging refactor is complete.
-    require(library)
-    message = "#{Time.now.httpdate}: loading library '#{library}' from #{__app_file_trace__.first} ..."
-    puts(message)
-    Merb.logger.info(message)
-  rescue LoadError
-    # TODO: adjust the two messages below to use merb's logger.error/info once logging refactor is complete.
-    message = "#{Time.now.httpdate}: <e> Could not find '#{library}' as either a library or gem, loaded from #{__app_file_trace__.first}.\n"
-    puts(message)
-    Merb.logger.error(message)
-    
-    # Print a helpful message
-    message =  "#{Time.now.httpdate}: <i> Please be sure that if '#{library}': \n"
-    message << "#{Time.now.httpdate}: <i>   * is a normal ruby library (file), be sure that the path of the library it is present in the $LOAD_PATH via $LOAD_PATH.unshift(\"/path/to/#{library}\") \n"
-    message << "#{Time.now.httpdate}: <i>   * is included within a gem, be sure that you are specifying the gem as a dependency \n"
-    puts(message)
-    Merb.logger.error(message)
-    exit() # Missing library/gem must be addressed.
-  end
-  
-  # does a basic require, and prints the message passed as an optional
-  # second parameter if an error occurs.
-  
-  def rescue_require(sym, message = nil)
-    require sym
-  rescue LoadError, RuntimeError
-    puts message if message
-  end
-  
-  # Used in Merb.root/dependencies.yml
-  # Tells merb which ORM (Object Relational Mapper) you wish to use.
-  # Currently merb has plugins to support ActiveRecord, DataMapper, and Sequel.
-  #
-  # Example
-  #   $ sudo gem install merb_datamapper # or merb_activerecord or merb_sequel
-  #   use_orm :datamapper # this line goes in dependencies.yml
-  #   $ ruby script/generate model MyModel # will use the appropriate generator for your ORM
-  
-  def use_orm(orm)
-    raise "Don't call use_orm more than once" unless 
-      Merb::GENERATOR_SCOPE.delete(:merb_default)
-    orm = orm.to_sym
-    orm_plugin = orm.to_s.match(/^merb_/) ? orm.to_s : "merb_#{orm}" 
-    Merb::GENERATOR_SCOPE.unshift(orm) unless
-      Merb::GENERATOR_SCOPE.include?(orm)
-    Kernel.dependency(orm_plugin)
-  end
-  
-  # Used in Merb.root/dependencies.yml
-  # Tells merb which testing framework to use.
-  # Currently merb supports rspec and test_unit for testing
-  #
-  # Example
-  #   $ sudo gem install rspec
-  #   use_test :rspec # this line goes in dependencies.yml (or use_test :test_unit)
-  #   $ ruby script/generate controller MyController # will use the appropriate generator for tests
-  
-  def use_test(test_framework)
-    test_framework = test_framework.to_sym
-    raise "use_test only supports :rspec and :test_unit currently" unless
-      [:rspec, :test_unit].include?(test_framework)
-    Merb::GENERATOR_SCOPE.delete(:rspec)
-    Merb::GENERATOR_SCOPE.delete(:test_unit)
-    Merb::GENERATOR_SCOPE.push(test_framework)
-  end
-  
-  # Returns an array with a stack trace of the application's files.
-
-  def __app_file_trace__
-    caller.select do |call| 
-      call.include?(Merb.root) && !call.include?(Merb.root + "/framework")
-    end.map do |call|
-      file, line = call.scan(Regexp.new("#{Merb.root}/(.*):(.*)")).first
-      "#{file}:#{line}"
-    end
-  end
-
-  # Gives you back the file, line and method of the caller number i
-  #
-  # Example
-  #   __caller_info__(1) # -> ['/usr/lib/ruby/1.8/irb/workspace.rb', '52', 'irb_binding']
-
-  def __caller_info__(i = 1)
-    file, line, meth = caller[i].scan(/(.*?):(\d+):in `(.*?)'/).first
-  end
-
-  # Gives you some context around a specific line in a file.
-  # the size argument works in both directions + the actual line,
-  # size = 2 gives you 5 lines of source, the returned array has the
-  # following format.
-  #   [
-  #     line = [
-  #              lineno           = Integer,
-  #              line             = String, 
-  #              is_searched_line = (lineno == initial_lineno)
-  #            ],
-  #     ...,
-  #     ...
-  #   ]
-  # Example
-  #  __caller_lines__('/usr/lib/ruby/1.8/debug.rb', 122, 2) # ->
-  #   [
-  #     [ 120, "  def check_suspend",                               false ],
-  #     [ 121, "    return if Thread.critical",                     false ],
-  #     [ 122, "    while (Thread.critical = true; @suspend_next)", true  ],
-  #     [ 123, "      DEBUGGER__.waiting.push Thread.current",      false ],
-  #     [ 124, "      @suspend_next = false",                       false ]
-  #   ]
-
-  def __caller_lines__(file, line, size = 4)
-    return [['Template Error!', "problem while rendering", false]] if file =~ /\(erubis\)/
-    lines = File.readlines(file)
-    current = line.to_i - 1
-
-    first = current - size
-    first = first < 0 ? 0 : first
-
-    last = current + size
-    last = last > lines.size ? lines.size : last
-
-    log = lines[first..last]
-
-    area = []
-
-    log.each_with_index do |line, index|
-      index = index + first + 1
-      area << [index, line.chomp, index == current + 1]
-    end
-
-    area
-  end
-  
-  # Requires ruby-prof (<tt>sudo gem install ruby-prof</tt>)
-  # Takes a block and profiles the results of running the block 100 times.
-  # The resulting profile is written out to Merb.root/log/#{name}.html.
-  # <tt>min</tt> specifies the minimum percentage of the total time a method must take for it to be included in the result.
-  #
-  # Example
-  #   __profile__("MyProfile", 5) do
-  #     30.times { rand(10)**rand(10) }
-  #     puts "Profile run"
-  #   end
-  # Assuming that the total time taken for #puts calls was less than 5% of the total time to run, #puts won't appear
-  # in the profilel report.
-  
-  def __profile__(name, min=1)
-    require 'ruby-prof' unless defined?(RubyProf)
-    return_result = ''
-    result = RubyProf.profile do
-      100.times{return_result = yield}
-    end
-    printer = RubyProf::GraphHtmlPrinter.new(result)
-    path = File.join(Merb.root, 'log', "#{name}.html")
-    File.open(path, 'w') do |file|
-     printer.print(file, {:min_percent => min,
-                          :print_file => true})
-    end
-    return_result
-  end  
-  
-  # Extracts an options hash if it is the last item in the args array
-  # Used internally in methods that take *args
-  #
-  # Example
-  #   def render(*args,&blk)
-  #     opts = extract_options_from_args!(args) || {}
-  
-  def extract_options_from_args!(args)
-    args.pop if Hash === args.last
-  end
-  
-  unless Kernel.respond_to?(:debugger)
-    # define debugger method so that code even works if debugger was not
-    # requested
-    # Drops a not to the logs that Debugger was not available
-    def debugger
-       Merb.logger.info "\n***** Debugger requested, but was not " + 
-                        "available: Start server with --debugger " +
-                        "to enable *****\n"
-    end
-  end
-end