rb_lovely 0.6.5 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fbacf68a03009f39933493ff077a97ace08685c0
-  data.tar.gz: 4c8d5d57b559c93215e7b9be01c95fb3c6073e40
+  metadata.gz: ee5ff98c21526db5492808222dda0a1323a6e307
+  data.tar.gz: abdce3830c9a0be152907318f05f0f7267332814
 SHA512:
-  metadata.gz: 6b457ed98975e79f3d567f32c5ba42efa38df04400918908d3213f2a5461133044f4dcde5f6565e0b57fe6364aeecfd607d1c34582c57f9b251ca132eaf51392
-  data.tar.gz: 0402307048f4051120ccc841dc86e1971de96cfe4c927c67ad0c0c084219ca765a797c0a40944cbd7b15564ffe69015555ad89c7698b3c0e6eae866bf526781a
+  metadata.gz: 0ae92b111ea962b4e7e962d556a428c3627e62d724417e05846f875177c76e4b37fd9816103567ae50139dabe55da64e0ac1f835341b5ec6c883505d6be492c6
+  data.tar.gz: 91f3b2d225924117724ebdeb3a23948eeb728500d4bf60635a4687385e1038de8aa6552ee33cf67ec01d045555bced30c96030f85def4452d9d2dc6414d6640c

data/ext/rb_lovely/container.hpp

@@ -5,7 +5,7 @@
 
 namespace rb_lovely {
 
-auto rbInspect = [](VALUE val) { return RSTRING_PTR(rb_funcall(val, inspectSym, 0)); };
+auto rbInspect = [](VALUE val) { return RSTRING_PTR(rb_inspect(val)); };
 
 }
 #endif

data/ext/rb_lovely/package.cpp

