memory_record 0.0.9 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6a9d0e0253067464bc3fa778dab80bf47b635752094879aa4ad4f1a95ef6773
-  data.tar.gz: 2fd9222c966e16931cff928629e2d7a50237a6c39b7be2266f12eeb8fc80ea87
+  metadata.gz: 2c8085a6c6fdc528864f2ba6ea2314864ee756ec70e3c0f084aefe284e2bdc33
+  data.tar.gz: aa03716f97fc13275339ca8a7432b4b1a298465c91e09848141c0762e0fea563
 SHA512:
-  metadata.gz: c02532cc3ad012939336002e2cdad14e7a7afd0ba9684d5c510117454c915b9766dc3305a5c4737f1619e4db4439df9c723e52132f753772f2aa7bc45be9d76c
-  data.tar.gz: 18cd2b7a7378fca5a9a0d511c8789e8ed7c021c21295fb4c21a7f4060bf453db04b7de819b91df66be6d8fafe4ba8d9399a7e0a3a3345f7f5837ef0868caea33
+  metadata.gz: ff89e669f37fa84e06fa8cf71ed23b3116018cf5608212eadb5707640244dd800bc5f0bb1d89a227db055cb2cf608c355b4a677f853c37f275ec9f92d32ee2d6
+  data.tar.gz: ab3c487124bcd4795b517ee2e9cef6d4db37e10d2c6ac7668930efaae422223495a5c2332c579ffb9a6f9c11b0a56a5a81aa5fb79b19b0c266c96469fd2fec9d

data/{README.org → README.md}

@@ -1,28 +1,34 @@
-* MemoryRecord
+# MemoryRecord
 
