monetra-ruby 0.0.6

data/lib/monetra/active_support/core_ext/module/introspection.rb

@@ -0,0 +1,21 @@
+class Module
+  # Return the module which contains this one; if this is a root module, such as
+  # +::MyModule+, then Object is returned.
+  def parent
+    parent_name = name.split('::')[0..-2] * '::'
+    parent_name.empty? ? Object : parent_name.constantize
+  end
+  
+  # Return all the parents of this module, ordered from nested outwards. The
+  # receiver is not contained within the result.
+  def parents
+    parents = []
+    parts = name.split('::')[0..-2]
+    until parts.empty?
+      parents << (parts * '::').constantize
+      parts.pop
+    end
+    parents << Object unless parents.include? Object
+    parents
+  end
+end

data/lib/monetra/active_support/core_ext/module/loading.rb

@@ -0,0 +1,13 @@
+class Module
+  def as_load_path
+    if self == Object || self == Kernel
+      ''
+    elsif is_a? Class
+      parent == self ? '' : parent.as_load_path
+    else
+      name.split('::').collect do |word|
+        word.underscore
+      end * '/'
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+
+# Add a +missing_name+ method to NameError instances.
+class NameError < StandardError
+  
+  # Add a method to obtain the missing name from a NameError.
+  def missing_name
+    $1 if /((::)?([A-Z]\w*)(::[A-Z]\w*)*)$/ =~ message
+  end
+  
+  # Was this exception raised because the given name was missing?
+  def missing_name?(name)
+    if name.is_a? Symbol
+      last_name = (missing_name || '').split('::').last
+      last_name == name.to_s
+    else
+      missing_name == name.to_s
+    end
+  end
+  
+end

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

@@ -0,0 +1,7 @@
+require File.dirname(__FILE__) + '/numeric/time'
+require File.dirname(__FILE__) + '/numeric/bytes'
+
+class Numeric #:nodoc:
+  include ActiveSupport::CoreExtensions::Numeric::Time 
+  include ActiveSupport::CoreExtensions::Numeric::Bytes 
+end

data/lib/monetra/active_support/core_ext/numeric/bytes.rb

@@ -0,0 +1,44 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Numeric #:nodoc:
+      # Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes
+      module Bytes
+        def bytes
+          self
+        end
+        alias :byte :bytes
+
+        def kilobytes
+          self * 1024
+        end
+        alias :kilobyte :kilobytes
+
+        def megabytes
+          self * 1024.kilobytes
+        end
+        alias :megabyte :megabytes
+
+        def gigabytes
+          self * 1024.megabytes 
+        end
+        alias :gigabyte :gigabytes
+
+        def terabytes
+          self * 1024.gigabytes
+        end
+        alias :terabyte :terabytes
+        
+        def petabytes
+          self * 1024.terabytes
+        end
+        alias :petabyte :petabytes
+        
+        def exabytes
+          self * 1024.petabytes
+        end
+        alias :exabyte :exabytes
+        
+      end
+    end
+  end
+end

data/lib/monetra/active_support/core_ext/numeric/time.rb

@@ -0,0 +1,72 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Numeric #:nodoc:
+      # Enables the use of time calculations and declarations, like 45.minutes + 2.hours + 4.years.
+      #
+      # If you need precise date calculations that doesn't just treat months as 30 days, then have
+      # a look at Time#advance.
+      # 
+      # Some of these methods are approximations, Ruby's core 
+      # Date[http://stdlib.rubyonrails.org/libdoc/date/rdoc/index.html] and 
+      # Time[http://stdlib.rubyonrails.org/libdoc/time/rdoc/index.html] should be used for precision
+      # date and time arithmetic
+      module Time
+        def seconds
+          self
+        end
+        alias :second :seconds
+
+        def minutes
+          self * 60
+        end
+        alias :minute :minutes  
+        
+        def hours
+          self * 60.minutes
+        end
+        alias :hour :hours
+        
+        def days
+          self * 24.hours
+        end
+        alias :day :days
+
+        def weeks
+          self * 7.days
+        end
+        alias :week :weeks
+        
+        def fortnights
+          self * 2.weeks
+        end
+        alias :fortnight :fortnights
+        
+        def months
+          self * 30.days
+        end
+        alias :month :months
+
+        def years
+          (self * 365.25.days).to_i
+        end
+        alias :year :years
+
+        # Reads best without arguments:  10.minutes.ago
+        def ago(time = ::Time.now)
+          time - self
+        end
+
+        # Reads best with argument:  10.minutes.until(time)
+        alias :until :ago
+
+        # Reads best with argument:  10.minutes.since(time)
+        def since(time = ::Time.now)
+          time + self
+        end
+
+        # Reads best without arguments:  10.minutes.from_now
+        alias :from_now :since
+      end
+    end
+  end
+end

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