@@ -5,7 +5,6 @@ namespace rb_lovely {
   VALUE rbMod;
   VALUE cmpMethSym;
   VALUE hashEqualitySym;
-  VALUE inspectSym;
   VALUE hashSym;
   VALUE compareSym;
   VALUE callSym;

data/ext/rb_lovely/ruby_util.hpp

@@ -7,7 +7,6 @@ namespace rb_lovely {
 extern VALUE rbMod;
 extern VALUE cmpMethSym;
 extern VALUE hashEqualitySym;
-extern VALUE inspectSym;
 extern VALUE hashSym;
 extern VALUE callSym;
 extern VALUE compareSym;
@@ -39,7 +38,6 @@ static void initRubyUtil() {
   rbMod = rb_define_module("RbLovely");
   cmpMethSym = rb_intern("<=>");
   hashEqualitySym = rb_intern("eql?");
-  inspectSym = rb_intern("inspect");
   hashSym = rb_intern("hash");
   callSym = rb_intern("call");
   compareSym = ID2SYM(rb_intern("compare"));

data/ext/rb_lovely/sorted_hash.cpp

@@ -181,10 +181,31 @@ VALUE hashToString(VALUE self) {
 
 VALUE hashFirst(VALUE self) {
   Hash* hash = rubyCast<Hash>(self);
-  return hash->container.empty() ? Qnil : hash->container.get<1>().begin()->val;
+  if (hash->container.empty()) {
+    return Qnil;
+  }
+
+  auto &pair = *hash->container.get<1>().begin();
+  return rb_ary_new3(2, pair.key, pair.val);
 }
 
 VALUE hashLast(VALUE self) {
+  Hash* hash = rubyCast<Hash>(self);
+  if (hash->container.empty()) {
+    return Qnil;
+  }
+
+  auto it = hash->container.get<1>().end();
+  --it;
+  return rb_ary_new3(2, it->key, it->val);
+}
+
+VALUE hashFirstValue(VALUE self) {
+  Hash* hash = rubyCast<Hash>(self);
+  return hash->container.empty() ? Qnil : hash->container.get<1>().begin()->val;
+}
+
+VALUE hashLastValue(VALUE self) {
   Hash* hash = rubyCast<Hash>(self);
   if (hash->container.empty())
     return Qnil;
@@ -212,13 +233,41 @@ VALUE hashShift(VALUE self) {
   if (hash->container.empty())
    return Qnil;
 
+  auto& idx = hash->container.get<1>();
+  auto keyBak = idx.begin()->key;
+  auto valBak = idx.begin()->val;
+  idx.erase(idx.begin());
+
+  return rb_ary_new3(2, keyBak, valBak);
+}
+
+VALUE hashPop(VALUE self) {
+  Hash* hash = rubyCast<Hash>(self);
+  if (hash->container.empty())
+   return Qnil;
+
+  auto& idx = hash->container.get<1>();
+  auto last = idx.end();
+  --last;
+  auto keyBak = last->key;
+  auto valBak = last->val;
+  idx.erase(last);
+
+  return rb_ary_new3(2, keyBak, valBak);
+}
+
+VALUE hashShiftValue(VALUE self) {
+  Hash* hash = rubyCast<Hash>(self);
+  if (hash->container.empty())
+   return Qnil;
+
   auto& idx = hash->container.get<1>();
   auto bak = idx.begin()->val;
   idx.erase(idx.begin());
   return bak;
 }
 
-VALUE hashPop(VALUE self) {
+VALUE hashPopValue(VALUE self) {
   Hash* hash = rubyCast<Hash>(self);
   if (hash->container.empty())
     return Qnil;
@@ -269,12 +318,16 @@ extern "C" {
     rb_define_method(rbHash, "to_s", RUBY_METHOD_FUNC(hashToString), 0);
     rb_define_method(rbHash, "first", RUBY_METHOD_FUNC(hashFirst), 0);
     rb_define_method(rbHash, "last", RUBY_METHOD_FUNC(hashLast), 0);
+    rb_define_method(rbHash, "first_value", RUBY_METHOD_FUNC(hashFirstValue), 0);
+    rb_define_method(rbHash, "last_value", RUBY_METHOD_FUNC(hashLastValue), 0);
     rb_define_method(rbHash, "delete", RUBY_METHOD_FUNC(hashDelete), 1);
     // rb_define_method(rbHash, "reject!", RUBY_METHOD_FUNC(hashMutatingReject), 0);
     // rb_define_method(rbHash, "reject_first!", RUBY_METHOD_FUNC(hashMutatingRejectFirst), 0);
     // rb_define_method(rbHash, "select!", RUBY_METHOD_FUNC(hashMutatingSelect), 0);
     rb_define_method(rbHash, "shift", RUBY_METHOD_FUNC(hashShift), 0);
     rb_define_method(rbHash, "pop", RUBY_METHOD_FUNC(hashPop), 0);
+    rb_define_method(rbHash, "shift_value", RUBY_METHOD_FUNC(hashShiftValue), 0);
+    rb_define_method(rbHash, "pop_value", RUBY_METHOD_FUNC(hashPopValue), 0);
     // Enumerable would test both key and value for include?
     rb_define_method(rbHash, "include?", RUBY_METHOD_FUNC(hashHas), 1);
     rb_define_method(rbHash, "has_key?", RUBY_METHOD_FUNC(hashHas), 1);

data/yard.rb

@@ -22,7 +22,7 @@ module RbLovely
   #
   #   empty_set = RbLovely::SortedSet.new
   #
-  #   set = RbLovely::SortedSet [ Person.new('Nyamuk', 2), Person.new('Cold Rain', 9999) ]
+  #   set = RbLovely::SortedSet [Person.new('Nyamuk', 2), Person.new('Cold Rain', 9999)]
   #   set.add Person.new('Beards', 15)
   #   set << Person.new('Anna', 12)
   #   set.add Person.new('Moust', 18)
@@ -37,12 +37,14 @@ module RbLovely
     include Enumerable
 
     # @param content [Array] An array of values to insert into the set.
+    # @complexity O(n).
     # @example
     #   set = RbLovely::SortedSet.new [3,1,2]
     #   expect(set.to_a).to eql [1,2,3]
     def initialize content = [] ; end
 
     # Factory method for creating sorted set from array.
+    # @complexity O(n).
     # @param content [Array] An array of values to insert into the created set.
     # @return [SortedSet] New sorted set instance.
     # @example
@@ -55,7 +57,7 @@ module RbLovely
     # @return The value that was removed or nil if no value was removed.
     # @param value Value to remove (each member is compared to value using the <=> method).
     # @example
-    #   set = RbLovely::SortedSet [ 1, 5, 3 ]
+    #   set = RbLovely::SortedSet [1, 5, 3]
     #   set.delete 3
     #   expect(set.to_a).to eql [1, 5]
     def delete value ; end
@@ -77,8 +79,8 @@ module RbLovely
     def last ; end
 
     # Remove the first element from the set.
-    # @see #pop
     # @complexity O(c).
+    # @see #pop
     # @return The first value according to the <=> method defined on each member or nil if the set is empty.
     # @example
     #   set = RbLovely::SortedSet [4, 0, 2]
@@ -86,8 +88,8 @@ module RbLovely
     def shift ; end
 
     # Remove the last element from the set.
-    # @see #shift
     # @complexity O(c).
+    # @see #shift
     # @return The last value according to the <=> method defined on each member or nil if the set is empty.
     # @example
     #   set = RbLovely::SortedSet [4, 0, 2]
@@ -129,10 +131,12 @@ module RbLovely
     def each(&block) ; end
 
     # Gets the number of elements in the set.
+    # @complexity O(c).
     # @return [Number] Number of items in set.
     def length ; end
 
     # Return true if the set is empty.
+    # @complexity O(c).
     # @return [Boolean] True only if the set is empty else false.
     def empty? ; end
   end
@@ -149,15 +153,18 @@ module RbLovely
   # @example
   #   empty_hash = RbLovely::SortedHash.new
   #
-  #   # constructor is like: hash[20] = 5 ; hash[9] = 1
-  #   hash = RbLovely::SortedHash [20, 5, 9, 1]
-  #   hash[2] = 16
-  #   hash[20] = 4 # updates previous value
-  #   expect(hash[20]).to equal 4
+  #   # constructor is like: hash[:y] = 5 ; hash[:i] = 1
+  #   hash = RbLovely::SortedHash [:y, 5, :i, 1]
+  #   hash[:b] = 16
+  #   hash[:y] = 4 # updates previous value
+  #   expect(hash.first).to equal [:i, 1]
+  #   expect(hash[:y]).to equal 4
   #   expect(hash.length).to equal 3
+  #   expect(hash.to_a).to eql [[:i, 1], [:y, 4], [:b, 16]]
   class SortedHash
     include Enumerable
 
+    # @complexity O(n).
     # @param content [Array] An array containing key, value, key, value ...
     # @param compare [Proc] Comparison function used to order values (rather than default
     #                       of using <=> method).
@@ -174,6 +181,7 @@ module RbLovely
     def initialize content = [], compare: nil ; end
 
     # Factory method for creating sorted hash from array.
+    # @complexity O(n).
     # @param content [Array] An array of values to insert into the created hash.
     # @return [SortedHash] New sorted set instance.
     # @example
@@ -182,6 +190,7 @@ module RbLovely
     def self.[](*content) ; end
 
     # Set the value associated with a key. If the key already then it and its value are removed.
+    # @complexity O(c).
     # @return The value that was passed.
     # @example
     #   hash = RbLovely::SortedHash.new
@@ -197,6 +206,7 @@ module RbLovely
     def replace(key, value) ; end
 
     # Delete the value associated with a key.
+    # @complexity O(c)
     # @return The value associated with the deleted key or nil if the key was not in the hash.
     # @example
     #   hash = RbLovely::SortedHash [:a, 5 ]
@@ -213,6 +223,7 @@ module RbLovely
     def each(&block) ; end
 
     # Remove all values from the hash.
+    # @complexity O(n)
     # @example
     #   hash = RbLovely::SortedHash [:a, 10]
     #   hash.clear
@@ -228,41 +239,84 @@ module RbLovely
     def [](key) ; end
 
     # Return true if the key is contained in the hash.
+    # @complexity O(c)
     def include?(key) ; end
     alias :has_key? :include?
     alias :key? :include?
 
-    # Retrieve first value as determined by value sort order or nil if the hash is empty.
+    # Retrieve first key-value pair as determined by value sort order or nil if the hash is empty.
     # @complexity O(c)
+    # @example
+    #   @set = RbLovely::SortedHash [:a, 2, :b, 1]
+    #   expect(@set.first).to equal [:b, 1]
     def first ; end
 
-    # Retrieve last value as determined by value sort order or nil if the hash is empty.
+    # Retrieve first_value value as determined by value sort order or nil if the hash is empty.
+    # @complexity O(c)
+    # @return [Array] The first key-value pair in the hash.
+    # @example
+    #   @set = RbLovely::SortedHash [:a, 2, :b, 1]
+    #   expect(@set.first_value).to equal 1
+    def first_value ; end
+
+    # Retrieve last key-value pair as determined by value sort order or nil if the hash is empty.
     # @complexity O(c)
+    # @return [Array] The last key-value pair in the hash.
+    # @example
+    #   @set = RbLovely::SortedHash [:a, 2, :b, 1]
+    #   expect(@set.last).to equal [:a, 2]
     def last ; end
 
-    # Remove the first value in the hash and return it or return nil if the hash is empty.
+    # Retrieve last value as determined by value sort order or nil if the hash is empty.
+    # @complexity O(c)
+    # @example
+    #   @set = RbLovely::SortedHash [:a, 2, :b, 1]
+    #   expect(@set.last_value).to equal 2
+    def last_value ; end
+
+    # Remove the first key-value pair in the hash and return it or return nil if the hash is empty.
     # @complexity O(c).
     # @see #pop
-    # @return The first value according to the <=> method defined on each member or nil if the hash is empty.
+    # @return [Array] The first key-value pair according to the <=> method defined on each member or nil if the hash is empty.
     # @example
     #   set = RbLovely::SortedHash [:a, 2, :b, 10]
-    #   expect(hash.shift).to equal 2
+    #   expect(hash.shift).to equal [:a, 2]
     def shift ; end
 
-    # Remove the last value in the hash and return it or return nil if the hash is empty.
+    # Remove the last key-value pair in the hash and return it or return nil if the hash is empty.
     # @complexity O(c).
     # @see #shift
-    # @return The last value according to the <=> method defined on each member or nil if the hash is empty.
+    # @return [Array] The last key-value pair according to the <=> method defined on each member or nil if the hash is empty.
     # @example
     #   set = RbLovely::SortedHash [:a, 2, :b, 10]
-    #   expect(hash.pop).to equal 10
+    #   expect(hash.pop).to equal [:b, 10]
     def pop ; end
 
+    # Remove the first key-value pair in the hash and return it or return nil if the hash is empty.
+    # @complexity O(c).
+    # @see #pop_value
+    # @return The first value according to the <=> method defined on each member or nil if the hash is empty.
+    # @example
+    #   set = RbLovely::SortedHash [:a, 2, :b, 10]
+    #   expect(hash.shift_value).to equal 2
+    def shift_value ; end
+
+    # Remove the last key-value pair in the hash and return it or return nil if the hash is empty.
+    # @complexity O(c).
+    # @see #shift_value
+    # @return The last value according to the <=> method defined on each member or nil if the hash is empty.
+    # @example
+    #   set = RbLovely::SortedHash [:a, 2, :b, 10]
+    #   expect(hash.pop_value).to equal 10
+    def pop_value ; end
+
     # Gets the number of elements in the hash.
+    # @complexity O(c).
     # @return [Number] Number of items in hash.
     def length ; end
 
     # Return true if the hash is empty.
+    # @complexity O(c).
     # @return [Boolean] True only if the hash is empty else false.
     def empty? ; end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rb_lovely
 version: !ruby/object:Gem::Version
-  version: 0.6.5
+  version: 0.7.0
 platform: ruby
 authors:
 - James Pike