memory_record 0.0.11 → 0.0.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ad1f7912204a4b4b9a098d2258b13e6bc9ab9d1ef231b5d9d7ebb4a97f6cf338
-  data.tar.gz: 997946f9e26295cf48485487eb8b2b99c941f76fc9600d6edf6a8594a9ff28c7
+  metadata.gz: 8a31161518612170878b45f58d9952e75403826b6ed1a3345e3a116b81b8b24c
+  data.tar.gz: d0c23e8933f7576c00608b5cc1f5fe233b3f609db3371d22b5ac25e08d198d02
 SHA512:
-  metadata.gz: 34edca154caf9330a144c06c6f96859ac90286d6cadf5008a795819f2744547b85ed2213ad9aa420476c7ff44533076c113b5b0233a01f06ffdaa3cf7634e798
-  data.tar.gz: 6736b1ba71f5003c62b57dc64f06cea334c34a5bad64538112ec03c8f668c12e0fc1aa2c9de93c2b08dfff580dd9f5b464888ef6c8014d8857856699e2a7393d
+  metadata.gz: 830f15f5f99178dc80e2f142d10aa4dd7f23431aca3ede47bb3591624d1e98e190485500742eb2622487f929cecd56f5507252b7b4941727e83315bc00ff4cad
+  data.tar.gz: bd185cef177836f31268c760225e7df2935f5f42921420168819f4007543d8108046b0d4f7bd76d3e5fb41d61ed83ff726d6d3bf3973f06e6c382278129e6d29

data/README.md

@@ -29,26 +29,32 @@ $ bundle install
 ### Basic usage
 
 ```ruby
-class Language
+class Palette
   include MemoryRecord
   memory_record [
-    {key: :lisp, author: "John McCarthy"      },
-    {key: :c,    author: "Dennis Ritchie"     },
-    {key: :ruby, author: "Yukihiro Matsumoto" },
+    { key: :coral,  r: 255, g: 127, b:   0 },
+    { key: :tomato, r: 255, g:  99, b:  71 },
+    { key: :gold,   r: 255, g: 215, b:   0 },
   ]
 
-  def mr_author
-    "Mr. #{author}"
+  def rgb
+    [r, g, b]
   end
-end
 
-Language[:ruby].key        # => :ruby
-Language[:ruby].code       # => 2
-Language[:ruby].author     # => "Yukihiro Matsumoto"
-Language[:ruby].mr_author  # => "Mr. Yukihiro Matsumoto"
+  def hex
+    "#" + rgb.collect { |e| "%02X" % e }.join
+  end
 
-Language.keys              # => [:lisp, :c, :ruby]
-Language.collect(&:author) # => ["John McCarthy", "Dennis Ritchie", "Yukihiro Matsumoto"]
+  def name
+    super.capitalize
+  end
+end
+
+Palette[:tomato].key   # => :tomato
+Palette[:tomato].name  # => "Tomato"
+Palette[:tomato].rgb   # => [255, 99, 71]
+Palette[:tomato].hex   # => "#FF6347"
+Palette.collect(&:hex) # => ["#FF7F00", "#FF6347", "#FFD700"]
 ```
 
 ### How to turn as an array?
@@ -56,14 +62,14 @@ Language.collect(&:author) # => ["John McCarthy", "Dennis Ritchie", "Yukihiro Ma
 **Enumerable** extended, so that **each** method is available
 
 ```ruby
-Foo.each { |e| ... }
-Foo.collect { |e| ... }
+Palette.each { |e| ... }
+Palette.collect { |e| ... }
 ```
 
 ### How do I submit a form to select in Rails?
 
 ```ruby
-form.collection_select(:selection_code, Foo, :code, :name)
+form.collection_select(:selection_code, Palette, :code, :name)
 ```
 
 ### Is the reference in subscripts slow?