@@ -0,0 +1,2 @@
+require File.dirname(__FILE__) + '/object/extending'
+require File.dirname(__FILE__) + '/object/misc'

data/lib/monetra/active_support/core_ext/object/extending.rb

@@ -0,0 +1,47 @@
+class Object #:nodoc:
+  def remove_subclasses_of(*superclasses)
+    Class.remove_class(*subclasses_of(*superclasses))
+  end
+
+  def subclasses_of(*superclasses)
+    subclasses = []
+    ObjectSpace.each_object(Class) do |k|
+      next if # Exclude this class if
+        (k.ancestors & superclasses).empty? || # It's not a subclass of our supers
+        superclasses.include?(k) || # It *is* one of the supers
+        eval("! defined?(::#{k})") || # It's not defined.
+        eval("::#{k}").object_id != k.object_id
+      subclasses << k
+    end
+    subclasses
+  end
+  
+  def extended_by
+    ancestors = class << self; ancestors end
+    ancestors.select { |mod| mod.class == Module } - [ Object, Kernel ]
+  end
+  
+  def copy_instance_variables_from(object, exclude = [])
+    exclude += object.protected_instance_variables if object.respond_to? :protected_instance_variables
+    
+    instance_variables = object.instance_variables - exclude.map { |name| name.to_s }
+    instance_variables.each { |name| instance_variable_set(name, object.instance_variable_get(name)) }
+  end
+  
+  def extend_with_included_modules_from(object)
+    object.extended_by.each { |mod| extend mod }
+  end
+
+  def instance_values
+    instance_variables.inject({}) do |values, name|
+      values[name[1..-1]] = instance_variable_get(name)
+      values
+    end
+  end
+  
+  unless defined? instance_exec # 1.9
+    def instance_exec(*arguments, &block)
+      block.bind(self)[*arguments]
+    end
+  end
+end

data/lib/monetra/active_support/core_ext/object/misc.rb

@@ -0,0 +1,34 @@
+class Object #:nodoc:
+  # A Ruby-ized realization of the K combinator, courtesy of Mikael Brockman.
+  #
+  #   def foo
+  #     returning values = [] do
+  #       values << 'bar'
+  #       values << 'baz'
+  #     end
+  #   end
+  #
+  #   foo # => ['bar', 'baz']
+  #
+  #   def foo
+  #     returning [] do |values|
+  #       values << 'bar'
+  #       values << 'baz'
+  #     end
+  #   end
+  #
+  #   foo # => ['bar', 'baz']
+  #
+  def returning(value)
+    yield(value)
+    value
+  end
+
+  def with_options(options)
+    yield ActiveSupport::OptionMerger.new(self, options)
+  end
+  
+  def to_json
+    ActiveSupport::JSON.encode(self)
+  end
+end

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

@@ -0,0 +1,7 @@
+require 'pathname'
+require File.dirname(__FILE__) + '/pathname/clean_within'
+
+class Pathname#:nodoc:
+  extend ActiveSupport::CoreExtensions::Pathname::CleanWithin
+end
+

data/lib/monetra/active_support/core_ext/pathname/clean_within.rb

@@ -0,0 +1,14 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Pathname #:nodoc:
+      module CleanWithin
+        # Clean the paths contained in the provided string.
+        def clean_within(string)
+          string.gsub(%r{[\w. ]+(/[\w. ]+)+(\.rb)?(\b|$)}) do |path|
+            new(path).cleanpath
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+class Proc #:nodoc:
+  def bind(object)
+    block, time = self, Time.now
+    (class << object; self end).class_eval do
+      method_name = "__bind_#{time.to_i}_#{time.usec}"
+      define_method(method_name, &block)
+      method = instance_method(method_name)
+      remove_method(method_name)
+      method
+    end.bind(object)
+  end
+end

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

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

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

