monetra-ruby 0.0.6

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

@@ -0,0 +1,24 @@
+class Class #:nodoc:
+  def remove_subclasses
+    Object.remove_subclasses_of(self)
+  end
+
+  def subclasses
+    Object.subclasses_of(self).map { |o| o.to_s }
+  end
+
+  def remove_class(*klasses)
+    klasses.flatten.each do |klass|
+      # Skip this class if there is nothing bound to this name
+      next unless defined?(klass.name)
+      
+      basename = klass.to_s.split("::").last
+      parent = klass.parent
+      
+      # Skip this class if it does not match the current one bound to this name
+      next unless parent.const_defined?(basename) && klass = parent.const_get(basename)
+      
+      parent.send :remove_const, basename unless parent == klass
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+require 'date'
+require File.dirname(__FILE__) + '/date/conversions'
+
+class Date#:nodoc:
+  include ActiveSupport::CoreExtensions::Date::Conversions
+end

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

@@ -0,0 +1,39 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Date #:nodoc:
+      # Getting dates in different convenient string representations and other objects
+      module Conversions
+        DATE_FORMATS = {
+          :short => "%e %b",
+          :long  => "%B %e, %Y"
+        }
+
+        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)
+          DATE_FORMATS[format] ? strftime(DATE_FORMATS[format]).strip : to_default_s
+        end
+
+        # To be able to keep Dates and Times interchangeable on conversions
+        def to_date
+          self
+        end
+
+        def to_time(form = :local)
+          if respond_to?(:hour)
+            ::Time.send(form, year, month, day, hour, min, sec)
+          else
+            ::Time.send(form, year, month, day)
+          end
+        end
+
+        def xmlschema
+          to_time.xmlschema
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Enumerable #:nodoc:
+  # Collect an enumerable into sets, grouped by the result of a block. Useful,
+  # for example, for grouping records by date.
+  #
+  # e.g. 
+  #
+  #   latest_transcripts.group_by(&:day).each do |day, transcripts| 
+  #     p "#{day} -> #{transcripts.map(&:class) * ', '}"
+  #   end
+  #   "2006-03-01 -> Transcript"
+  #   "2006-02-28 -> Transcript"
+  #   "2006-02-27 -> Transcript, Transcript"
+  #   "2006-02-26 -> Transcript, Transcript"
+  #   "2006-02-25 -> Transcript"
+  #   "2006-02-24 -> Transcript, Transcript"
+  #   "2006-02-23 -> Transcript"
+  def group_by
+    inject({}) do |groups, element|
+      (groups[yield(element)] ||= []) << element
+      groups
+    end
+  end 
+
+  # Calculates a sum from the elements. Examples:
+  #
+  #  payments.sum { |p| p.price * p.tax_rate }
+  #  payments.sum(&:price)
+  #
+  # This is instead of payments.inject { |sum, p| sum + p.price }
+  #
+  # Also calculates sums without the use of a block:
+  #   [5, 15, 10].sum # => 30
+  #
+  # The default identity (sum of an empty list) is zero. 
+  # However, you can override this default:
+  #
+  # [].sum(Payment.new(0)) { |i| i.amount } # => Payment.new(0)
+  #
+  def sum(identity = 0, &block)
+    return identity unless size > 0
+    if block_given?
+      map(&block).sum
+    else
+      inject { |sum, element| sum + element }
+    end
+  end
+
+  # Convert an enumerable to a hash. Examples:
+  # 
+  #   people.index_by(&:login)
+  #     => { "nextangle" => <Person ...>, "chade-" => <Person ...>, ...}
+  #   people.index_by { |person| "#{person.first_name} #{person.last_name}" }
+  #     => { "Chade- Fowlersburg-e" => <Person ...>, "David Heinemeier Hansson" => <Person ...>, ...}
+  # 
+  def index_by
+    inject({}) do |accum, elem|
+      accum[yield(elem)] = elem
+      accum
+    end
+  end
+  
+end

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

