weasel_diesel 1.0.0

data/lib/framework_ext/sinatra.rb

@@ -0,0 +1,30 @@
+# Module used to extend {WeaselDiesel} and add {#load_sinatra_route} to services.
+# This code is Sinatra specific and therefore lives outside the {WeaselDiesel}
+# @see {WeaselDiesel}
+# @api public
+module WeaselDieselSinatraExtension
+  
+  # Defines a sinatra service route based on its settings
+  #
+  # @return [Nil]
+  # @api private
+  def load_sinatra_route
+    service     = self
+    upcase_verb = service.verb.to_s.upcase
+    puts "/#{self.url} -> #{self.controller_name}##{self.action} - (#{upcase_verb})"
+
+    # Define the route directly to save some object allocations on the critical path
+    # Note that we are using a private API to define the route and that unlike sinatra usual DSL
+    # we do NOT define a HEAD route for every GET route.
+    Sinatra::Base.send(:route, upcase_verb, "/#{self.url}") do
+      service.controller_dispatch(self)
+    end
+
+    # Other alternative to the route definition, this time using the public API
+    # self.send(verb, "/#{service.url}") do
+    #   service.controller_dispatch(self)
+    # end
+
+  end
+  
+end

data/lib/framework_ext/sinatra_controller.rb

@@ -0,0 +1,80 @@
+require 'forwardable'
+require File.expand_path('./../params_verification', File.dirname(__FILE__))
+
+# Base code shared by all service controllers
+# This allows us to share code between controllers
+# more precisely to render templates and in general to use sinatra helpers
+#
+# @see Sinatra::Base and Sinatra::Helpers
+# @api public
+# @author Matt Aimonetti
+class SinatraServiceController
+  extend Forwardable
+  
+  # The service controller might be loaded outside of a Sinatra App
+  # in this case, we don't need to load the helpers
+  if Object.const_defined?(:Sinatra)
+    include Sinatra::Helpers 
+  end
+  
+  class AuthenticationFailed < StandardError; end
+  
+  # @return [WeaselDiesel] The service served by this controller
+  # @api public
+  attr_reader :service
+  
+  # @return [Sinatra::Application]
+  # @api public
+  attr_reader :app
+  
+  # @return [Hash]
+  # @api public
+  attr_reader :env
+  
+  # @return [Sinatra::Request]
+  # @see http://rubydoc.info/github/sinatra/sinatra/Sinatra/Request
+  # @api public
+  attr_reader :request
+  
+  # @return [Sinatra::Response]
+  # @see http://rubydoc.info/github/sinatra/sinatra/Sinatra/Response
+  # @api public
+  attr_reader :response
+  
+  # @return [Hash]
+  # @api public
+  attr_accessor :params
+  
+  # @param [Sinatra::Application] app The Sinatra app used as a reference and to access request params
+  # @param [WeaselDiesel] service The service served by this controller
+  # @raise [ParamError, NoParamsDefined, MissingParam, UnexpectedParam, InvalidParamType, InvalidParamValue] 
+  #   If the params don't validate one of the {ParamsVerification} errors will be raised.
+  # @api public
+  def initialize(app, service)
+    @app      = app
+    @env      = app.env
+    @request  = app.request
+    @response = app.response
+    @service  = service
+   
+    # raises an exception if the params are not valid
+    # otherwise update the app params with potentially new params (using default values)   
+    # note that if a type if mentioned for a params, the object will be cast to this object type 
+    @params = app.params = ParamsVerification.validate!(app.params, service.defined_params)
+
+    # Authentication check
+    if service.auth_required
+      raise AuthenticationFailed unless logged_in?
+    end
+  end
+  
+
+  # Forwarding some methods to the underlying app object
+  def_delegators :app, :settings, :halt, :compile_template, :session
+
+  # Returns true or false if the player is logged in.
+  def logged_in?
+    !session[:player_id].nil?
+  end
+    
+end

data/lib/inflection.rb