@@ -71,15 +77,15 @@ form.collection_select(:selection_code, Foo, :code, :name)
 Since it has a hash internally using the key value as a key, it can be acquired with O (1).
 
 ```ruby
-Foo[1].name  # => "A"
-Foo[:a].name # => "A"
+Palette[1].name       # => "Tomato"
+Palette[:tomato].name # => "Tomato"
 ```
 
 ### Instances always react to **code** and **key**
 
 ```ruby
-object = Foo.first
-object.key  # => :a
+object = Palette[:tomato]
+object.key  # => :tomato
 object.code # => 1
 ```
 
@@ -98,23 +104,23 @@ Alias of **name**, **to_s** is defined.
 ### If there is no key, use fetch to get an error
 
 ```ruby
-Foo.fetch(:xxx)              # => <KeyError: ...>
+Palette.fetch(:xxx)              # => <KeyError: ...>
 ```
 
 The following are all the same
 
 ```ruby
-Foo[:xxx] || :default        # => :default
-Foo.fetch(:xxx, :default}    # => :default
-Foo.fetch(:xxx) { :default } # => :default
+Palette[:xxx] || :default        # => :default
+Palette.fetch(:xxx, :default}    # => :default
+Palette.fetch(:xxx) { :default } # => :default
 ```
 
 ### Use fetch_if to ignore if the key is nil
 
 ```ruby
-Foo.fetch_if(nil)            # => nil
-Foo.fetch_if(:a)             # => #<Foo:... @attributes={...}>
-Foo.fetch_if(:xxx)           # => <KeyError: ...>
+Palette.fetch_if(nil)            # => nil
+Palette.fetch_if(:tomato)        # => #<Palette:... @attributes={...}>
+Palette.fetch_if(:xxx)           # => <KeyError: ...>
 ```
 
 ### How to refer to other keys
@@ -123,9 +129,9 @@ Foo.fetch_if(:xxx)           # => <KeyError: ...>
 class Foo
   include MemoryRecord
   memory_record [
-    {key: :a, other_key: :x},
-    {key: :b, other_key: :y},
-    {key: :c, other_key: :z},
+    { key: :a, other_key: :x },
+    { key: :b, other_key: :y },
+    { key: :c, other_key: :z },
   ]
 
   class << self
@@ -146,35 +152,16 @@ Foo[:b] == Foo[:y]                  # => true
 Foo[:c] == Foo[:z]                  # => true
 ```
 
-### How can I prohibit the hash key from being attr_reader automatically?
-
-#### attr_reader: false
-
-I think that it is better to use it when you want to make it difficult to access easily.
-
-```ruby
-class Foo
-  include MemoryRecord
-  memory_record attr_reader: false do
-    [
-      {x: 1, y: 1, z: 1},
-    ]
-  end
-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>>
-```
+### How prohibit the hash key from being attr_reader automatically?
 
-#### attr_reader: {only: :y}
+Use `attr_reader: false` or `attr_reader: {only: ...}` or `attr_reader: {except: ...}`
 
 ```ruby
 class Foo
   include MemoryRecord
   memory_record attr_reader: {only: :y} do
     [
-      {x: 1, y: 1, z: 1},
+      { x: 1, y: 1, z: 1 },
     ]
   end
 end
@@ -184,36 +171,18 @@ Foo.first.y rescue $! # => 1
 Foo.first.z rescue $! # => #<NoMethodError: undefined method `z' for #<Foo:0x007fcc861ff108>>
 ```
 
-#### attr_reader: {except: :y}
-
-```ruby
-class Foo
-  include MemoryRecord
-  memory_record attr_reader: {except: :y} do
-    [
-      {x: 1, y: 1, z: 1},
-    ]
-  end
-end
-
-Foo.first.x rescue $! # => 1
-Foo.first.y rescue $! # => #<NoMethodError: undefined method `y' for #<Foo:0x007ff033895e88>>
-Foo.first.z rescue $! # => 1
-```
-
 *** How to decide **code** yourself?
 
 ```ruby
 class Foo
   include MemoryRecord
   memory_record [
-    {code: 1, key: :a, name: "A"},
-    {code: 2, key: :b, name: "B"},
-    {code: 3, key: :c, name: "C"},
+    { code: 1, key: :a, name: "A" },
+    { code: 2, key: :b, name: "B" },
   ]
 end
 
