memory_record 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4e8c3d1cda033561e441032be32332be1327c9876a4a62d0d64cac44b024f99
-  data.tar.gz: 2b9fed19a0944263ac9d0895677018537557c5f4d2d5bba9b4536f02c97f517c
+  metadata.gz: 64b86bd76f59f5da1e0e4111208b5fdb868df86865239e998c9d4de5796f43e6
+  data.tar.gz: 405a3da00872ef9c104ac6208c225eb808b7329443be89cc1ee3328b3aec0a5e
 SHA512:
-  metadata.gz: 8412d6ec55aaea46004a97a34d111e66c0a5fc5901ad975f2714842087f5a5168935920f752f426930fa1967816950c742a4a4f14c9e03951d9fdf248e372565
-  data.tar.gz: 3d994cce8445425741eb6245b65dfac26d7dae8253062ea8b9a5694f32baab72be36d4b1b167c29cc8fe26c68b662ce4a1d96ab345aee008b145a767e429175e
+  metadata.gz: 0f243e8cf16808efda1c6fab438c1631982d9d825d1dd760f5bc3c1741ee30d1ca01ec1e79a5259e6f2757cef8153d6823e8360ee4df09fa2644745c4ac6bb69
+  data.tar.gz: 51f7d2216b5aef88194fd7d9c76362babab8800193c85b7bb511d6aa6d4cbda004e7992891d77113101e86e04e02f868b22831d41e28c17e43ca817d5bb89912

data/README.md

