motion-support 0.1.0 → 0.2.0

data/lib/motion-support/core_ext/time.rb

@@ -0,0 +1,19 @@
+require 'motion-require'
+
+files = [
+  '_stdlib/date',
+  '_stdlib/time',
+  'core_ext/time/acts_like',
+  'core_ext/time/calculations',
+  'core_ext/time/conversions',
+  'core_ext/date/acts_like',
+  'core_ext/date/calculations',
+  'core_ext/date/conversions',
+  'core_ext/date_and_time/calculations',
+  'core_ext/integer/time',
+  'core_ext/numeric/time',
+  'core_ext/object/acts_like',
+  'duration'
+].map { |file| File.expand_path(File.join(File.dirname(__FILE__), "/../../../motion", "#{file}.rb")) }
+
+Motion::Require.all(files)

data/lib/motion-support/core_ext.rb

@@ -0,0 +1,3 @@
+Dir["#{File.dirname(__FILE__)}/core_ext/*.rb"].sort.each do |path|
+  require path
+end

data/lib/motion-support/inflector.rb

@@ -1,156 +1,12 @@
-# Inflector is a singleton class that helps
-# singularize, pluralize and other-thing-ize
-# words. It is very much based on the Rails
-# ActiveSupport implementation or Inflector
-class Inflector
-  def self.instance #nodoc
-    @__instance__ ||= new
-  end
-
-  def initialize #nodoc
-    reset
-  end
-
-  def reset
-    # Put singular-form to plural form transformations here
-    @plurals = [
-      [/^person$/, 'people'],
-      [/^man$/, 'men'],
-      [/^child$/, 'children'],
-      [/^sex$/, 'sexes'],
-      [/^move$/, 'moves'],
-      [/^cow$/, 'kine'],
-      [/^zombie$/, 'zombies'],
-      [/(quiz)$/i, '\1zes'],
-      [/^(oxen)$/i, '\1'],
-      [/^(ox)$/i, '\1en'],
-      [/^(m|l)ice$/i, '\1ice'],
-      [/^(m|l)ouse$/i, '\1ice'],
-      [/(matr|vert|ind)(?:ix|ex)$/i, '\1ices'],
-      [/(x|ch|ss|sh)$/i, '\1es'],
-      [/([^aeiouy]|qu)y$/i, '\1ies'],
-      [/(hive)$/i, '\1s'],
-      [/(?:([^f])fe|([lr])f)$/i, '\1\2ves'],
-      [/sis$/i, 'ses'],
-      [/([ti])a$/i, '\1a'],
-      [/([ti])um$/i, '\1a'],
-      [/(buffal|tomat)o$/i, '\1oes'],
-      [/(bu)s$/i, '\1ses'],
-      [/(alias|status)$/i, '\1es'],
-      [/(octop|vir)i$/i, '\1i'],
-      [/(octop|vir|alumn)us$/i, '\1i'],
-      [/^(ax|test)is$/i, '\1es'],
-      [/s$/i, 's'],
-      [/$/, 's']
-    ]
-
-    # Put plural-form to singular form transformations here
-    @singulars = [
-      [/^people$/, 'person'],
-      [/^men$/, 'man'],
-      [/^children$/, 'child'],
-      [/^sexes$/, 'sex'],
-      [/^moves$/, 'move'],
-      [/^kine$/, 'cow'],
-      [/^zombies$/, 'zombie'],
-      [/(database)s$/i, '\1'],
-      [/(quiz)zes$/i, '\1'],
-      [/(matr)ices$/i, '\1ix'],
-      [/(vert|ind)ices$/i, '\1ex'],
-      [/^(ox)en/i, '\1'],
-      [/(alias|status)(es)?$/i, '\1'],
-      [/(octop|vir|alumn)(us|i)$/i, '\1us'],
-      [/^(a)x[ie]s$/i, '\1xis'],
-      [/(cris|test)(is|es)$/i, '\1is'],
-      [/(shoe)s$/i, '\1'],
-      [/(o)es$/i, '\1'],
-      [/(bus)(es)?$/i, '\1'],
-      [/^(m|l)ice$/i, '\1ouse'],
-      [/(x|ch|ss|sh)es$/i, '\1'],
-      [/(m)ovies$/i, '\1ovie'],
-      [/(s)eries$/i, '\1eries'],
-      [/([^aeiouy]|qu)ies$/i, '\1y'],
-      [/([lr])ves$/i, '\1f'],
-      [/(tive)s$/i, '\1'],
-      [/(hive)s$/i, '\1'],
-      [/([^f])ves$/i, '\1fe'],
-      [/(^analy)(sis|ses)$/i, '\1sis'],
-      [/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)$/i, '\1sis'],
-      [/([ti])a$/i, '\1um'],
-      [/(n)ews$/i, '\1ews'],
-      [/(ss)$/i, '\1'],
-      [/s$/i, '']
-    ]
-
-    @irregulars = [
-    ]
-
-    @uncountables = [
-      'equipment',
-      'information',
-      'rice',
-      'money',
-      'species',
-      'series',
-      'fish',
-      'sheep',
-      'jeans',
-      'police'
-    ]
-  end
-
-  attr_reader :plurals, :singulars, :uncountables, :irregulars
-
-  def self.inflections
-    if block_given?
-      yield Inflector.instance
-    else
-      Inflector.instance
-    end
-  end
-
-  def uncountable(word)
-    @uncountables << word
-  end
-
-  def singular(rule, replacement)
-    @singulars << [rule, replacement]
-  end
-
-  def plural(rule, replacement)
-    @plurals << [rule, replacement]
-  end
-
-  def irregular(rule, replacement)
-    @irregulars << [rule, replacement]
-  end
-
-  def uncountable?(word)
-    return word if @uncountables.include?(word.downcase)
-    false
-  end
-
-  def inflect(word, direction) #nodoc
-    return word if uncountable?(word)
-
-    subject = word.dup
-
-    @irregulars.each do |rule|
-      return subject if subject.gsub!(rule.first, rule.last)
-    end
-
-    sense_group = direction == :singularize ? @singulars : @plurals
-    sense_group.each do |rule|
-      return subject if subject.gsub!(rule.first, rule.last)
-    end
-    subject
-  end
-
-  def singularize(word)
-     inflect word, :singularize
-  end
-
-  def pluralize(word)
-    inflect word, :pluralize
-  end
-end
+require 'motion-require'
+
+files = [
+  "inflector/inflections",
+  "inflector/methods",
+  "inflections",
+  "core_ext/string/inflections",
+  
+  "core_ext/array/prepend_and_append"
+].map { |file| File.expand_path(File.join(File.dirname(__FILE__), "/../../motion", "#{file}.rb")) }
+
+Motion::Require.all(files)