-Foo.collect(&:code) # => [1, 2, 3]
+Foo.collect(&:code) # => [1, 2]
 ```
 
 It is not recommended to specify it explicitly.

data/examples/0100_basic.rb

@@ -1,23 +1,29 @@
 $LOAD_PATH.unshift '../lib'
 require 'memory_record'
 
-class Language
+class Palette
   include MemoryRecord
   memory_record [
-    {key: :lisp, author: "John McCarthy"      },
-    {key: :c,    author: "Dennis Ritchie"     },
-    {key: :ruby, author: "Yukihiro Matsumoto" },
+    { key: :coral,  r: 255, g: 127, b:   0 },
+    { key: :tomato, r: 255, g:  99, b:  71 },
+    { key: :gold,   r: 255, g: 215, b:   0 },
   ]
 
-  def mr_author
-    "Mr. #{author}"
+  def rgb
+    [r, g, b]
+  end
+
+  def hex
+    "#" + rgb.collect { |e| "%02X" % e }.join
   end
-end
 
-Language[:ruby].key        # => :ruby
-Language[:ruby].code       # => 2
-Language[:ruby].author     # => "Yukihiro Matsumoto"
-Language[:ruby].mr_author  # => "Mr. Yukihiro Matsumoto"
+  def name
+    super.capitalize
+  end
+end
 
-Language.keys              # => [:lisp, :c, :ruby]
-Language.collect(&:author) # => ["John McCarthy", "Dennis Ritchie", "Yukihiro Matsumoto"]
+Palette[:tomato].key        # => :tomato
+Palette[:tomato].name       # => "Tomato"
+Palette[:tomato].rgb        # => [255, 99, 71]
+Palette[:tomato].hex        # => "#FF6347"
+Palette.collect(&:hex)      # => ["#FF7F00", "#FF6347", "#FFD700"]

data/examples/0190_super_usable.rb

@@ -14,7 +14,12 @@ class Foo
   def name
     "(#{super})"
   end
+
+  def to_h
+    super.merge(x: 1)
+  end
 end
 
 Foo.first.a                     # => 20
 Foo.first.name                  # => "(_key0)"
+Foo.first.to_h                  # => {:a=>10, :code=>0, :key=>:_key0, :x=>1}

data/examples/0220_bad_design.rb

@@ -13,5 +13,5 @@ class Foo
   ]
 end
 
-Foo["01"] # => #<Foo:0x00007f9e519ba6d0 @attributes={:key=>:"01", :name=>"left", :code=>0}>
-Foo["02"] # => #<Foo:0x00007f9e519ba568 @attributes={:key=>:"02", :name=>"right", :code=>1}>
+Foo["01"] # => #<Foo:0x00007fb30e1ddcd8 @attributes={:key=>:"01", :name=>"left", :code=>0}>
+Foo["02"] # => #<Foo:0x00007fb30e1ddbc0 @attributes={:key=>:"02", :name=>"right", :code=>1}>

data/examples/0240_attr_reader_option.rb

@@ -10,9 +10,9 @@ class C1
   end
 end
 
-C1.first.x rescue $! # => #<NoMethodError: undefined method `x' for #<C1:0x00007f83bc8e7078>>
-C1.first.y rescue $! # => #<NoMethodError: undefined method `y' for #<C1:0x00007f83bc8e7078>>
-C1.first.z rescue $! # => #<NoMethodError: undefined method `z' for #<C1:0x00007f83bc8e7078>>
+C1.first.x rescue $! # => #<NoMethodError: undefined method `x' for #<C1:0x00007fb4d51afd60>>
+C1.first.y rescue $! # => #<NoMethodError: undefined method `y' for #<C1:0x00007fb4d51afd60>>
+C1.first.z rescue $! # => #<NoMethodError: undefined method `z' for #<C1:0x00007fb4d51afd60>>
 
 class C2
   include MemoryRecord
