monetra-ruby 0.0.6

data/lib/monetra/active_support/deprecation.rb

@@ -0,0 +1,106 @@
+module ActiveSupport
+  module Deprecation
+    # Choose the default warn behavior according to RAILS_ENV.
+    # Ignore deprecation warnings in production.
+    DEFAULT_BEHAVIORS = {
+      'test'        => Proc.new { |message| $stderr.puts message },
+      'development' => Proc.new { |message| RAILS_DEFAULT_LOGGER.warn message },
+    }
+
+    class << self
+      def warn(message = nil, callstack = caller)
+        behavior.call(deprecation_message(callstack, message)) if behavior
+      end
+
+      def default_behavior
+        DEFAULT_BEHAVIORS[RAILS_ENV.to_s] if defined?(RAILS_ENV)
+      end
+
+      private
+        def deprecation_message(callstack, message = nil)
+          file, line, method = extract_callstack(callstack)
+          message ||= "WARNING: #{method} is deprecated and will be removed from the next Rails release"
+          "#{message} (#{method} at #{file}:#{line})"
+        end
+
+        def extract_callstack(callstack)
+          callstack.first.match(/^(.+?):(\d+)(?::in `(.*?)')?/).captures
+        end
+    end
+
+    # Behavior is a block that takes a message argument.
+    mattr_accessor :behavior
+    self.behavior = default_behavior
+
+    module ClassMethods
+      # Declare that a method has been deprecated.
+      def deprecate(*method_names)
+        method_names.each do |method_name|
+          class_eval(<<-EOS, __FILE__, __LINE__)
+            def #{method_name}_with_deprecation(*args, &block)
+              ::ActiveSupport::Deprecation.warn
+              #{method_name}_without_deprecation(*args, &block)
+            end
+          EOS
+          alias_method_chain(method_name, :deprecation)
+        end
+      end
+    end
+
+    module Assertions
+      def assert_deprecated(match = nil, &block)
+        last = with_last_message_tracking_deprecation_behavior(&block)
+        assert last, "Expected a deprecation warning within the block but received none"
+        match = Regexp.new(Regexp.escape(match)) unless match.is_a?(Regexp)
+        assert_match match, last, "Deprecation warning didn't match #{match}: #{last}"
+      end
+
+      def assert_not_deprecated(&block)
+        last = with_last_message_tracking_deprecation_behavior(&block)
+        assert_nil last, "Expected no deprecation warning within the block but received one: #{last}"
+      end
+
+      private
+        def with_last_message_tracking_deprecation_behavior
+          old_behavior = ActiveSupport::Deprecation.behavior
+          last_message = nil
+          ActiveSupport::Deprecation.behavior = Proc.new { |message| last_message = message; old_behavior.call(message) if old_behavior }
+          yield
+          last_message
+        ensure
+          ActiveSupport::Deprecation.behavior = old_behavior
+        end
+    end
+
+    # Stand-in for @request, @attributes, etc.
+    class DeprecatedInstanceVariableProxy
+      instance_methods.each { |m| undef_method m unless m =~ /^__/ }
+
+      def initialize(instance, method, var = "@#{method}")
+        @instance, @method, @var = instance, method, var
+      end
+
+      private
+        def warn(callstack, called, args)
+          ActiveSupport::Deprecation.warn("#{@var} is deprecated! Call #{@method}.#{called} instead of #{@var}.#{called}. Args: #{args.inspect}", callstack)
+        end
+
+        def method_missing(called, *args, &block)
+          warn caller, called, args
+          @instance.__send__(@method).__send__(called, *args, &block)
+        end
+    end
+  end
+end
+
+class Class
+  include ActiveSupport::Deprecation::ClassMethods
+end
+
+module Test
+  module Unit
+    class TestCase
+      include ActiveSupport::Deprecation::Assertions
+    end
+  end
+end

data/lib/monetra/active_support/inflections.rb

@@ -0,0 +1,53 @@
+Inflector.inflections do |inflect|
+  inflect.plural(/$/, 's')
+  inflect.plural(/s$/i, 's')
+  inflect.plural(/(ax|test)is$/i, '\1es')
+  inflect.plural(/(octop|vir)us$/i, '\1i')
+  inflect.plural(/(alias|status)$/i, '\1es')
+  inflect.plural(/(bu)s$/i, '\1ses')
+  inflect.plural(/(buffal|tomat)o$/i, '\1oes')
+  inflect.plural(/([ti])um$/i, '\1a')
+  inflect.plural(/sis$/i, 'ses')
+  inflect.plural(/(?:([^f])fe|([lr])f)$/i, '\1\2ves')
+  inflect.plural(/(hive)$/i, '\1s')
+  inflect.plural(/([^aeiouy]|qu)y$/i, '\1ies')
+  inflect.plural(/([^aeiouy]|qu)ies$/i, '\1y')
+  inflect.plural(/(x|ch|ss|sh)$/i, '\1es')
+  inflect.plural(/(matr|vert|ind)ix|ex$/i, '\1ices')
+  inflect.plural(/([m|l])ouse$/i, '\1ice')
+  inflect.plural(/^(ox)$/i, '\1en')
+  inflect.plural(/(quiz)$/i, '\1zes')
+
+  inflect.singular(/s$/i, '')
+  inflect.singular(/(n)ews$/i, '\1ews')
+  inflect.singular(/([ti])a$/i, '\1um')
+  inflect.singular(/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1\2sis')
+  inflect.singular(/(^analy)ses$/i, '\1sis')
+  inflect.singular(/([^f])ves$/i, '\1fe')
+  inflect.singular(/(hive)s$/i, '\1')
+  inflect.singular(/(tive)s$/i, '\1')
+  inflect.singular(/([lr])ves$/i, '\1f')
+  inflect.singular(/([^aeiouy]|qu)ies$/i, '\1y')
+  inflect.singular(/(s)eries$/i, '\1eries')
+  inflect.singular(/(m)ovies$/i, '\1ovie')
+  inflect.singular(/(x|ch|ss|sh)es$/i, '\1')
+  inflect.singular(/([m|l])ice$/i, '\1ouse')
+  inflect.singular(/(bus)es$/i, '\1')
+  inflect.singular(/(o)es$/i, '\1')
+  inflect.singular(/(shoe)s$/i, '\1')
+  inflect.singular(/(cris|ax|test)es$/i, '\1is')
+  inflect.singular(/(octop|vir)i$/i, '\1us')
+  inflect.singular(/(alias|status)es$/i, '\1')
+  inflect.singular(/^(ox)en/i, '\1')
+  inflect.singular(/(vert|ind)ices$/i, '\1ex')
+  inflect.singular(/(matr)ices$/i, '\1ix')
+  inflect.singular(/(quiz)zes$/i, '\1')
+
+  inflect.irregular('person', 'people')
+  inflect.irregular('man', 'men')
+  inflect.irregular('child', 'children')
+  inflect.irregular('sex', 'sexes')
+  inflect.irregular('move', 'moves')
+
+  inflect.uncountable(%w(equipment information rice money species series fish sheep))
+end

data/lib/monetra/active_support/inflector.rb

@@ -0,0 +1,179 @@
+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
+
+  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
+
+  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
+
+  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
+
+  def titleize(word)
+    humanize(underscore(word)).gsub(/\b([a-z])/) { $1.capitalize }
+  end
+  
+  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
+  
+  def dasherize(underscored_word)
+    underscored_word.gsub(/_/, '-')
+  end
+
+  def humanize(lower_case_and_underscored_word)
+    lower_case_and_underscored_word.to_s.gsub(/_id$/, "").gsub(/_/, " ").capitalize
+  end
+
+  def demodulize(class_name_in_module)
+    class_name_in_module.to_s.gsub(/^.*::/, '')
+  end
+
+  def tableize(class_name)
+    pluralize(underscore(class_name))
+  end
+  
+  def classify(table_name)
+    # strip out any leading schema name
+    camelize(singularize(table_name.to_s.sub(/.*\./, '')))
+  end
+
+  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
+
+  def constantize(camel_cased_word)
+    raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!" unless
+      /^(::)?([A-Z]\w*)(::[A-Z]\w*)*$/ =~ camel_cased_word
+    
+    camel_cased_word = "::#{camel_cased_word}" unless $1
+    Object.module_eval(camel_cased_word, __FILE__, __LINE__)
+  end
+
+  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/monetra/active_support/json.rb

@@ -0,0 +1,37 @@
+require 'active_support/json/encoders'
+
+module ActiveSupport
+  module JSON #:nodoc:
+    class CircularReferenceError < StandardError #:nodoc:
+    end
+    # returns the literal string as its JSON encoded form.  Useful for passing javascript variables into functions.
+    #
+    # page.call 'Element.show', ActiveSupport::JSON::Variable.new("$$(#items li)")
+    class Variable < String #:nodoc:
+      def to_json
+        self
+      end
+    end
+
+    class << self
+      REFERENCE_STACK_VARIABLE = :json_reference_stack
+      
+      def encode(value)
+        raise_on_circular_reference(value) do
+          Encoders[value.class].call(value)
+        end
+      end
+      
+      protected
+        def raise_on_circular_reference(value)
+          stack = Thread.current[REFERENCE_STACK_VARIABLE] ||= []
+          raise CircularReferenceError, 'object references itself' if
+            stack.include? value
+          stack << value
+          yield
+        ensure
+          stack.pop
+        end
+    end
+  end
+end

data/lib/monetra/active_support/json/encoders.rb

@@ -0,0 +1,25 @@
+module ActiveSupport
+  module JSON #:nodoc:
+    module Encoders
+      mattr_accessor :encoders
+      @@encoders = {}
+
+      class << self        
+        def define_encoder(klass, &block)
+          encoders[klass] = block
+        end
+        
+        def [](klass)
+          klass.ancestors.each do |k|
+            encoder = encoders[k]
+            return encoder if encoder
+          end
+        end
+      end
+    end
+  end
+end
+
+Dir[File.dirname(__FILE__) + '/encoders/*.rb'].each do |file|
+  require file[0..-4]
+end

data/lib/monetra/active_support/json/encoders/core.rb

@@ -0,0 +1,65 @@
+module ActiveSupport
+  module JSON #:nodoc:
+    module Encoders #:nodoc:
+      define_encoder Object do |object|
+        object.instance_values.to_json
+      end
+      
+      define_encoder TrueClass do
+        'true'
+      end
+      
+      define_encoder FalseClass do
+        'false'
+      end
+      
+      define_encoder NilClass do
+        'null'
+      end
+      
+      define_encoder String do |string|
+        returning value = '"' do
+          string.each_char do |char|
+            value << case
+            when char == "\010":  '\b'
+            when char == "\f":    '\f'
+            when char == "\n":    '\n'
+            when char == "\r":    '\r'
+            when char == "\t":    '\t'
+            when char == '"':     '\"'
+            when char == '\\':    '\\\\'  
+            when char.length > 1: "\\u#{'%04x' % char.unpack('U').first}"
+            else;                 char
+            end
+          end
+          value << '"'
+        end
+      end
+      
+      define_encoder Numeric do |numeric|
+        numeric.to_s
+      end
+      
+      define_encoder Symbol do |symbol|
+        symbol.to_s.to_json
+      end
+
+      define_encoder Enumerable do |enumerable|
+        "[#{enumerable.map { |value| value.to_json } * ', '}]"
+      end
+      
+      define_encoder Hash do |hash|
+        returning result = '{' do
+          result << hash.map do |pair|
+            pair.map { |value| value.to_json } * ': '
+          end * ', '
+          result << '}'
+        end
+      end
+
+      define_encoder Regexp do |regexp|
+        regexp.inspect
+      end
+    end
+  end
+end