data/lib/motion-support.rb

@@ -1,5 +1,5 @@
-require "motion-support/version"
-require 'bubble-wrap'
-Dir.glob(File.join(File.dirname(__FILE__), 'motion-support/*.rb')).each do |file|
-  BW.require file
-end
+require 'motion-require'
+
+Motion::Require.all(Dir.glob(File.expand_path('../../motion/**/*.rb', __FILE__)))
+
+at_exit { puts "\nWARNING: Automatic dependency detection does not work with motion-support. Turn it off in your Rakefile:\n\n  app.detect_dependencies = false\n\n" if Motion::Project::App.config.detect_dependencies }

data/motion/_stdlib/cgi.rb

@@ -0,0 +1,22 @@
+# This is a very small part of the CGI class, borrowed from the Rubinius sources
+class CGI
+  @@accept_charset="UTF-8" unless defined?(@@accept_charset)
+  # URL-encode a string.
+  #   url_encoded_string = CGI::escape("'Stop!' said Fred")
+  #      # => "%27Stop%21%27+said+Fred"
+  def CGI::escape(string)
+    string.gsub(/([^ a-zA-Z0-9_.-]+)/) do
+      '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
+    end.tr(' ', '+')
+  end
+
+  # URL-decode a string with encoding(optional).
+  #   string = CGI::unescape("%27Stop%21%27+said+Fred")
+  #      # => "'Stop!' said Fred"
+  def CGI::unescape(string,encoding=@@accept_charset)
+    str=string.tr('+', ' ').force_encoding(Encoding::ASCII_8BIT).gsub(/((?:%[0-9a-fA-F]{2})+)/) do
+      [$1.delete('%')].pack('H*')
+    end.force_encoding(encoding)
+    str.valid_encoding? ? str : str.force_encoding(string.encoding)
+  end
+end