@@ -0,0 +1,33 @@
+class Exception # :nodoc:
+  def clean_message
+    Pathname.clean_within message
+  end
+  
+  TraceSubstitutions = []
+  FrameworkRegexp = /generated|vendor|dispatch|ruby|script\/\w+/
+  
+  def clean_backtrace
+    backtrace.collect do |line|
+      Pathname.clean_within(TraceSubstitutions.inject(line) do |line, (regexp, sub)|
+        line.gsub regexp, sub
+      end)
+    end
+  end
+  
+  def application_backtrace
+    before_application_frame = true
+    
+    trace = clean_backtrace.reject do |line|
+      non_app_frame = (line =~ FrameworkRegexp)
+      before_application_frame = false unless non_app_frame
+      non_app_frame && ! before_application_frame
+    end
+    
+    # If we didn't find any application frames, return an empty app trace.
+    before_application_frame ? [] : trace
+  end
+  
+  def framework_backtrace
+    clean_backtrace.select {|line| line =~ FrameworkRegexp}
+  end
+end

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

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/hash/keys'
+require File.dirname(__FILE__) + '/hash/indifferent_access'
+require File.dirname(__FILE__) + '/hash/reverse_merge'
+require File.dirname(__FILE__) + '/hash/conversions'
+require File.dirname(__FILE__) + '/hash/diff'
+
+class Hash #:nodoc:
+  include ActiveSupport::CoreExtensions::Hash::Keys
+  include ActiveSupport::CoreExtensions::Hash::IndifferentAccess
+  include ActiveSupport::CoreExtensions::Hash::ReverseMerge
+  include ActiveSupport::CoreExtensions::Hash::Conversions
+  include ActiveSupport::CoreExtensions::Hash::Diff
+end

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

@@ -0,0 +1,148 @@
+require 'date'
+require 'xml_simple'
+
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Hash #:nodoc:
+      module Conversions
+        XML_TYPE_NAMES = {
+          ::Fixnum     => "integer",
+          ::Float      => "float",
+          ::Date       => "date",
+          ::DateTime   => "datetime",
+          ::Time       => "datetime",
+          ::TrueClass  => "boolean",
+          ::FalseClass => "boolean"
+        } unless defined? XML_TYPE_NAMES
+
+        XML_FORMATTING = {
+          "date"     => Proc.new { |date| date.to_s(:db) },
+          "datetime" => Proc.new { |time| time.xmlschema },
+          "binary"   => Proc.new { |binary| Base64.encode64(binary) }
+        } unless defined? XML_FORMATTING
+
+        def self.included(klass)
+          klass.extend(ClassMethods)
+        end
+
+        def to_xml(options = {})
+          options[:indent] ||= 2
+          options.reverse_merge!({ :builder => Builder::XmlMarkup.new(:indent => options[:indent]),
+                                   :root => "hash" })
+          options[:builder].instruct! unless options.delete(:skip_instruct)
+          dasherize = !options.has_key?(:dasherize) || options[:dasherize]
+          root = dasherize ? options[:root].to_s.dasherize : options[:root].to_s
+
+          options[:builder].__send__(root) do
+            each do |key, value|
+              case value
+                when ::Hash
+                  value.to_xml(options.merge({ :root => key, :skip_instruct => true }))
+                when ::Array
+                  value.to_xml(options.merge({ :root => key, :children => key.to_s.singularize, :skip_instruct => true}))
+                when ::Method, ::Proc
+                  # If the Method or Proc takes two arguments, then
+                  # pass the suggested child element name.  This is
+                  # used if the Method or Proc will be operating over
+                  # multiple records and needs to create an containing
+                  # element that will contain the objects being
+                  # serialized.
+                  if 1 == value.arity
+                    value.call(options.merge({ :root => key, :skip_instruct => true }))
+                  else
+                    value.call(options.merge({ :root => key, :skip_instruct => true }), key.to_s.singularize)
+                  end
+                else
+                  if value.respond_to?(:to_xml)
+                    value.to_xml(options.merge({ :root => key, :skip_instruct => true }))
+                  else
+                    type_name = XML_TYPE_NAMES[value.class]
+
+                    key = dasherize ? key.to_s.dasherize : key.to_s
+
+                    attributes = options[:skip_types] || value.nil? || type_name.nil? ? { } : { :type => type_name }
+                    if value.nil?
+                      attributes[:nil] = true
+                    end
+
+                    options[:builder].tag!(key,
+                      XML_FORMATTING[type_name] ? XML_FORMATTING[type_name].call(value) : value,
+                      attributes
+                    )
+                end
+              end
+            end
+          end
+
+        end
+
+        module ClassMethods
+          def create_from_xml(xml)
+            # TODO: Refactor this into something much cleaner that doesn't rely on XmlSimple
+            undasherize_keys(typecast_xml_value(XmlSimple.xml_in(xml,
+              'forcearray'   => false,
+              'forcecontent' => true,
+              'keeproot'     => true,
+              'contentkey'   => '__content__')
+            ))
+          end
+
+          private
+            def typecast_xml_value(value)
+              case value.class.to_s
+                when "Hash"
+                  if value.has_key?("__content__")
+                    content = translate_xml_entities(value["__content__"])
+                    case value["type"]
+                      when "integer"  then content.to_i
+                      when "boolean"  then content.strip == "true"
+                      when "datetime" then ::Time.parse(content).utc
+                      when "date"     then ::Date.parse(content)
+                      else                 content
+                    end
+                  else
+                    value.empty? || value['nil'] == 'true' ? nil : value.inject({}) do |h,(k,v)|
+                      h[k] = typecast_xml_value(v)
+                      h
+                    end
+                  end
+                when "Array"
+                  value.map! { |i| typecast_xml_value(i) }
+                  case value.length
+                    when 0 then nil
+                    when 1 then value.first
+                    else value
+                  end
+                when "String"
+                  value
+                else
+                  raise "can't typecast #{value.inspect}"
+              end
+            end
+
+            def translate_xml_entities(value)
+              value.gsub(/&lt;/,   "<").
+                    gsub(/&gt;/,   ">").
+                    gsub(/&quot;/, '"').
+                    gsub(/&apos;/, "'").
+                    gsub(/&amp;/,  "&")
+            end
+
+            def undasherize_keys(params)
+              case params.class.to_s
+                when "Hash"
+                  params.inject({}) do |h,(k,v)|
+                    h[k.to_s.tr("-", "_")] = undasherize_keys(v)
+                    h
+                  end
+                when "Array"
+                  params.map { |v| undasherize_keys(v) }
+                else
+                  params
+              end
+            end
+        end
+      end
+    end
+  end
+end