-  A simple library that handles a few records easily.
-  With this library can flexibly managed immutable data.
+[![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)
 
-** Installation
+## Introduction
 
-   Install as a standalone gem
+A simple library that handles a few records easily.
+With this library can flexibly managed immutable data.
 
-#+BEGIN_SRC shell
+## Installation
+
+Install as a standalone gem
+
+```shell
 $ gem install memory_record
-#+END_SRC
+```
 
 Or install within application using Gemfile
 
-#+BEGIN_SRC shell
+```shell
 $ bundle add memory_record
 $ bundle install
-#+END_SRC
+```
 
-** Examples
+## Examples
 
-*** Basic usage
+### Basic usage
 
-#+BEGIN_SRC ruby
+```ruby
 class Language
   include MemoryRecord
   memory_record [
@@ -43,77 +49,77 @@ Language[:ruby].mr_author  # => "Mr. Yukihiro Matsumoto"
 
 Language.keys              # => [:lisp, :c, :ruby]
 Language.collect(&:author) # => ["John McCarthy", "Dennis Ritchie", "Yukihiro Matsumoto"]
-#+END_SRC
+```
 
-*** How to turn as an array?
+### How to turn as an array?
 
-    =Enumerable= extended, so that =each= method is available
+**Enumerable** extended, so that **each** method is available
 
-#+BEGIN_SRC ruby
+```ruby
 Foo.each { |e| ... }
 Foo.collect { |e| ... }
-#+END_SRC
+```
 
-*** How do I submit a form to select in Rails?
+### How do I submit a form to select in Rails?
 
-#+BEGIN_SRC ruby
+```ruby
 form.collection_select(:selection_code, Foo, :code, :name)
-#+END_SRC
+```
 
-*** Is the reference in subscripts slow?
+### Is the reference in subscripts slow?
 
-    Since it has a hash internally using the key value as a key, it can be acquired with O (1).
+Since it has a hash internally using the key value as a key, it can be acquired with O (1).
 
-#+BEGIN_SRC ruby
+```ruby
 Foo[1].name  # => "A"
 Foo[:a].name # => "A"
-#+END_SRC
+```
 
-*** Instances always react to =code= and =key=
+### Instances always react to **code** and **key**
 
-#+BEGIN_SRC ruby
+```ruby
 object = Foo.first
 object.key  # => :a
 object.code # => 1
-#+END_SRC
+```
 
-*** How do I add a method to an instance?
+### How do I add a method to an instance?
 
-    For that, I am creating a new class so I need to define it normally
+For that, I am creating a new class so I need to define it normally
 
-*** =name= method is special?
+### **name** method is special?
 
-    If =name= is not defined, it defines a =name= method that returns =key.to_s=
+If **name** is not defined, it defines a **name** method that returns **key.to_s**
 
-*** =to_s= method is defined?
+### **to_s** method is defined?
 
-    Alias of =name=, =to_s= is defined.
+Alias of **name**, **to_s** is defined.
 
-*** If there is no key, use fetch to get an error
+### If there is no key, use fetch to get an error
 
-#+BEGIN_SRC ruby
+```ruby
 Foo.fetch(:xxx)              # => <KeyError: ...>
-#+END_SRC
+```
 
-    The following are all the same
+The following are all the same
 
-#+BEGIN_SRC ruby
+```ruby
 Foo[:xxx] || :default        # => :default
 Foo.fetch(:xxx, :default}    # => :default
 Foo.fetch(:xxx) { :default } # => :default
-#+END_SRC
+```
 
-*** Use fetch_if to ignore if the key is nil
+### Use fetch_if to ignore if the key is nil
 
-#+BEGIN_SRC ruby
+```ruby
 Foo.fetch_if(nil)            # => nil
 Foo.fetch_if(:a)             # => #<Foo:... @attributes={...}>
 Foo.fetch_if(:xxx)           # => <KeyError: ...>
-#+END_SRC
+```
 
-*** How to refer to other keys
+### How to refer to other keys
 
-#+BEGIN_SRC ruby
+```ruby
 class Foo
   include MemoryRecord
   memory_record [
@@ -138,15 +144,15 @@ end
 Foo[:a] == Foo[:x]                  # => true
 Foo[:b] == Foo[:y]                  # => true
 Foo[:c] == Foo[:z]                  # => true
-#+END_SRC
+```
 
-*** How can I prohibit the hash key from being attr_reader automatically?
+### How can I prohibit the hash key from being attr_reader automatically?
 
-**** attr_reader: false
+#### attr_reader: false
 
 I think that it is better to use it when you want to make it difficult to access easily.
 
-#+BEGIN_SRC ruby
+```ruby
 class Foo
   include MemoryRecord
   memory_record attr_reader: false do
@@ -159,11 +165,11 @@ end
 Foo.first.x rescue $! # => #<NoMethodError: undefined method `x' for #<Foo:0x007fb2c710eda8>>
 Foo.first.y rescue $! # => #<NoMethodError: undefined method `y' for #<Foo:0x007fb2c710eda8>>
 Foo.first.z rescue $! # => #<NoMethodError: undefined method `z' for #<Foo:0x007fb2c710eda8>>
-#+END_SRC
+```
 
-**** attr_reader: {only: :y}
+#### attr_reader: {only: :y}
 
-#+BEGIN_SRC ruby
+```ruby
 class Foo
   include MemoryRecord
   memory_record attr_reader: {only: :y} do
@@ -176,11 +182,11 @@ end
 Foo.first.x rescue $! # => #<NoMethodError: undefined method `x' for #<Foo:0x007fcc861ff108>>
 Foo.first.y rescue $! # => 1
 Foo.first.z rescue $! # => #<NoMethodError: undefined method `z' for #<Foo:0x007fcc861ff108>>
-#+END_SRC
+```
 
-**** attr_reader: {except: :y}
+#### attr_reader: {except: :y}
 
-#+BEGIN_SRC ruby
+```ruby
 class Foo
   include MemoryRecord
   memory_record attr_reader: {except: :y} do
@@ -193,11 +199,11 @@ end
 Foo.first.x rescue $! # => 1
 Foo.first.y rescue $! # => #<NoMethodError: undefined method `y' for #<Foo:0x007ff033895e88>>
 Foo.first.z rescue $! # => 1
-#+END_SRC
+```
 
-*** How to decide =code= yourself?
+*** How to decide **code** yourself?
 
-#+BEGIN_SRC ruby
+```ruby
 class Foo
   include MemoryRecord
   memory_record [
@@ -208,7 +214,7 @@ class Foo
 end
 
 Foo.collect(&:code) # => [1, 2, 3]
-#+END_SRC
+```
 
-    It is not recommended to specify it explicitly.
-    It is useful only when refactoring legacy code with compatibility in mind.
+It is not recommended to specify it explicitly.
+It is useful only when refactoring legacy code with compatibility in mind.

data/examples/0300_use_as_hash_key.rb

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift '../lib'
+require 'memory_record'
+
+class C
+  include MemoryRecord
+  memory_record [
+    {key: :a},
+  ]
+end
+
+a = C[:a]
+b = Marshal.load(Marshal.dump(a))
+
+h = {}
+h[a] = true
+h[b]                            # => true

data/examples/0310_same_if_dup.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift '../lib'
+require 'memory_record'
+
+class C
+  include MemoryRecord
+  memory_record [
+    {key: :a},
+  ]
+end
+
+a = C[:a]
+b = Marshal.load(Marshal.dump(a))
+a == b                          # => true

data/lib/memory_record/memory_record.rb

@@ -78,9 +78,24 @@ module MemoryRecord
         end
 
         m.module_eval do
+          # sort matches definition order
           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
+          end
+
+          def hash
+            key.hash
+          end
         end
       }
 

data/lib/memory_record/version.rb

@@ -1,3 +1,3 @@
 module MemoryRecord
-  VERSION = '0.0.9'
+  VERSION = '0.0.10'
 end

data/spec/memory_record_spec.rb

@@ -220,4 +220,18 @@ RSpec.describe MemoryRecord do
       expect { [m1[:b], m2[:a]].sort }.to raise_error(ArgumentError)
     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
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: memory_record
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors:
 - akicho8
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-31 00:00:00.000000000 Z
+date: 2018-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -78,7 +78,7 @@ files:
 - ".travis.yml"
 - Gemfile
 - LICENSE.txt
-- README.org
+- README.md
 - Rakefile
 - examples/0100_basic.rb
 - examples/0110_for_legacy_code.rb
@@ -100,6 +100,8 @@ files:
 - examples/0270_instance_freeze.rb
 - examples/0280_sortable.rb
 - examples/0290_eql_behavior.rb
+- examples/0300_use_as_hash_key.rb
+- examples/0310_same_if_dup.rb
 - lib/memory_record.rb
 - lib/memory_record/memory_record.rb
 - lib/memory_record/version.rb