data/motion/_stdlib/date.rb

@@ -0,0 +1,77 @@
+class Date
+  def self.gregorian_leap?(year)
+    if year % 400 == 0
+      true
+    elsif year % 100 == 0 then
+      false
+    elsif year % 4 == 0 then
+      true
+    else
+      false
+    end
+  end
+  
+  def initialize(year = nil, month = nil, day = nil)
+    if year && month && day
+      @value = Time.utc(year, month, day)
+    else
+      @value = Time.now
+    end
+  end
+  
+  def self.today
+    new
+  end
+  
+  def to_s
+    "#{year}-#{month}-#{day}"
+  end
+  
+  def ==(other)
+    year == other.year &&
+    month == other.month &&
+    day == other.day
+  end
+  
+  def +(other)
+    val = @value + other * 3600 * 24
+    Date.new(val.year, val.month, val.day)
+  end
+  
+  def -(other)
+    if other.is_a?(Date)
+      (@value - other.instance_variable_get(:@value)) / (3600 * 24)
+    elsif other.is_a?(Time)
+      (@value - other) 
+    else
+      self + (-other)
+    end
+  end
+  
+  def >>(months)
+    new_year = year + (self.month + months - 1) / 12
+    new_month = (self.month + months) % 12
+    new_month = new_month == 0 ? 12 : new_month
+    new_day = [day, Time.days_in_month(new_month, new_year)].min
+    
+    Date.new(new_year, new_month, new_day)
+  end
+  
+  def <<(months)
+    return self >> -months
+  end
+  
+  [:year, :month, :day, :wday, :<, :<=, :>, :>=, :"<=>", :strftime].each do |method|
+    define_method method do |*args|
+      @value.send(method, *args)
+    end
+  end
+  
+  def to_date
+    self
+  end
+  
+  def to_time
+    @value
+  end
+end

data/motion/_stdlib/time.rb

@@ -0,0 +1,19 @@
+class Time
+  def to_date
+    Date.new(year, month, day)
+  end
+  
+  def to_time
+    self
+  end
+  
+  def ==(other)
+    other &&
+    year == other.year &&
+    month == other.month &&
+    day == other.day &&
+    hour == other.hour &&
+    min == other.min &&
+    sec == other.sec
+  end
+end

data/motion/core_ext/array/access.rb

@@ -0,0 +1,28 @@
+class Array
+  # Returns the tail of the array from +position+.
+  #
+  #   %w( a b c d ).from(0)  # => ["a", "b", "c", "d"]
+  #   %w( a b c d ).from(2)  # => ["c", "d"]
+  #   %w( a b c d ).from(10) # => []
+  #   %w().from(0)           # => []
+  def from(position)
+    self[position, length] || []
+  end
+
+  # Returns the beginning of the array up to +position+.
+  #
+  #   %w( a b c d ).to(0)  # => ["a"]
+  #   %w( a b c d ).to(2)  # => ["a", "b", "c"]
+  #   %w( a b c d ).to(10) # => ["a", "b", "c", "d"]
+  #   %w().to(0)           # => []
+  def to(position)
+    first position + 1
+  end
+
+  # Equal to <tt>self[1]</tt>.
+  #
+  #   %w( a b c d e ).second # => "b"
+  def second
+    self[1]
+  end
+end

data/motion/core_ext/array/conversions.rb