data/lib/monetra/active_support/core_ext/hash/diff.rb

@@ -0,0 +1,11 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Hash #:nodoc:
+      module Diff
+        def diff(h2)
+          self.dup.delete_if { |k, v| h2[k] == v }.merge(h2.dup.delete_if { |k, v| self.has_key?(k) })
+        end
+      end
+    end
+  end
+end

data/lib/monetra/active_support/core_ext/hash/indifferent_access.rb

@@ -0,0 +1,88 @@
+# this class has dubious semantics and we only have it so that
+# people can write params[:key] instead of params['key']
+
+class HashWithIndifferentAccess < Hash
+  def initialize(constructor = {})
+    if constructor.is_a?(Hash)
+      super()
+      update(constructor)
+    else
+      super(constructor)
+    end
+  end
+
+  def default(key = nil)
+    if key.is_a?(Symbol) && include?(key = key.to_s)
+      self[key]
+    else
+      super
+    end
+  end
+
+  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+  alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+  def []=(key, value)
+    regular_writer(convert_key(key), convert_value(value))
+  end
+
+  def update(other_hash)
+    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+    self
+  end
+
+  alias_method :merge!, :update
+
+  def key?(key)
+    super(convert_key(key))
+  end
+
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  def fetch(key, *extras)
+    super(convert_key(key), *extras)
+  end
+
+  def values_at(*indices)
+    indices.collect {|key| self[convert_key(key)]}
+  end
+
+  def dup
+    HashWithIndifferentAccess.new(self)
+  end
+
+  def merge(hash)
+    self.dup.update(hash)
+  end
+
+  def delete(key)
+    super(convert_key(key))
+  end
+
+  def stringify_keys!; self end
+  def symbolize_keys!; self end
+
+  protected
+    def convert_key(key)
+      key.kind_of?(Symbol) ? key.to_s : key
+    end
+    def convert_value(value)
+      value.is_a?(Hash) ? value.with_indifferent_access : value
+    end
+end
+
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Hash #:nodoc:
+      module IndifferentAccess #:nodoc:
+        def with_indifferent_access
+          hash = HashWithIndifferentAccess.new(self)
+          hash.default = self.default
+          hash
+        end
+      end
+    end
+  end
+end

data/lib/monetra/active_support/core_ext/hash/keys.rb

@@ -0,0 +1,53 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Hash #:nodoc:
+      module Keys
+        # Return a new hash with all keys converted to strings.
+        def stringify_keys
+          inject({}) do |options, (key, value)|
+            options[key.to_s] = value
+            options
+          end
+        end
+
+        # Destructively convert all keys to strings.
+        def stringify_keys!
+          keys.each do |key|
+            unless key.class.to_s == "String" # weird hack to make the tests run when string_ext_test.rb is also running
+              self[key.to_s] = self[key]
+              delete(key)
+            end
+          end
+          self
+        end
+
+        # Return a new hash with all keys converted to symbols.
+        def symbolize_keys
+          inject({}) do |options, (key, value)|
+            options[key.to_sym] = value
+            options
+          end
+        end
+
+        # Destructively convert all keys to symbols.
+        def symbolize_keys!
+          keys.each do |key|
+            unless key.is_a?(Symbol)
+              self[key.to_sym] = self[key]
+              delete(key)
+            end
+          end
+          self
+        end
+
+        alias_method :to_options,  :symbolize_keys
+        alias_method :to_options!, :symbolize_keys!
+
+        def assert_valid_keys(*valid_keys)
+          unknown_keys = keys - [valid_keys].flatten
+          raise(ArgumentError, "Unknown key(s): #{unknown_keys.join(", ")}") unless unknown_keys.empty?
+        end
+      end
+    end
+  end
+end