@@ -0,0 +1,21 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Range #:nodoc:
+      # Getting dates in different convenient string representations and other objects
+      module Conversions
+        DATE_FORMATS = {
+          :db => Proc.new { |start, stop| "BETWEEN '#{start.to_s(:db)}' AND '#{stop.to_s(:db)}'" }
+        }
+        
+        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] ? DATE_FORMATS[format].call(first, last) : to_default_s   
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/string/inflections'
+require File.dirname(__FILE__) + '/string/conversions'
+require File.dirname(__FILE__) + '/string/access'
+require File.dirname(__FILE__) + '/string/starts_ends_with'
+require File.dirname(__FILE__) + '/string/iterators'
+
+class String #:nodoc:
+  include ActiveSupport::CoreExtensions::String::Access
+  include ActiveSupport::CoreExtensions::String::Conversions
+  include ActiveSupport::CoreExtensions::String::Inflections
+  include ActiveSupport::CoreExtensions::String::StartsEndsWith
+  include ActiveSupport::CoreExtensions::String::Iterators
+end

data/lib/monetra/active_support/core_ext/string/access.rb

@@ -0,0 +1,58 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      # Makes it easier to access parts of a string, such as specific characters and substrings.
+      module Access
+        # Returns the character at the +position+ treating the string as an array (where 0 is the first character).
+        #
+        # Examples: 
+        #   "hello".at(0)  # => "h"
+        #   "hello".at(4)  # => "o"
+        #   "hello".at(10) # => nil
+        def at(position)
+          self[position, 1]
+        end
+        
+        # Returns the remaining of the string from the +position+ treating the string as an array (where 0 is the first character).
+        #
+        # Examples: 
+        #   "hello".from(0)  # => "hello"
+        #   "hello".from(2)  # => "llo"
+        #   "hello".from(10) # => nil
+        def from(position)
+          self[position..-1]
+        end
+        
+        # Returns the beginning of the string up to the +position+ treating the string as an array (where 0 is the first character).
+        #
+        # Examples: 
+        #   "hello".to(0)  # => "h"
+        #   "hello".to(2)  # => "hel"
+        #   "hello".to(10) # => "hello"
+        def to(position)
+          self[0..position]
+        end
+
+        # Returns the first character of the string or the first +limit+ characters.
+        #
+        # Examples: 
+        #   "hello".first     # => "h"
+        #   "hello".first(2)  # => "he"
+        #   "hello".first(10) # => "hello"
+        def first(limit = 1)
+          self[0..(limit - 1)]
+        end
+        
+        # Returns the last character of the string or the last +limit+ characters.
+        #
+        # Examples: 
+        #   "hello".last     # => "o"
+        #   "hello".last(2)  # => "lo"
+        #   "hello".last(10) # => "hello"
+        def last(limit = 1)
+          self[(-limit)..-1] || self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'parsedate'
+
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      # Converting strings to other objects
+      module Conversions
+        # Form can be either :utc (default) or :local.
+        def to_time(form = :utc)
+          ::Time.send(form, *ParseDate.parsedate(self))
+        end
+
+        def to_date
+          ::Date.new(*ParseDate.parsedate(self)[0..2])
+        end
+      end
+    end
+  end
+end

data/lib/monetra/active_support/core_ext/string/inflections.rb

@@ -0,0 +1,153 @@
+require File.dirname(__FILE__) + '/../../inflector' unless defined? Inflector
+
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      # String inflections define new methods on the String class to transform names for different purposes.
+      # For instance, you can figure out the name of a database from the name of a class.
+      #   "ScaleScore".tableize => "scale_scores"
+      module Inflections
+        # 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
+          Inflector.pluralize(self)
+        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
+          Inflector.singularize(self)
+        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(first_letter = :upper)
+          case first_letter
+            when :upper then Inflector.camelize(self, true)
+            when :lower then Inflector.camelize(self, false)
+          end
+        end
+        alias_method :camelcase, :camelize
+
+        # 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
+          Inflector.titleize(self)
+        end
+        alias_method :titlecase, :titleize
+
+        # 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
+          Inflector.underscore(self)
+        end
+
+        # Replaces underscores with dashes in the string.
+        #
+        # Example
+        #   "puni_puni" #=> "puni-puni"
+        def dasherize
+          Inflector.dasherize(self)
+        end
+
+        # Removes the module part from the expression in the string
+        #
+        # Examples
+        #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize #=> "Inflections"
+        #   "Inflections".demodulize #=> "Inflections"
+        def demodulize
+          Inflector.demodulize(self)
+        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
+          Inflector.tableize(self)
+        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
+          Inflector.classify(self)
+        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
+          Inflector.humanize(self)
+        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(separate_class_name_and_id_with_underscore = true)
+          Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
+        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
+          Inflector.constantize(self)
+        end
+      end
+    end
+  end
+end