@@ -0,0 +1,86 @@
+class Array
+  # Converts the array to a comma-separated sentence where the last element is
+  # joined by the connector word.
+  #
+  # You can pass the following options to change the default behavior. If you
+  # pass an option key that doesn't exist in the list below, it will raise an
+  # <tt>ArgumentError</tt>.
+  #
+  # Options:
+  #
+  # * <tt>:words_connector</tt> - The sign or word used to join the elements
+  #   in arrays with two or more elements (default: ", ").
+  # * <tt>:two_words_connector</tt> - The sign or word used to join the elements
+  #   in arrays with two elements (default: " and ").
+  # * <tt>:last_word_connector</tt> - The sign or word used to join the last element
+  #   in arrays with three or more elements (default: ", and ").
+  #
+  #   [].to_sentence                      # => ""
+  #   ['one'].to_sentence                 # => "one"
+  #   ['one', 'two'].to_sentence          # => "one and two"
+  #   ['one', 'two', 'three'].to_sentence # => "one, two, and three"
+  #
+  #   ['one', 'two'].to_sentence(passing: 'invalid option')
+  #   # => ArgumentError: Unknown key :passing
+  #
+  #   ['one', 'two'].to_sentence(two_words_connector: '-')
+  #   # => "one-two"
+  #
+  #   ['one', 'two', 'three'].to_sentence(words_connector: ' or ', last_word_connector: ' or at least ')
+  #   # => "one or two or at least three"
+  def to_sentence(options = {})
+    options.assert_valid_keys(:words_connector, :two_words_connector, :last_word_connector)
+
+    default_connectors = {
+      :words_connector     => ', ',
+      :two_words_connector => ' and ',
+      :last_word_connector => ', and '
+    }
+    options = default_connectors.merge!(options)
+
+    case length
+    when 0
+      ''
+    when 1
+      self[0].to_s.dup
+    when 2
+      "#{self[0]}#{options[:two_words_connector]}#{self[1]}"
+    else
+      "#{self[0...-1].join(options[:words_connector])}#{options[:last_word_connector]}#{self[-1]}"
+    end
+  end
+
+  # Converts a collection of elements into a formatted string by calling
+  # <tt>to_s</tt> on all elements and joining them. Having this model:
+  #
+  #   class Blog < ActiveRecord::Base
+  #     def to_s
+  #       title
+  #     end
+  #   end
+  #
+  #   Blog.all.map(&:title) #=> ["First Post", "Second Post", "Third post"]
+  #
+  # <tt>to_formatted_s</tt> shows us:
+  #
+  #   Blog.all.to_formatted_s # => "First PostSecond PostThird Post"
+  #
+  # Adding in the <tt>:db</tt> argument as the format yields a comma separated
+  # id list:
+  #
+  #   Blog.all.to_formatted_s(:db) # => "1,2,3"
+  def to_formatted_s(format = :default)
+    case format
+    when :db
+      if empty?
+        'null'
+      else
+        collect { |element| element.id }.join(',')
+      end
+    else
+      to_default_s
+    end
+  end
+  alias_method :to_default_s, :to_s
+  alias_method :to_s, :to_formatted_s
+end

data/motion/core_ext/array/extract_options.rb

@@ -0,0 +1,11 @@
+class Array
+  # Extracts options from a set of arguments. Removes and returns the last
+  # element in the array if it's a hash, otherwise returns a blank hash.
+  def extract_options!
+    if last.is_a?(Hash)
+      pop
+    else
+      {}
+    end
+  end
+end

data/motion/core_ext/array/grouping.rb

@@ -0,0 +1,99 @@
+class Array
+  # Splits or iterates over the array in groups of size +number+,
+  # padding any remaining slots with +fill_with+ unless it is +false+.
+  #
+  #   %w(1 2 3 4 5 6 7 8 9 10).in_groups_of(3) {|group| p group}
+  #   ["1", "2", "3"]
+  #   ["4", "5", "6"]
+  #   ["7", "8", "9"]
+  #   ["10", nil, nil]
+  #
+  #   %w(1 2 3 4 5).in_groups_of(2, ' ') {|group| p group}
+  #   ["1", "2"]
+  #   ["3", "4"]
+  #   ["5", " "]
+  #
+  #   %w(1 2 3 4 5).in_groups_of(2, false) {|group| p group}
+  #   ["1", "2"]
+  #   ["3", "4"]
+  #   ["5"]
+  def in_groups_of(number, fill_with = nil)
+    if fill_with == false
+      collection = self
+    else
+      # size % number gives how many extra we have;
+      # subtracting from number gives how many to add;
+      # modulo number ensures we don't add group of just fill.
+      padding = (number - size % number) % number
+      collection = dup.concat([fill_with] * padding)
+    end
+
+    if block_given?
+      collection.each_slice(number) { |slice| yield(slice) }
+    else
+      groups = []
+      collection.each_slice(number) { |group| groups << group }
+      groups
+    end
+  end
+
+  # Splits or iterates over the array in +number+ of groups, padding any
+  # remaining slots with +fill_with+ unless it is +false+.
+  #
+  #   %w(1 2 3 4 5 6 7 8 9 10).in_groups(3) {|group| p group}
+  #   ["1", "2", "3", "4"]
+  #   ["5", "6", "7", nil]
+  #   ["8", "9", "10", nil]
+  #
+  #   %w(1 2 3 4 5 6 7 8 9 10).in_groups(3, '&nbsp;') {|group| p group}
+  #   ["1", "2", "3", "4"]
+  #   ["5", "6", "7", "&nbsp;"]
+  #   ["8", "9", "10", "&nbsp;"]
+  #
+  #   %w(1 2 3 4 5 6 7).in_groups(3, false) {|group| p group}
+  #   ["1", "2", "3"]
+  #   ["4", "5"]
+  #   ["6", "7"]
+  def in_groups(number, fill_with = nil)
+    # size / number gives minor group size;
+    # size % number gives how many objects need extra accommodation;
+    # each group hold either division or division + 1 items.
+    division = size.div number
+    modulo = size % number
+
+    # create a new array avoiding dup
+    groups = []
+    start = 0
+
+    number.times do |index|
+      length = division + (modulo > 0 && modulo > index ? 1 : 0)
+      groups << last_group = slice(start, length)
+      last_group << fill_with if fill_with != false &&
+        modulo > 0 && length == division
+      start += length
+    end
+
+    if block_given?
+      groups.each { |g| yield(g) }
+    else
+      groups
+    end
+  end
+
+  # Divides the array into one or more subarrays based on a delimiting +value+
+  # or the result of an optional block.
+  #
+  #   [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)
+    inject([[]]) do |results, element|
+      if block && block.call(element) || value == element
+        results << []
+      else
+        results.last << element
+      end
+
+      results
+    end
+  end
+end

data/motion/core_ext/array/prepend_and_append.rb

@@ -0,0 +1,7 @@
+class Array
+  # The human way of thinking about adding stuff to the end of a list is with append
+  alias_method :append,  :<<
+
+  # The human way of thinking about adding stuff to the beginning of a list is with prepend
+  alias_method :prepend, :unshift
+end

data/motion/core_ext/array/wrap.rb

@@ -0,0 +1,45 @@
+class Array
+  # Wraps its argument in an array unless it is already an array (or array-like).
+  #
+  # Specifically:
+  #
+  # * If the argument is +nil+ an empty list is returned.
+  # * Otherwise, if the argument responds to +to_ary+ it is invoked, and its result returned.
+  # * Otherwise, returns an array with the argument as its single element.
+  #
+  #     Array.wrap(nil)       # => []
+  #     Array.wrap([1, 2, 3]) # => [1, 2, 3]
+  #     Array.wrap(0)         # => [0]
+  #
+  # This method is similar in purpose to <tt>Kernel#Array</tt>, but there are some differences:
+  #
+  # * If the argument responds to +to_ary+ the method is invoked. <tt>Kernel#Array</tt>
+  #   moves on to try +to_a+ if the returned value is +nil+, but <tt>Array.wrap</tt> returns
+  #   such a +nil+ right away.
+  # * If the returned value from +to_ary+ is neither +nil+ nor an +Array+ object, <tt>Kernel#Array</tt>
+  #   raises an exception, while <tt>Array.wrap</tt> does not, it just returns the value.
+  # * It does not call +to_a+ on the argument, though special-cases +nil+ to return an empty array.
+  #
+  # The last point is particularly worth comparing for some enumerables:
+  #
+  #   Array(foo: :bar)      # => [[:foo, :bar]]
+  #   Array.wrap(foo: :bar) # => [{:foo=>:bar}]
+  #
+  # There's also a related idiom that uses the splat operator:
+  #
+  #   [*object]
+  #
+  # which for +nil+ returns <tt>[]</tt>, and calls to <tt>Array(object)</tt> otherwise.
+  #
+  # Thus, in this case the behavior may be different for +nil+, and the differences with
+  # <tt>Kernel#Array</tt> explained above apply to the rest of <tt>object</tt>s.
+  def self.wrap(object)
+    if object.nil?
+      []
+    elsif object.respond_to?(:to_ary)
+      object.to_ary || [object]
+    else
+      [object]
+    end
+  end
+end

data/{lib/motion-support → motion/core_ext}/array.rb

@@ -1,8 +1,4 @@
 class Array
-  def empty?
-    self.length < 1
-  end
-
   # If any item in the array has the key == `key` true, otherwise false.
   # Of good use when writing specs.
   def has_hash_key?(key)