monetra-ruby 0.0.6

data/lib/monetra/active_support/caching_tools.rb

@@ -0,0 +1,62 @@
+module ActiveSupport
+  module CachingTools #:nodoc:
+    
+    # Provide shortcuts to simply the creation of nested default hashes. This
+    # pattern is useful, common practice, and unsightly when done manually.
+    module HashCaching
+      # Dynamically create a nested hash structure used to cache calls to +method_name+
+      # The cache method is named +#{method_name}_cache+ unless :as => :alternate_name
+      # is given.
+      #
+      # The hash structure is created using nested Hash.new. For example:
+      # 
+      #   def slow_method(a, b) a ** b end
+      # 
+      # can be cached using hash_cache :slow_method, which will define the method
+      # slow_method_cache. We can then find the result of a ** b using:
+      # 
+      #   slow_method_cache[a][b]
+      # 
+      # The hash structure returned by slow_method_cache would look like this:
+      # 
+      #   Hash.new do |as, a|
+      #     as[a] = Hash.new do |bs, b|
+      #       bs[b] = slow_method(a, b)
+      #     end
+      #   end
+      # 
+      # The generated code is actually compressed onto a single line to maintain
+      # sensible backtrace signatures.
+      #
+      def hash_cache(method_name, options = {})
+        selector = options[:as] || "#{method_name}_cache"
+        method = self.instance_method(method_name)
+        
+        args = []
+        code = "def #{selector}(); @#{selector} ||= "
+        
+        (1..method.arity).each do |n|
+          args << "v#{n}"
+          code << "Hash.new {|h#{n}, v#{n}| h#{n}[v#{n}] = "
+        end
+        
+        # Add the method call with arguments, followed by closing braces and end.
+        code << "#{method_name}(#{args * ', '}) #{'}' * method.arity} end"
+        
+        # Extract the line number information from the caller. Exceptions arising
+        # in the generated code should point to the +hash_cache :...+ line.
+        if caller[0] && /^(.*):(\d+)$/ =~ caller[0]
+          file, line_number = $1, $2.to_i
+        else # We can't give good trackback info; fallback to this line:
+          file, line_number = __FILE__, __LINE__
+        end
+        
+        # We use eval rather than building proc's because it allows us to avoid
+        # linking the Hash's to this method's binding. Experience has shown that
+        # doing so can cause obtuse memory leaks.
+        class_eval code, file, line_number
+      end
+    end
+    
+  end
+end

data/lib/monetra/active_support/clean_logger.rb

@@ -0,0 +1,38 @@
+require 'logger'
+require File.dirname(__FILE__) + '/core_ext/class/attribute_accessors'
+
+class Logger #:nodoc:
+  cattr_accessor :silencer
+  self.silencer = true
+
+  # Silences the logger for the duration of the block.
+  def silence(temporary_level = Logger::ERROR)
+    if silencer
+      begin
+        old_logger_level, self.level = level, temporary_level
+        yield self
+      ensure
+        self.level = old_logger_level
+      end
+    else
+      yield self
+    end
+  end
+
+  private
+    alias old_format_message format_message
+
+    # Ruby 1.8.3 transposed the msg and progname arguments to format_message.
+    # We can't test RUBY_VERSION because some distributions don't keep Ruby
+    # and its standard library in sync, leading to installations of Ruby 1.8.2
+    # with Logger from 1.8.3 and vice versa.
+    if method_defined?(:formatter=)
+      def format_message(severity, timestamp, progname, msg)
+        "#{msg}\n"
+      end
+    else
+      def format_message(severity, timestamp, msg, progname)
+        "#{msg}\n"
+      end
+    end
+end

data/lib/monetra/active_support/core_ext.rb

@@ -0,0 +1 @@
+Dir[File.dirname(__FILE__) + "/core_ext/*.rb"].each { |file| require(file) }

data/lib/monetra/active_support/core_ext/array.rb

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/array/conversions'
+require File.dirname(__FILE__) + '/array/grouping'
+
+class Array #:nodoc:
+  include ActiveSupport::CoreExtensions::Array::Conversions
+  include ActiveSupport::CoreExtensions::Array::Grouping
+end

data/lib/monetra/active_support/core_ext/array/conversions.rb