@@ -2,7 +2,8 @@
 
 [![Build Status](https://travis-ci.org/akicho8/memory_record.svg?branch=master)](https://travis-ci.org/akicho8/memory_record)
 [![Gem Version](https://badge.fury.io/rb/memory_record.svg)](https://badge.fury.io/rb/memory_record)
-[![Dependency Status](https://gemnasium.com/badges/github.com/akicho8/memory_record.svg)](https://gemnasium.com/github.com/akicho8/memory_record)
+
+<!-- [![Dependency Status](https://gemnasium.com/badges/github.com/akicho8/memory_record.svg)](https://gemnasium.com/github.com/akicho8/memory_record) -->
 
 ## Introduction
 
@@ -206,14 +207,18 @@ class ColorInfo
 
   def children
     [
-      {foo: 1, bar: 3},
-      {foo: 2, bar: 4},
+      {x: 1, y: 2},
+      {x: 3, y: 4},
     ]
   end
 end
 
-ColorInfo.first.as_json(only: :key)              # => {:key => :blue}
-ColorInfo.first.as_json(except: [:rgb, :code])   # => {:key => :blue}
-ColorInfo.first.as_json(only: [], methods: :hex) # => {:hex => "#0000FF"}
-ColorInfo.first.as_json(only: [], include: {children: {only: :foo}} ).should == {:children => [{"foo" => 1}, {"foo" => 2}]}
+color_info = ColorInfo.first
+color_info.as_json(only: :key)              # => {:key => :blue}
+color_info.as_json(except: [:rgb, :code])   # => {:key => :blue}
+color_info.as_json(only: [], methods: :hex) # => {:hex => "#0000FF"}
+color_info.as_json(only: [], include: {children: {only: :x}} ) # => {:children => [{"x" => 1}, {"x" => 3}]}
+
+ColorInfo.as_json(only: :key)               # => [{:key=>:blue}, {:key=>:red}]
+ColorInfo.to_json(only: :key)               # => "[{\"key\":\"blue\"},{\"key\":\"red\"}]"
 ```

data/examples/0320_as_json.rb

@@ -40,3 +40,6 @@ ColorInfo.first.as_json(only: :key)                                 # => {:key=>
 ColorInfo.first.as_json(except: [:rgb, :code, :a])                  # => {:key=>:blue}
 ColorInfo.first.as_json(only: [], methods: :hex)                    # => {:hex=>"#0000FF"}
 ColorInfo.first.as_json(only: [], include: {children: {only: :a}} ) # => {:children=>[{"a"=>1}, {"a"=>1}, {:a=>1}]}
+
+ColorInfo.as_json(only: :key)   # => [{:key=>:blue}, {:key=>:red}]
+ColorInfo.to_json(only: :key)   # => "[{\"key\":\"blue\"},{\"key\":\"red\"}]"

data/examples/0330_comparable.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift '../lib'
+require 'memory_record'
+
+class Foo
+  include MemoryRecord
+  memory_record [
+    { key: :a, },
+    { key: :b, },
+  ]
+end
+
+Foo[:a] == Foo[:a]              # => true
+Foo[:a] == Foo[:b]              # => false
+Foo[:a] < Foo[:b]               # => true

data/lib/memory_record/memory_record.rb

@@ -36,6 +36,7 @@ module MemoryRecord
       end
 
       extend Enumerable
+      include Comparable
       include ::MemoryRecord::SingletonMethods
       include ::MemoryRecord::Serialization
 
@@ -76,16 +77,11 @@ module MemoryRecord
           define_method(:name) { key.to_s }
         end
 
-        # sort matches definition order
+        # sort matches definition order. Comparable module methods will be available.
         def <=>(other)
           [self.class, code] <=> [other.class, other.code]
         end
 
-        # Even if duplicate, objects match
-        def ==(other)
-          self.class == other.class && key == other.key
-        end
-
         # Even if object_id of objects used as hash keys are different, they match. It also speeds up by defining hash.
         def eql?(other)
           self.class == other.class && key == other.key

data/lib/memory_record/version.rb

@@ -1,3 +1,3 @@
 module MemoryRecord
-  VERSION = '0.0.13'
+  VERSION = '0.0.14'
 end

data/spec/memory_record_spec.rb

@@ -1,22 +1,30 @@
 require 'spec_helper'
 
-class Model
-  include MemoryRecord
-  memory_record [
-    {name: 'A'},
-    {name: 'B'},
-  ], attr_reader: :name
-end
+RSpec.describe MemoryRecord do
+  class Model5
+    include MemoryRecord
+    memory_record [
+      { key: :a },
+      { key: :b },
+    ]
+  end
 
-class Legacy
-  include MemoryRecord
-  memory_record [
-    {code: 10, key: :a, name: 'A'},
-    {code: 20, key: :b, name: 'B'},
-  ], attr_reader: :name
-end
+  class Model
+    include MemoryRecord
+    memory_record [
+      { name: 'A' },
+      { name: 'B' },
+    ], attr_reader: :name
+  end
+
+  class Legacy
+    include MemoryRecord
+    memory_record [
+      { code: 10, key: :a, name: 'A', },
+      { code: 20, key: :b, name: 'B', },
+    ], attr_reader: :name
+  end
 
-RSpec.describe MemoryRecord do
   def class_new(table)
     Class.new {
       include MemoryRecord
@@ -26,21 +34,21 @@ RSpec.describe MemoryRecord do
 
   context 'Useful Class Methods' do
     it 'each' do
-      assert Model.each
+      assert { Model.each }
     end
 
     it 'keys' do
-      assert_equal [:_key0, :_key1], Model.keys
+      assert { [:_key0, :_key1] == Model.keys }
     end
 
     it 'values' do
-      assert_equal Model.each.to_a, Model.values
+      assert { Model.each.to_a == Model.values }
     end
   end
 
   context 'Subscript access to class' do
     it 'When code and key are automatically waved' do
-      assert_equal 'A', Model[0].name
+      assert { 'A' == Model[0].name }
     end
 
     it 'It will not cause an error even if there is no corresponding key' do
@@ -58,23 +66,23 @@ RSpec.describe MemoryRecord do
 
   context 'Subscript access to instance' do
     it do
-      Model.first[:name].should == 'A'
-      Model.first[:xxxx].should == nil
+      assert { Model.first[:name] == 'A' }
+      assert { Model.first[:xxxx] == nil }
     end
   end
 
   context 'to_s' do
     it do
-      Model.first.to_s.should == 'A'
+      assert { Model.first.to_s == 'A' }
     end
   end
 
   context 'instance accessor' do
     it do
-      assert Model.first.to_h
-      assert Model.first.attributes
-      assert Model.first.key
-      assert Model.first.code
+      assert { Model.first.to_h }
+      assert { Model.first.attributes }
+      assert { Model.first.key }
+      assert { Model.first.code }
     end
   end
 
@@ -84,35 +92,35 @@ RSpec.describe MemoryRecord do
       @model.memory_record_reset [{key: :b}, {key: :c}]
     end
     it 'changed' do
-      assert_equal [:b, :c], @model.keys
-      assert_equal [0, 1], @model.codes
+      assert { [:b, :c] == @model.keys }
+      assert { [0, 1] == @model.codes }
     end
   end
 
   context 'Subtle specifications' do
     it 'When keys are specified as an array, they become symbols with underscores' do
       model = class_new [{key: [:id, :desc]}]
-      assert_equal [:id_desc], model.keys
+      assert { [:id_desc] == model.keys }
     end
 
     it 'Name method is automatically defined if it is not defined' do
       model = class_new [{key: :foo}]
-      assert_equal true, model.instance_methods.include?(:name)
-      assert_equal "foo", model[:foo].name
+      assert { true == model.instance_methods.include?(:name) }
+      assert { "foo" == model[:foo].name }
     end
   end
 
   it 'Japanese can be used for key' do
     model = class_new [{key: 'あ'}]
-    assert model['あ']
+    assert { model['あ'] }
   end
 
   it 'When you define code and keys yourself' do
-    assert_equal 'A', Legacy[10].name
+    assert { 'A' == Legacy[10].name }
   end
 
   it 'We do not freeze values because memoization becomes impossible' do
-    Model.first.name.upcase!
+    assert_nothing_raised { Model.first.name.upcase! }
   end
 
   describe 'super' do
@@ -128,7 +136,7 @@ RSpec.describe MemoryRecord do
     end
 
     it 'Since methods are defined in ancestry, you can use super' do
-      assert_equal 'xy', Model2.first.var
+      assert { 'xy' == Model2.first.var }
     end
   end
 
@@ -142,15 +150,15 @@ RSpec.describe MemoryRecord do
     end
 
     it do
-      assert_equal 1, Model3.first.a
-      assert_equal nil, Model3.first.b
+      assert { 1 == Model3.first.a }
+      assert { nil == Model3.first.b }
     end
   end
 
   describe 'Do not duplicate key and code' do
     it do
-      expect { Model.memory_record_reset([{key: :a}, {key: :a}]) }.to raise_error(ArgumentError)
-      expect { Model.memory_record_reset([{code: 0}, {code: 0}]) }.to raise_error(ArgumentError)
+      assert_raises(ArgumentError) { Model.memory_record_reset([{key: :a}, {key: :a}]) }
+      assert_raises(ArgumentError) { Model.memory_record_reset([{code: 0}, {code: 0}]) }
     end
   end
 
@@ -169,27 +177,27 @@ RSpec.describe MemoryRecord do
     context 'false' do
       subject { element(attr_reader: false) }
       it do
-        assert_equal false, subject.respond_to?(:x)
-        assert_equal false, subject.respond_to?(:y)
-        assert_equal false, subject.respond_to?(:z)
+        assert { subject.respond_to?(:x) == false }
+        assert { subject.respond_to?(:y) == false }
+        assert { subject.respond_to?(:z) == false }
       end
     end
 
     context 'only' do
       subject { element(attr_reader: {only: [:x, :z]}) }
       it do
-        assert_equal true,  subject.respond_to?(:x)
-        assert_equal false, subject.respond_to?(:y)
-        assert_equal true,  subject.respond_to?(:z)
+        assert { subject.respond_to?(:x) == true  }
+        assert { subject.respond_to?(:y) == false }
+        assert { subject.respond_to?(:z) == true  }
       end
     end
 
     context 'except' do
       subject { element(attr_reader: {except: :y}) }
       it do
-        assert_equal true,  subject.respond_to?(:x)
-        assert_equal false, subject.respond_to?(:y)
-        assert_equal true,  subject.respond_to?(:z)
+        assert { subject.respond_to?(:x) == true  }
+        assert { subject.respond_to?(:y) == false }
+        assert { subject.respond_to?(:z) == true  }
       end
     end
   end
@@ -201,39 +209,50 @@ RSpec.describe MemoryRecord do
         super.key
       end
     end
-    model[:a].should == :a
+    assert { model[:a] == :a }
   end
 
   it "minus" do
     m = class_new [{key: :a}, {key: :b}]
-    ([m[:a], m[:b]] - [m[:a]]).should == [m[:b]]
+    assert { ([m[:a], m[:b]] - [m[:a]]) == [m[:b]] }
   end
 
   describe "sort (<=> method)" do
     it "same class" do
       m = class_new [{key: :a}, {key: :b}]
-      [m[:b], m[:a]].sort.should == [m[:a], m[:b]]
+      assert { [m[:b], m[:a]].sort == [m[:a], m[:b]] }
     end
 
     it "different class" do
       m1 = class_new [{key: :a}, {key: :b}]
       m2 = class_new [{key: :a}, {key: :b}]
-      expect { [m1[:b], m2[:a]].sort }.to raise_error(ArgumentError)
+      assert_raises(ArgumentError) { [m1[:b], m2[:a]].sort }
     end
   end
 
-  it "==" do
-    a = Model.fetch(:_key0)
-    b = Marshal.load(Marshal.dump(a))
-    (a == b).should == true
-  end
-
   it "eql?, hash" do
     a = Model.fetch(:_key0)
     b = Marshal.load(Marshal.dump(a))
     h = {}
     h[a] = true
-    h[b].should == true
+    assert { h[b] == true }
+  end
+
+  describe "Comparable operator" do
+    it do
+      model = class_new [
+        { key: :a },
+        { key: :b },
+      ]
+      assert { model[:a] < model[:b]  }
+      assert { model[:a] == model[:a] }
+    end
+
+    it "==" do
+      a = Model5.first
+      b = Marshal.load(Marshal.dump(a))
+      assert { a == b }
+    end
   end
 
   context 'as_json' do
@@ -271,10 +290,11 @@ RSpec.describe MemoryRecord do
     end
 
     it "as_json(options)" do
-      ColorInfo.first.as_json(only: :key).should                                 == {:key => :blue}
-      ColorInfo.first.as_json(except: [:rgb, :code, :a]).should                  == {:key => :blue}
-      ColorInfo.first.as_json(only: [], methods: :hex).should                    == {:hex => "#0000FF"}
-      ColorInfo.first.as_json(only: [], include: {children: {only: :a}} ).should == {:children => [{"a" => 1}, {"a" => 1}, {:a => 1}]}
+      assert { ColorInfo.first.as_json(only: :key) == {:key => :blue} }
+      assert { ColorInfo.first.as_json(except: [:rgb, :code, :a]) == {:key => :blue} }
+      assert { ColorInfo.first.as_json(only: [], methods: :hex) == {:hex => "#0000FF"} }
+      assert { ColorInfo.first.as_json(only: [], include: {children: {only: :a}}) == {:children => [{"a" => 1}, {"a" => 1}, {:a => 1}]} }
+      assert { ColorInfo.as_json(only: :key) == [{:key => :blue}, {:key => :red}] }
     end
   end
 end

data/spec/spec_helper.rb

@@ -2,8 +2,5 @@ $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'memory_record'
 
 RSpec.configure do |config|
-  config.expect_with :rspec do |expectations|
-    expectations.syntax = [:should, :expect]
-  end
   config.expect_with :test_unit
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: memory_record
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
 platform: ruby
 authors:
 - akicho8
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-20 00:00:00.000000000 Z
+date: 2018-06-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -117,6 +117,7 @@ files:
 - examples/0300_use_as_hash_key.rb
 - examples/0310_same_if_dup.rb
 - examples/0320_as_json.rb
+- examples/0330_comparable.rb
 - lib/memory_record.rb
 - lib/memory_record/memory_record.rb
 - lib/memory_record/memory_record/serialization.rb
@@ -144,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: A simple library that handles a few records easily