@@ -0,0 +1,460 @@
+#Copyright (c) 2010 Dan Kubb
+
+#Permission is hereby granted, free of charge, to any person obtaining
+#a copy of this software and associated documentation files (the
+#"Software"), to deal in the Software without restriction, including
+#without limitation the rights to use, copy, modify, merge, publish,
+#distribute, sublicense, and/or sell copies of the Software, and to
+#permit persons to whom the Software is furnished to do so, subject to
+#the following conditions:
+
+#The above copyright notice and this permission notice shall be
+#included in all copies or substantial portions of the Software.
+
+#THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+#EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+#MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+#NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+#LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+#OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+#WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#---
+
+# Modified for the need of this software package
+
+module ExtlibCopy
+
+  # Same as Inflection.classify but without the singularization
+  def self.classify(name)
+    words = name.to_s.sub(/.*\./, '').split('_')
+    words.collect { |word| word.capitalize }.join
+  end
+
+  # = English Nouns Number Inflection.
+  #
+  # This module provides english singular <-> plural noun inflections.
+  module Inflection
+
+    class << self
+      # Take an underscored name and make it into a camelized name
+      #
+      # @example
+      #   "egg_and_hams".classify #=> "EggAndHam"
+      #   "enlarged_testes".classify #=> "EnlargedTestis"
+      #   "post".classify #=> "Post"
+      #
+      def classify(name)
+        words = name.to_s.sub(/.*\./, '').split('_')
+        words[-1] = singularize(words[-1])
+        words.collect { |word| word.capitalize }.join
+      end
+
+      # By default, camelize converts strings to UpperCamelCase.
+      #
+      # camelize will also convert '/' to '::' which is useful for converting paths to namespaces
+      #
+      # @example
+      #   "active_record".camelize #=> "ActiveRecord"
+      #   "active_record/errors".camelize #=> "ActiveRecord::Errors"
+      #
+      def camelize(lower_case_and_underscored_word, *args)
+        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+      end
+
+
+      # The reverse of +camelize+. Makes an underscored form from the expression in the string.
+      #
+      # Changes '::' to '/' to convert namespaces to paths.
+      #
+      # @example
+      #   "ActiveRecord".underscore #=> "active_record"
+      #   "ActiveRecord::Errors".underscore #=> active_record/errors
+      #
+      def underscore(camel_cased_word)
+        camel_cased_word.to_const_path
+      end
+
+      # Capitalizes the first word and turns underscores into spaces and strips _id.
+      # Like titleize, this is meant for creating pretty output.
+      #
+      # @example
+      #   "employee_salary" #=> "Employee salary"
+      #   "author_id" #=> "Author"
+      def humanize(lower_case_and_underscored_word)
+        lower_case_and_underscored_word.to_s.gsub(/_id$/, '').tr('_', ' ').capitalize
+      end
+
+      # Removes the module part from the expression in the string
+      #
+      # @example
+      #   "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.
+      #
+      # @example
+      #   "RawScaledScorer".tableize #=> "raw_scaled_scorers"
+      #   "EnlargedTestis".tableize #=> "enlarged_testes"
+      #   "egg_and_ham".tableize #=> "egg_and_hams"
+      #   "fancyCategory".tableize #=> "fancy_categories"
+      def tableize(class_name)
+        words = class_name.to_const_path.tr('/', '_').split('_')
+        words[-1] = pluralize(words[-1])
+        words.join('_')
+      end
+
+      # Creates a foreign key name from a class name.
+      #
+      # @example
+      #   "Message".foreign_key #=> "message_id"
+      #   "Admin::Post".foreign_key #=> "post_id"
+      def foreign_key(class_name, key = "id")
+        underscore(demodulize(class_name.to_s)) << "_" << key.to_s
+      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.
+      #
+      # @example
+      #   "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
+    end
+
+    @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:
+      #
+      # English::Inflect.word "erratum", "errata"
+      #
+      # In case singular and plural forms are the same omit
+      # second argument on call:
+      #
+      # English::Inflect.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:
+      # English::Inflect.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:
+      # English::Inflect.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:
+      # English::Inflect.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 plural 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 plural.
+      #
+      #   "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 'fish'
+    word 'grass'
+    word 'hovercraft'
+    word 'information'
+    word 'milk'
+    word 'money'
+    word 'moose'
+    word 'plurals'
+    word 'postgres'
+    word 'rain'
+    word 'rice'
+    word 'series'
+    word 'sheep'
+    word 'species'
+    word 'status'
+
+    # Two arguments defines a singular and plural exception.
+    word 'alias'      , 'aliases'
+    word 'analysis'   , 'analyses'
+    word 'axis'       , 'axes'
+    word 'basis'      , 'bases'
+    word 'buffalo'    , 'buffaloes'
+    word 'cactus'     , 'cacti'
+    word 'crisis'     , 'crises'
+    word 'criterion'  , 'criteria'
+    word 'cross'      , 'crosses'
+    word 'datum'      , 'data'
+    word 'diagnosis'  , 'diagnoses'
+    word 'drive'      , 'drives'
+    word 'erratum'    , 'errata'
+    word 'goose'      , 'geese'
+    word 'index'      , 'indices'
+    word 'life'       , 'lives'
+    word 'louse'      , 'lice'
+    word 'matrix'     , 'matrices'
+    word 'medium'     , 'media'
+    word 'mouse'      , 'mice'
+    word 'movie'      , 'movies'
+    word 'octopus'    , 'octopi'
+    word 'ox'         , 'oxen'
+    word 'phenomenon' , 'phenomena'
+    word 'plus'       , 'plusses'
+    word 'potato'     , 'potatoes'
+    word 'quiz'       , 'quizzes'
+    word 'status'     , 'status'
+    word 'status'     , 'statuses'
+    word 'Swiss'      , 'Swiss'
+    word 'testis'     , 'testes'
+    word 'thesaurus'  , 'thesauri'
+    word 'thesis'     , 'theses'
+    word 'thief'      , 'thieves'
+    word 'tomato'     , 'tomatoes'
+    word 'torpedo'    , 'torpedoes'
+    word 'vertex'     , 'vertices'
+    word 'wife'       , 'wives'
+
+    # 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