@@ -0,0 +1,72 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Array #:nodoc:
+      module Conversions
+        # Converts the array to comma-seperated sentence where the last element is joined by the connector word. Options:
+        # * <tt>:connector</tt>: The word used to join the last element in arrays with two or more elements (default: "and")
+        # * <tt>:skip_last_comma</tt>: Set to true to return "a, b and c" instead of "a, b, and c".
+        def to_sentence(options = {})
+          options.assert_valid_keys(:connector, :skip_last_comma)
+          options.reverse_merge! :connector => 'and', :skip_last_comma => false
+          
+          case length
+          	when 0
+          		""
+            when 1
+              self[0]
+            when 2
+              "#{self[0]} #{options[:connector]} #{self[1]}"
+            else
+              "#{self[0...-1].join(', ')}#{options[:skip_last_comma] ? '' : ','} #{options[:connector]} #{self[-1]}"
+          end
+        end
+
+        # When an array is given to url_for, it is converted to a slash separated string.
+        def to_param
+          join '/'
+        end
+        
+        def self.included(klass) #:nodoc:
+          klass.send(:alias_method, :to_default_s, :to_s)
+          klass.send(:alias_method, :to_s, :to_formatted_s)
+        end
+        
+        def to_formatted_s(format = :default)
+          case format
+            when :db
+              if respond_to?(:empty?) && self.empty?
+                "null"
+              else
+                collect { |element| element.id }.join(",")
+              end
+            else
+              to_default_s
+          end
+        end
+        
+        def to_xml(options = {})
+          raise "Not all elements respond to to_xml" unless all? { |e| e.respond_to? :to_xml }
+
+          options[:root]     ||= all? { |e| e.is_a?(first.class) && first.class.to_s != "Hash" } ? first.class.to_s.underscore.pluralize : "records"
+          options[:children] ||= options[:root].singularize
+          options[:indent]   ||= 2
+          options[:builder]  ||= Builder::XmlMarkup.new(:indent => options[:indent])
+
+          root     = options.delete(:root).to_s
+          children = options.delete(:children)
+
+          if !options.has_key?(:dasherize) || options[:dasherize]
+            root = root.dasherize
+          end
+
+          options[:builder].instruct! unless options.delete(:skip_instruct)
+
+          opts = options.merge({ :skip_instruct => true, :root => children })
+
+          options[:builder].tag!(root) { each { |e| e.to_xml(opts) } }
+        end
+
+      end
+    end
+  end
+end

data/lib/monetra/active_support/core_ext/array/grouping.rb

@@ -0,0 +1,46 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Array #:nodoc:
+      module Grouping
+        # Iterate over an array in groups of a certain size, padding any remaining 
+        # slots with specified value (<tt>nil</tt> by default).
+        # 
+        # E.g.
+        # 
+        #   %w(1 2 3 4 5 6 7).in_groups_of(3) {|g| p g}
+        #   ["1", "2", "3"]
+        #   ["4", "5", "6"]
+        #   ["7", nil, nil]
+        def in_groups_of(number, fill_with = nil, &block)
+          require 'enumerator'
+          collection = dup
+          collection << fill_with until collection.size.modulo(number).zero?
+          grouped_collection = [] unless block_given?
+          collection.each_slice(number) do |group|
+            block_given? ? yield(group) : grouped_collection << group
+          end
+          grouped_collection unless block_given?
+        end
+
+        # Divide the array into one or more subarrays based on a delimiting +value+
+        # or the result of an optional block.
+        #
+        # ex.
+        #
+        #   [1, 2, 3, 4, 5].split(3)                # => [[1, 2], [4, 5]]
+        #   (1..10).to_a.split { |i| i % 3 == 0 }   # => [[1, 2], [4, 5], [7, 8], [10]]
+        def split(value = nil, &block)
+          block ||= Proc.new { |e| e == value }
+          inject([[]]) do |results, element|
+            if block.call(element)
+              results << []
+            else
+              results.last << element
+            end
+            results
+          end
+        end
+      end
+    end
+  end
+end

data/lib/monetra/active_support/core_ext/bigdecimal.rb

@@ -0,0 +1,3 @@
+require 'bigdecimal'
+
+require File.dirname(__FILE__) + '/bigdecimal/formatting.rb'

data/lib/monetra/active_support/core_ext/bigdecimal/formatting.rb

@@ -0,0 +1,7 @@
+class BigDecimal #:nodoc:
+  
+  alias :_original_to_s :to_s
+  def to_s(format="F")
+    _original_to_s(format)
+  end
+end

data/lib/monetra/active_support/core_ext/blank.rb