@@ -23,9 +23,9 @@ class C2
   end
 end
 
-C2.first.x rescue $! # => #<NoMethodError: undefined method `x' for #<C2:0x00007f83bc9419d8>>
+C2.first.x rescue $! # => #<NoMethodError: undefined method `x' for #<C2:0x00007fb4d50dfb60>>
 C2.first.y rescue $! # => 1
-C2.first.z rescue $! # => #<NoMethodError: undefined method `z' for #<C2:0x00007f83bc9419d8>>
+C2.first.z rescue $! # => #<NoMethodError: undefined method `z' for #<C2:0x00007fb4d50dfb60>>
 
 class C3
   include MemoryRecord
@@ -37,5 +37,5 @@ class C3
 end
 
 C3.first.x rescue $! # => 1
-C3.first.y rescue $! # => #<NoMethodError: undefined method `y' for #<C3:0x00007f83bc948968>>
+C3.first.y rescue $! # => #<NoMethodError: undefined method `y' for #<C3:0x00007fb4d50d4440>>
 C3.first.z rescue $! # => 1

data/examples/0250_lookup_super_call.rb

@@ -15,5 +15,5 @@ class C
   end
 end
 
-C.lookup(:alice)                # => #<C:0x00007ffe599ba4d8 @attributes={:key=>:alice, :code=>0}>
-C[:alice]                       # => #<C:0x00007ffe599ba4d8 @attributes={:key=>:alice, :code=>0}>
+C.lookup(:alice)                # => #<C:0x00007fa9dc11d8b0 @attributes={:key=>:alice, :code=>0}>
+C[:alice]                       # => #<C:0x00007fa9dc11d8b0 @attributes={:key=>:alice, :code=>0}>

data/examples/0270_instance_freeze.rb

@@ -17,6 +17,6 @@ class Foo
   end
 end
 
-v = Foo.first # => #<Foo:0x00007fdc05a532d0 @attributes={:key=>:a, :code=>0}, @var=1>
+v = Foo.first # => #<Foo:0x00007f9da02595a0 @attributes={:key=>:a, :code=>0}, @var=1>
 v.frozen?     # => true
 v.a           # => 1

data/lib/memory_record/memory_record.rb

@@ -62,38 +62,32 @@ module MemoryRecord
       end
 
       # Define it to an ancestor so that super method can be used.
-      include Module.new.tap { |m|
+      include Module.new {
         ([:key, :code] + attr_reader_args).uniq.each do |key|
-          m.module_eval do
-            define_method(key) { @attributes[key.to_sym] }
-          end
+          define_method(key) { @attributes[key.to_sym] }
         end
 
-        unless m.method_defined?(:name)
-          m.module_eval do
-            define_method(:name) { key.to_s }
-          end
+        unless method_defined?(:name)
+          define_method(:name) { key.to_s }
         end
 
-        m.module_eval do
-          # sort matches definition order
-          def <=>(other)
-            [self.class, code] <=> [other.class, other.code]
-          end
+        # 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 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
+        # 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
-            self.class.hash ^ key.hash
-          end
+        def hash
+          self.class.hash ^ key.hash
         end
       }
 
@@ -205,7 +199,7 @@ module MemoryRecord
 
     attr_reader :attributes
 
-    delegate :[], to: :attributes
+    delegate :[], :to_h, to: :attributes
     delegate :to_s, to: :name
 
     def initialize(attributes)

data/lib/memory_record/version.rb

@@ -1,3 +1,3 @@
 module MemoryRecord
-  VERSION = '0.0.11'
+  VERSION = '0.0.12'
 end

data/spec/memory_record_spec.rb

@@ -71,6 +71,7 @@ RSpec.describe MemoryRecord do
 
   context 'instance accessor' do
     it do
+      assert Model.first.to_h
       assert Model.first.attributes
       assert Model.first.key
       assert Model.first.code

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: memory_record
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.0.12
 platform: ruby
 authors:
 - akicho8
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-14 00:00:00.000000000 Z
+date: 2018-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake