stupidedi 1.2.5 → 1.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2093ddba04d861a92064a74df14c6c950f29b54d
-  data.tar.gz: d94a09d05a3d2f5c21cec4309e4cb3f72124ad6d
+  metadata.gz: 92ea0385370f3e4b2c78354360628986b05d388a
+  data.tar.gz: f4e0c0afd30345c303c7baf272a1e8bc92406c1f
 SHA512:
-  metadata.gz: e9ed1ef8bc67776276b6ce099d7e721ed9eb61d0e75e6a265ef58dc291e131172b5129ffe2715d5d2dd7a58034a920e8172da523be8da0e42042e2fec4d1ce01
-  data.tar.gz: 36ab7df0ead50f68f75b063ad41566013e3cc6cc3b23ca533a951c1b86f35358732b76e36a84d09d6a791e6707a443ed2521985d102e95e261165fe6cbda5cdf
+  metadata.gz: 333c3e34198b7de9ab66b24beea12aeb559d88f62b64f56d3b004af2db2c5a361d3f2369e31da6a00b9e547a0444d55f96c7bc49eb5e93444d964149c0c3d57b
+  data.tar.gz: 8af0836876ae602978852e3d14d9774d36be5e7ef2b23bcce1ca1a4832d859a302749b163bb4c319cd6a6706cd06cbe9fbd30ac7c8c8782fb5a18be14aa903b9

data/README.md

@@ -18,17 +18,10 @@ notices, and health care claims. It is similar to XML in some ways,
 but precedes it by about 15 years; so if you think XML sucks, you
 will love to hate EDI.
 
-### Beware / Help Wanted
+### Credits
 
-Stupidedi monkey patches some classes in the Ruby standard library. These
-are listed in `lib/ruby`. Rails users and other ActiveSupport users have
-reported problems caused by these patches, since they are unintentionally
-incompatible.
-
-There is a pull request ([72](https://github.com/kputnam/stupidedi/pull/72))
-which should solve these. Please test the `refinements` branch and provide
-feedback -- it imposes a requirement of Ruby 2.1+, but should otherwise be
-a seemless change.
+* __Author__: [Kyle Putnam](https://github.com/kputnam)
+* __Maintainer__: [Isi Robayna](https://github.com/irobayna)
 
 ## What problem does it solve?
 

data/lib/ruby/array.rb

@@ -1,189 +1,227 @@
-class Array
-
-  def blank?
-    empty?
-  end
-
-  def present?
-    not empty?
-  end
-
-  # Return the first item. Raises an `IndexError` if the Array is `empty?`.
-  #
-  # @example
-  #   [1, 2, 3].head  #=> 1
-  #
-  def head
-    raise IndexError, "head of empty list" if empty?
-    x, = self
-    x
-  end
-
-  # True if `#at` is defined for the given `n`
-  #
-  # @example
-  #   [1, 2, 3].defined_at?(0)    #=> true
-  #   [].defined_at?(0)           #=> false
-  #
-  def defined_at?(n)
-    n < length and -n <= length
-  end
-
-  # @group Selection
-  #############################################################################
-
-  # Selects all elements except the first.
-  #
-  # @example
-  #   [1, 2, 3].tail  #=> [2, 3]
-  #   [1].tail        #=> []
-  #   [].tail         #=> []
-  #
-  # @return [Array]
-  def tail
-    _, *xs = self
-    xs
-  end
-
-  # Selects all elements except the last `n` ones.
-  #
-  # @example
-  #   [1, 2, 3].init      #=> [1, 2]
-  #   [1, 2, 3].init(2)   #=> [1]
-  #   [].tail             #=> []
-  #
-  # @return [Array]
-  def init(n = 1)
-    raise ArgumentError, "n cannot be negative" if n < 0
-    slice(0..-(n + 1)) or []
-  end
-
-  # Select all elements except the first `n` ones.
-  #
-  # @example
-  #   [1, 2, 3].drop(1)   #=> [2, 3]
-  #   [1, 3, 3].drop(2)   #=> [3]
-  #   [].drop(10)         #=> []
-  #
-  # @return [Array]
-  def drop(n)
-    raise ArgumentError, "n cannot be negative" if n < 0
-    slice(n..-1) or []
-  end
-
-  # Select the first `n` elements.
-  #
-  # @example
-  #   [1, 2, 3].take(2)  #=> [1, 2]
-  #   [1, 2, 3].take(0)  #=> []
-  #
-  # @return [Array]
-  def take(n)
-    raise ArgumentError, "n cannot be negative" if n < 0
-    slice(0, n) or []
-  end
-
-  # Split the array in two at the given position.
-  #
-  # @example
-  #   [1, 2, 3].split_at(2)   #=> [[1,2], [3]]
-  #   [1, 2, 3].split_at(0)   #=> [[], [1,2,3]]
-  #
-  # @return [(Array, Array)]
-  def split_at(n)
-    n = length + n if n < 0
-    return take(n), drop(n)
-  end
-
-  # @endgroup
-  #############################################################################
-
-  # @group Filtering
-  #############################################################################
-
-  # Drops the longest prefix of elements that satisfy the predicate.
-  #
-  # @return [Array]
-  def drop_while(&block)
-    # This is in tail call form
-    if not empty? and yield(head)
-      tail.drop_while(&block)
-    else
-      self
+module Stupidedi
+  module Refinements
+
+    refine Array do
+      def blank?
+        empty?
+      end
+
+      def present?
+        not empty?
+      end
+
+      # Return the first item. Raises an `IndexError` if the Array is `empty?`.
+      #
+      # @example
+      #   [1, 2, 3].head  #=> 1
+      #
+      def head
+        raise IndexError, "head of empty list" if empty?
+        x, = self
+        x
+      end
+
+      # True if `#at` is defined for the given `n`
+      #
+      # @example
+      #   [1, 2, 3].defined_at?(0)    #=> true
+      #   [].defined_at?(0)           #=> false
+      #
+      def defined_at?(n)
+        n < length and -n <= length
+      end
+
+      # @group Selection
+      #############################################################################
+
+      # Selects all elements except the first.
+      #
+      # @example
+      #   [1, 2, 3].tail  #=> [2, 3]
+      #   [1].tail        #=> []
+      #   [].tail         #=> []
+      #
+      # @return [Array]
+      def tail
+        _, *xs = self
+        xs
+      end
+
+      # Selects all elements except the last `n` ones.
+      #
+      # @example
+      #   [1, 2, 3].init      #=> [1, 2]
+      #   [1, 2, 3].init(2)   #=> [1]
+      #   [].tail             #=> []
+      #
+      # @return [Array]
+      def init(n = 1)
+        raise ArgumentError, "n cannot be negative" if n < 0
+        slice(0..-(n + 1)) or []
+      end
+
+      # Select all elements except the first `n` ones.
+      #
+      # @example
+      #   [1, 2, 3].drop(1)   #=> [2, 3]
+      #   [1, 3, 3].drop(2)   #=> [3]
+      #   [].drop(10)         #=> []
+      #
+      # @return [Array]
+      def drop(n)
+        raise ArgumentError, "n cannot be negative" if n < 0
+        slice(n..-1) or []
+      end
+
+      # Select the first `n` elements.
+      #
+      # @example
+      #   [1, 2, 3].take(2)  #=> [1, 2]
+      #   [1, 2, 3].take(0)  #=> []
+      #
+      # @return [Array]
+      def take(n)
+        raise ArgumentError, "n cannot be negative" if n < 0
+        slice(0, n) or []
+      end
+
+      # Split the array in two at the given position.
+      #
+      # @example
+      #   [1, 2, 3].split_at(2)   #=> [[1,2], [3]]
+      #   [1, 2, 3].split_at(0)   #=> [[], [1,2,3]]
+      #
+      # @return [(Array, Array)]
+      def split_at(n)
+        n = length + n if n < 0
+        return take(n), drop(n)
+      end
+
+      # @endgroup
+      #############################################################################
+
+      # @group Filtering
+      #############################################################################
+
+      # Drops the longest prefix of elements that satisfy the predicate.
+      #
+      # @return [Array]
+      def drop_while(&block)
+        # This is in tail call form
+        if not empty? and yield(head)
+          tail.drop_while(&block)
+        else
+          self
+        end
+      end
+
+      # Drops the longest prefix of elements that do not satisfy the predicate.
+      #
+      # @return [Array]
+      def drop_until(&block)
+        # This is in tail call form
+        unless empty? or yield(head)
+          tail.drop_until(&block)
+        else
+          self
+        end
+      end
+
+      # Takes the longest prefix of elements that satisfy the predicate.
+      #
+      # @return [Array]
+      def take_while(accumulator = [], &block)
+        # This is in tail call form
+        if not empty? and yield(head)
+          tail.take_while(head.snoc(accumulator), &block)
+        else
+          accumulator
+        end
+      end
+
+      # Takes the longest prefix of elements that do not satisfy the predicate.
+      #
+      # @return [Array]
+      def take_until(accumulator = [], &block)
+        # This is in tail call form
+        unless empty? or yield(head)
+          tail.take_until(head.snoc(accumulator), &block)
+        else
+          accumulator
+        end
+      end
+
+      # Splits the array into prefix/suffix pair according to the predicate.
+      #
+      # @return [(Array, Array)]
+      def split_until(&block)
+        prefix = take_while(&block)
+        suffix = drop(prefix.length)
+        return prefix, suffix
+      end
+
+      # Splits the array into prefix/suffix pair according to the predicate.
+      #
+      # @return [(Array, Array)]
+      def split_when(&block)
+        prefix = take_until(&block)
+        suffix = drop(prefix.length)
+        return prefix, suffix
+      end
+
+      # Returns a list of sublists, where each sublist contains only equal
+      # elements. Equality is determined by a two-argument block parameter.
+      # The concatenation of the result is equal to the original argument.
+      #
+      # @example
+      #   "abba".split(//).group_seq(&:==) #=> [["y"], ["a"], ["b", "b"], ["a"]]
+      #
+      # @return [[Array]]
+      def runs(&block)
+        unless empty?
+          as, bs = tail.split_until{|x| block.call(head, x) }
+          head.cons(as).cons(bs.runs(&block))
+        else
+          []
+        end
+      end
+
+      # @endgroup
+      #############################################################################
+
+      # Accumulate elements using the `+` method, optionally
+      # transforming them first using a block
+      #
+      # @example
+      #   ["a", "b", "cd"].sum             #=> "abcd"
+      #   ["a", "b", "cd"].sum(&:length)   #=> 4
+      #
+      def sum(&block)
+        if block_given?
+          tail.inject(yield(head)){|sum,e| sum + yield(e) }
+        else
+          tail.inject(head){|sum,e| sum + e }
+        end
+      end
+
+      # Count the number of elements that satisfy the predicate
+      #
+      # @example
+      #   ["abc", "de", "fg", "hi"].count{|s| s.length == 2 } #=> 3
+      #   ["a", "b", "a", "c", "a"].count("a")                #=> 3
+      #   [1, 3, 5, 9, 0].count                               #=> 5
+      #
+      # @return [Integer]
+      def count(*args)
+        if block_given?
+          inject(0){|n, e| yield(e) ? n + 1 : n }
+        elsif args.empty?
+          size
+        else
+          inject(0){|n, e| e == args.first ? n + 1 : n }
+        end
+      end
     end
-  end
-
-  # Drops the longest prefix of elements that do not satisfy the predicate.
-  #
-  # @return [Array]
-  def drop_until(&block)
-    # This is in tail call form
-    unless empty? or yield(head)
-      tail.drop_until(&block)
-    else
-      self
-    end
-  end
 
-  # Takes the longest prefix of elements that satisfy the predicate.
-  #
-  # @return [Array]
-  def take_while(accumulator = [], &block)
-    # This is in tail call form
-    if not empty? and yield(head)
-      tail.take_while(head.snoc(accumulator), &block)
-    else
-      accumulator
-    end
-  end
-
-  # Takes the longest prefix of elements that do not satisfy the predicate.
-  #
-  # @return [Array]
-  def take_until(accumulator = [], &block)
-    # This is in tail call form
-    unless empty? or yield(head)
-      tail.take_until(head.snoc(accumulator), &block)
-    else
-      accumulator
-    end
   end
-
-  # Splits the array into prefix/suffix pair according to the predicate.
-  #
-  # @return [(Array, Array)]
-  def split_until(&block)
-    prefix = take_while(&block)
-    suffix = drop(prefix.length)
-    return prefix, suffix
-  end
-
-  # Splits the array into prefix/suffix pair according to the predicate.
-  #
-  # @return [(Array, Array)]
-  def split_when(&block)
-    prefix = take_until(&block)
-    suffix = drop(prefix.length)
-    return prefix, suffix
-  end
-
-  # Returns a list of sublists, where each sublist contains only equal
-  # elements. Equality is determined by a two-argument block parameter.
-  # The concatenation of the result is equal to the original argument.
-  #
-  # @example
-  #   "abba".split(//).group_seq(&:==) #=> [["y"], ["a"], ["b", "b"], ["a"]]
-  #
-  # @return [[Array]]
-  def runs(&block)
-    unless empty?
-      as, bs = tail.split_until{|x| block.call(head, x) }
-      head.cons(as).cons(bs.runs(&block))
-    else
-      []
-    end
-  end
-
-  # @endgroup
-  #############################################################################
 end

data/lib/ruby/blank.rb

@@ -1,69 +1,53 @@
-class String
+module Stupidedi
+  module Refinements
+
+    refine String do
+      # True if the string is `empty?` or contains all whitespace
+      #
+      # @example
+      #   "abc".blank?    #=> false
+      #   "   ".blank?    #=> true
+      #   "".blank?       #=> true
+      #
+      def blank?
+        self !~ /\S/
+      end
+
+      def present?
+        self =~ /\S/
+      end
+    end
+
+    refine NilClass do
+      # Always `true`. Note this overrides {Object#blank?} which returns false.
+      #
+      # @example
+      #   nil.blank?    #=> true
+      #
+      def blank?
+        true
+      end
+
+      def present?
+        false
+      end
+    end
+
+    refine Object do
+      # Always `false`. Note that {NilClass#blank?} is overridden to return `true`
+      #
+      # @example
+      #   false.blank?    #=> false
+      #   100.blank?      #=> false
+      #
+      def blank?
+        false
+      end
+
+      def present?
+        true
+      end
+    end
 
-  # True if the string is `empty?` or contains all whitespace
-  #
-  # @example
-  #   "abc".blank?    #=> false
-  #   "   ".blank?    #=> true
-  #   "".blank?       #=> true
-  #
-  def blank?
-    self !~ /\S/
-  end
-
-  def present?
-    self =~ /\S/
-  end
-end
-
-# module Enumerable
-#
-#   # True if the collection is `empty?`
-#   #
-#   # @example
-#   #   [1,2].blank?    #=> false
-#   #   [].blank?       #=> false
-#   #
-#   unless respond_to?(:blank?)
-#
-#   def blank?
-#     empty?
-#   end
-#
-#   def present?
-#     not empty?
-#   end
-# end
-
-class NilClass
-
-  # Always `true`. Note this overrides {Object#blank?} which returns false.
-  #
-  # @example
-  #   nil.blank?    #=> true
-  #
-  def blank?
-    true
-  end
-
-  def present?
-    false
-  end
-end
-
-class Object
-
-  # Always `false`. Note that {NilClass#blank?} is overridden to return `true`
-  #
-  # @example
-  #   false.blank?    #=> false
-  #   100.blank?      #=> false
-  #
-  def blank?
-    false
-  end
-
-  def present?
-    true
   end
 end