@@ -0,0 +1,50 @@
+class Object #:nodoc:
+  # "", "   ", nil, [], and {} are blank
+  def blank?
+    if respond_to?(:empty?) && respond_to?(:strip)
+      empty? or strip.empty?
+    elsif respond_to?(:empty?)
+      empty?
+    else
+      !self
+    end
+  end
+end
+
+class NilClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class FalseClass #:nodoc:
+  def blank?
+    true
+  end
+end
+
+class TrueClass #:nodoc:
+  def blank?
+    false
+  end
+end
+
+class Array #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class Hash #:nodoc:
+  alias_method :blank?, :empty?
+end
+
+class String #:nodoc:
+  def blank?
+    empty? || strip.empty?
+  end
+end
+
+class Numeric #:nodoc:
+  def blank?
+    false
+  end
+end

data/lib/monetra/active_support/core_ext/cgi.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__) + '/cgi/escape_skipping_slashes'
+
+class CGI #:nodoc:
+  extend(ActiveSupport::CoreExtensions::CGI::EscapeSkippingSlashes)
+end

data/lib/monetra/active_support/core_ext/cgi/escape_skipping_slashes.rb

@@ -0,0 +1,14 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module CGI #:nodoc:
+      module EscapeSkippingSlashes #:nodoc:
+        def escape_skipping_slashes(str)
+          str = str.join('/') if str.respond_to? :join
+          str.gsub(/([^ \/a-zA-Z0-9_.-])/n) do
+            "%#{$1.unpack('H2').first.upcase}"
+          end.tr(' ', '+')
+        end
+      end
+    end
+  end
+end

data/lib/monetra/active_support/core_ext/class.rb

@@ -0,0 +1,3 @@
+require File.dirname(__FILE__) + '/class/attribute_accessors'
+require File.dirname(__FILE__) + '/class/inheritable_attributes'
+require File.dirname(__FILE__) + '/class/removal'

data/lib/monetra/active_support/core_ext/class/attribute_accessors.rb

@@ -0,0 +1,44 @@
+# Extends the class object with class and instance accessors for class attributes,
+# just like the native attr* accessors for instance attributes.
+class Class # :nodoc:
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+
+  def cattr_writer(*syms)
+    syms.flatten.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+
+        def #{sym}=(obj)
+          @@#{sym} = obj
+        end
+      EOS
+    end
+  end
+
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+end

data/lib/monetra/active_support/core_ext/class/inheritable_attributes.rb

@@ -0,0 +1,115 @@
+# Retain for backward compatibility.  Methods are now included in Class.
+module ClassInheritableAttributes # :nodoc:
+end
+
+# Allows attributes to be shared within an inheritance hierarchy, but where each descendant gets a copy of
+# their parents' attributes, instead of just a pointer to the same. This means that the child can add elements
+# to, for example, an array without those additions being shared with either their parent, siblings, or
+# children, which is unlike the regular class-level attributes that are shared across the entire hierarchy.
+class Class # :nodoc:
+  def class_inheritable_reader(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}
+          read_inheritable_attribute(:#{sym})
+        end
+
+        def #{sym}
+          self.class.#{sym}
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_attribute(:#{sym}, obj)
+        end
+
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_array_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_array(:#{sym}, obj)
+        end
+
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_hash_writer(*syms)
+    syms.each do |sym|
+      class_eval <<-EOS
+        def self.#{sym}=(obj)
+          write_inheritable_hash(:#{sym}, obj)
+        end
+
+        def #{sym}=(obj)
+          self.class.#{sym} = obj
+        end
+      EOS
+    end
+  end
+
+  def class_inheritable_accessor(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_writer(*syms)
+  end
+
+  def class_inheritable_array(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_array_writer(*syms)
+  end
+
+  def class_inheritable_hash(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_hash_writer(*syms)
+  end
+
+  def inheritable_attributes
+    @inheritable_attributes ||= {}
+  end
+  
+  def write_inheritable_attribute(key, value)
+    inheritable_attributes[key] = value
+  end
+  
+  def write_inheritable_array(key, elements)
+    write_inheritable_attribute(key, []) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key) + elements)
+  end
+
+  def write_inheritable_hash(key, hash)
+    write_inheritable_attribute(key, {}) if read_inheritable_attribute(key).nil?
+    write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
+  end
+
+  def read_inheritable_attribute(key)
+    inheritable_attributes[key]
+  end
+  
+  def reset_inheritable_attributes
+    inheritable_attributes.clear
+  end
+
+  private 
+    def inherited_with_inheritable_attributes(child)
+      inherited_without_inheritable_attributes(child) if respond_to?(:inherited_without_inheritable_attributes)
+      child.instance_variable_set('@inheritable_attributes', inheritable_attributes.dup)
+    end
+
+    alias inherited_without_inheritable_attributes inherited
+    alias inherited inherited_with_inheritable_attributes
+end