memory_record 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0a0d02478e038db4812bab5276b78fea07776ab4
+  data.tar.gz: 98d8b5e8afc8d4953dc71e240112ea96deb13bcc
+SHA512:
+  metadata.gz: 57018d07d34f7087d497ed1e31df045590b3ba664607a2990c65ac5aa1cf0e6f3af45c72790a0dc576da73dc1412b66f6ed9de2773e0c0de41485b3371f6a4a5
+  data.tar.gz: 37dc4b8c4ff4a17d5a70e1681993b42d65186a7b3cfdd4b04b1de74dd3e8fd31a26013a275a4226422130ae3a857b22a3c9246cd57f55de6ea9b4ac1c22092d3

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+/*.html

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.3

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 akicho8
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.org

@@ -0,0 +1,123 @@
+* A small number of records Easy handling library
+
+#+BEGIN_SRC ruby
+class Direction
+  include MemoryRecord
+  memory_record [
+    {key: :left,  name: "←", vector: [-1,  0]},
+    {key: :right, name: "→", vector: [ 1,  0]},
+  ], attr_reader_auto: true
+
+  def long_name
+    "#{key}:#{name}"
+  end
+end
+
+Direction.collect(&:name)       # => ["←", "→"]
+Direction.keys                  # => [:left, :right]
+
+Direction[:right].key           # => :right
+Direction[:right].code          # => 1
+Direction[:right].vector        # => [1, 0]
+Direction[:right].long_name     # => "right:→"
+
+Direction[1].key                # => :right
+
+Direction[:up]                  # => nil
+Direction.fetch(:up) rescue $!  # => #<KeyError: Direction.fetch(:up) does not match anything。
+#+END_SRC
+
+*** How to decide =code= yourself?
+
+#+BEGIN_SRC 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"},
+  ], attr_reader: :name
+end
+
+Foo.collect(&:code) # => [1, 2, 3]
+#+END_SRC
+
+    It is used only when refactoring legacy code, when compatibility is required.
+
+*** How to turn as an array?
+
+    =Enumerable= extended, so that =each= method is available
+
+#+BEGIN_SRC ruby
+Foo.each {|v| ... }
+Foo.collect {|v| ... }
+#+END_SRC
+
+*** How do I submit a form to select in Rails?
+
+#+BEGIN_SRC ruby
+form.collection_select(:selection_code, Foo, :code, :name)
+#+END_SRC
+
+*** 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).
+
+#+BEGIN_SRC ruby
+Foo[1].name  # => "A"
+Foo[:a].name # => "A"
+#+END_SRC
+
+*** Instances always react to =code= and =key=
+
+#+BEGIN_SRC ruby
+object = Foo.first
+object.key  # => :a
+object.code # => 1
+#+END_SRC
+
+*** =attr_reader= option
+
+    The attribute value can be referenced with =@attributes[:xxx]=, but it is troublesome to refer frequently, so it is methodized with =attr_reader: xxx=.
+
+*** =attr_reader_auto= option
+
+    Automatically all attributes =attr_reader=
+
+*** What if I do not want you to feel free to access the attributes of a record?
+
+    =attr_reader= with no method definition and reference =object.attributes[:xxx]=
+
+*** How do I add a method to an instance?
+
+    For that, I am creating a new class so I need to define it normally
+
+*** =name= method is special?
+
+    If =name= is not defined, it defines a =name= method that returns a translation of =key=
+
+*** =to_s= method is defined?
+
+    = Alias of =name=, =to_s= is defined.
+
+*** If there is no key, use fetch to get an error
+
+#+BEGIN_SRC ruby
+Foo.fetch(:xxx)              # => <KeyError: ...>
+#+END_SRC
+
+    The following are all the same
+
+#+BEGIN_SRC 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
+
+#+BEGIN_SRC ruby
+Foo.fetch_if(nil)            # => nil
+Foo.fetch_if(:a)             # => #<Foo:... @attributes={...}>
+Foo.fetch_if(:xxx)           # => <KeyError: ...>
+#+END_SRC

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/examples/0110_basic.rb

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift '../lib'
+require 'memory_record'
+
+class Foo
+  include MemoryRecord
+  memory_record [
+    {key: :male,   name: 'otoko'},
+    {key: :female, name: 'onna'},
+  ], attr_reader: :name
+end
+
+Foo[:male]   # => #<Foo:0x007ff459a494a8 @attributes={:key=>:male, :name=>"otoko", :code=>0}>
+Foo[:female] # => #<Foo:0x007ff459a49390 @attributes={:key=>:female, :name=>"onna", :code=>1}>
+
+Foo[:male].name                 # => "otoko"
+Foo[:female].name               # => "onna"

data/examples/0120_attr_reader_auto_option.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift '../lib'
+require 'memory_record'
+
+model = Class.new do
+  include MemoryRecord
+  memory_record [
+    {a: 1},
+    {b: 2},
+  ], attr_reader_auto: true
+end
+
+model.first.name                # => nil
+model.first.a                   # => 1
+model.first.b                   # => nil

data/examples/0130_for_legacy_code.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift '../lib'
+require 'memory_record'
+
+class Foo
+  include MemoryRecord
+  memory_record [
+    {code: 1, key: :a, name: 'A'},
+    {code: 2, key: :b, name: 'B'},
+    {code: 3, key: :c, name: 'C'},
+  ], :attr_reader => :name
+end
+
+Foo[2].name                     # => 'B'
+Foo[:b].name                    # => 'B'

data/examples/0140_key_join_underscore_if_array.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift '../lib'
+require 'memory_record'
+
+class C
+  include MemoryRecord
+  memory_record [
+    {key: [:a, :b]},
+  ]
+end
+
+C.keys                          # => [:a_b]

data/examples/0150_behavior_like_hash.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift '../lib'
+require 'memory_record'
+
+class C
+  include MemoryRecord
+  memory_record [
+    {key: :a, x: 1},
+  ]
+end
+
+C[:a][:x] # => 1

data/examples/0160_practice.rb

@@ -0,0 +1,27 @@
+$LOAD_PATH.unshift '../lib'
+require 'memory_record'
+
+class Direction
+  include MemoryRecord
+  memory_record [
+    {key: :left,  name: '←', vector: [-1,  0]},
+    {key: :right, name: '→', vector: [ 1,  0]},
+  ], attr_reader_auto: true
+
+  def long_name
+    '#{name}方向'
+  end
+end
+
+Direction.collect(&:name)       # => ['←', '→']
+Direction.keys                  # => [:left, :right]
+
+Direction[:right].key           # => :right
+Direction[:right].code          # => 1
+Direction[:right].vector        # => [1, 0]
+Direction[:right].long_name     # => '→方向'
+
+Direction[1].key                # => :right
+
+Direction[:up]                  # => nil
+Direction.fetch(:up) rescue $!  # => #<KeyError: Direction.fetch(:up) does not match anything

data/examples/0170_reset.rb

@@ -0,0 +1,21 @@
+$LOAD_PATH.unshift '../lib'
+require 'memory_record'
+
+class C
+  include MemoryRecord
+  memory_record [{key: :a}], attr_reader: :name
+end
+
+C.keys                          # => [:a]
+
+# memory_record では更新できない
+class C
+  memory_record [{key: :b}], attr_reader: :name
+end
+
+C.keys                          # => [:a]
+
+# memory_record_list_set を使うこと
+C.memory_record_list_set [{key: :c}]
+
+C.keys                          # => [:c]

data/examples/0180_key_is_anything_ok.rb

@@ -0,0 +1,11 @@
+$LOAD_PATH.unshift '../lib'
+require 'memory_record'
+
+class Foo
+  include MemoryRecord
+  memory_record [
+    {key: '↑', name: '上'},
+  ], attr_reader: :name
+end
+
+Foo['↑'].name                  # => '上'

data/examples/0190_tips_on_handling_boolean_type.rb

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift '../lib'
+require 'memory_record'
+
+class Foo
+  include MemoryRecord
+  memory_record [
+    {key: 'true',  name: '有効'},
+    {key: 'false', name: '無効'},
+  ], attr_reader: :name
+end
+
+flag = true
+
+Foo[flag.to_s].name             # => '有効'

data/examples/0200_freeze_makes_it_impossible_to_memorize.rb

@@ -0,0 +1,24 @@
+# freeze してしまうとこれらのメモ化ができなくなる
+
+$LOAD_PATH.unshift '../lib'
+require 'memory_record'
+
+class C
+  def self.x
+    @x ||= 'OK'
+  end
+end
+
+class C2
+  include MemoryRecord
+  memory_record [
+    {model: C},
+  ], attr_reader_auto: true
+
+  def x
+    @x ||= 'OK'
+  end
+end
+
+C2.first.x                      # => "OK"
+C2.first.model.x                # => "OK"

data/examples/0210_super_usable.rb

@@ -0,0 +1,20 @@
+$LOAD_PATH.unshift '../lib'
+require 'memory_record'
+
+class Foo
+  include MemoryRecord
+  memory_record [
+    {a: 10},
+  ], attr_reader: :a
+
+  def a
+    super * 2
+  end
+
+  def name
+    "(#{super})"
+  end
+end
+
+Foo.first.a                     # => 20
+Foo.first.name                  # => "(Key0)"

data/examples/0230_validation.rb

@@ -0,0 +1,23 @@
+$LOAD_PATH.unshift '../lib'
+require 'memory_record'
+
+class Foo
+  include MemoryRecord
+  memory_record [
+    {name: 'alice'},
+    {name: 'bob'},
+  ], attr_reader_auto: true
+end
+
+require 'active_model'
+
+class Foo
+  include ActiveModel::Validations
+  validates :name, length: { maximum: 3 }
+end
+
+Foo.collect(&:valid?)           # => [false, true]
+
+foo = Foo.first
+foo.valid?                     # => false
+foo.errors.full_messages       # => ['Name is too long (maximum is 3 characters)']

data/examples/0240_key_duplicate.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift '../lib'
+require 'memory_record'
+
+class Foo
+  include MemoryRecord
+  memory_record [{key: :a}, {key: :a},] rescue $! # => #<ArgumentError: Foo#key の :a が重複しています
+end
+
+class Bar
+  include MemoryRecord
+  memory_record [{code: 0}, {code: 0},] rescue $! # => #<ArgumentError: Bar#code の 0 が重複しています
+end

data/examples/0250_when_key_like_numeric.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH.unshift '../lib'
+require 'memory_record'
+
+class Foo
+  include MemoryRecord
+  memory_record [
+    {key: '01', name: '→'},
+    {key: '02', name: '←'},
+  ], attr_reader: :name
+end
+
+Foo['01'] # => #<Foo:0x007fac2c35db28 @attributes={:key=>:'01', :name=>'→', :code=>0}>
+Foo['02'] # => #<Foo:0x007fac2c35d9e8 @attributes={:key=>:'02', :name=>'←', :code=>1}>
+
+# このようにもできるがまったくオススメできない
+# マジックナンバーを増やすメリットはない
+# なんのためにキーがあるのか考えよう

data/examples/0260_with_use_activerecord_enum.rb

@@ -0,0 +1,33 @@
+$LOAD_PATH.unshift '../lib'
+require 'memory_record'
+
+require 'active_record'
+
+ActiveRecord::VERSION::STRING   # => "5.1.3"
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Base.establish_connection(adapter: 'sqlite3', database: ':memory:')
+
+ActiveRecord::Schema.define do
+  create_table :users do |t|
+    t.integer :gender_key
+  end
+end
+
+class GenderInfo
+  include MemoryRecord
+  memory_record [
+    {key: :male,   name: 'otoko'},
+    {key: :female, name: 'onna'},
+  ], attr_reader: :name
+end
+
+class User < ActiveRecord::Base
+  enum gender_key: GenderInfo.keys
+
+  def gender_info
+    GenderInfo[gender_key]
+  end
+end
+
+user = User.create!(gender_key: :male)
+user.gender_info.name           # => "otoko"

data/lib/memory_record/memory_record.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+require 'active_support/concern'
+require 'active_support/core_ext/module/concerning'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/array/wrap'
+require 'active_model'
+
+module MemoryRecord
+  extend ActiveSupport::Concern
+
+  class_methods do
+    def memory_record(list, **options, &block)
+      return if memory_record_defined?
+
+      extend ActiveModel::Translation
+      extend Enumerable
+      include ::MemoryRecord::SingletonMethods
+
+      class_attribute :memory_record_configuration
+      self.memory_record_configuration = {
+        attr_reader: [],
+      }.merge(options)
+
+      if block_given?
+        yield memory_record_configuration
+      end
+
+      if memory_record_configuration[:attr_reader_auto]
+        _attr_reader = list.inject([]) { |a, e| a | e.keys.collect(&:to_sym) }
+      else
+        _attr_reader = memory_record_configuration[:attr_reader]
+      end
+
+      include Module.new.tap { |m|
+        ([:key, :code] + Array.wrap(_attr_reader)).uniq.each do |key|
+          m.class_eval do
+            define_method(key) { @attributes[key.to_sym] }
+          end
+        end
+
+        unless m.method_defined?(:name)
+          m.class_eval do
+            define_method(:name) do
+              if self.class.name
+                self.class.human_attribute_name(key)
+              end
+            end
+          end
+        end
+      }
+
+      memory_record_list_set(list)
+    end
+
+    def memory_record_defined?
+      ancestors.include?(SingletonMethods)
+    end
+  end
+
+  concern :SingletonMethods do
+    class_methods do
+      def memory_record?
+        memory_record_defined?
+      end
+
+      def lookup(key)
+        return key if key.kind_of? self
+        case key
+        when Symbol, String
+          @values_hash[:key][key.to_sym]
+        else
+          @values_hash[:code][key]
+        end
+      end
+      alias [] lookup
+
+      def fetch(key, default = nil, &block)
+        raise ArgumentError if block_given? && default
+        v = lookup(key)
+        unless v
+          case
+          when block_given?
+            v = yield
+          when default
+            v = default
+          else
+            raise KeyError, [
+              "#{name}.fetch(#{key.inspect}) does not match anything",
+              "keys: #{keys.inspect}",
+              "codes: #{codes.inspect}",
+            ].join("\n")
+          end
+        end
+        v
+      end
+
+      def fetch_if(key, default = nil, &block)
+        if key
+          fetch(key, default, &block)
+        end
+      end
+
+      delegate :each, to: :values
+
+      def keys
+        @keys ||= @values_hash[:key].keys
+      end
+
+      def codes
+        @codes ||= @values_hash[:code].keys
+      end
+
+      attr_reader :values
+
+      def memory_record_list_set(list)
+        @keys = nil
+        @codes = nil
+        @values = list.collect.with_index {|e, i| new(_attributes_normalize(e, i)) }.freeze
+        @values_hash = {}
+        [:code, :key].each do |pk|
+          @values_hash[pk] = @values.inject({}) do |a, e|
+            a.merge(e.send(pk) => e) do |key, a, b|
+              raise ArgumentError, [
+                "#{name}##{pk} #{key.inspect} is duplicate",
+                "Existing:  #{a.attributes.inspect}",
+                "Collision: #{b.attributes.inspect}",
+              ].join("\n")
+            end
+          end
+        end
+      end
+
+      private
+
+      def _attributes_normalize(attrs, index)
+        key = attrs[:key] || "_key#{index}"
+        if key.kind_of? Array
+          key = key.join('_')
+        end
+        attrs.merge(code: attrs[:code] || index, key: key.to_sym)
+      end
+    end
+
+    attr_reader :attributes
+
+    delegate :[], to: :attributes
+    delegate :to_s, to: :name
+
+    def initialize(attributes)
+      @attributes = attributes
+    end
+  end
+end

data/lib/memory_record/version.rb

@@ -0,0 +1,3 @@
+module MemoryRecord
+  VERSION = '0.0.1'
+end

data/lib/memory_record.rb

@@ -0,0 +1,2 @@
+require 'memory_record/version'
+require 'memory_record/memory_record'

data/memory_record.gemspec

@@ -0,0 +1,26 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'memory_record/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'memory_record'
+  spec.version       = MemoryRecord::VERSION
+  spec.authors       = ['akicho8']
+  spec.email         = ['akicho8@gmail.com']
+  spec.description   = %q{A small number of records Easy handling library}
+  spec.summary       = %q{A small number of records Easy handling library}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'test-unit'
+
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'activemodel'
+end

data/spec/memory_record_spec.rb

@@ -0,0 +1,164 @@
+require 'spec_helper'
+
+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 __define(table)
+    Class.new {
+      include MemoryRecord
+      memory_record table, attr_reader_auto: true
+    }
+  end
+
+  let(:instance) { Model.first }
+
+  context 'Useful Class Methods' do
+    it 'each' do
+      assert Model.each
+    end
+
+    it 'keys' do
+      assert_equal [:_key0, :_key1], Model.keys
+    end
+
+    it 'values' do
+      assert_equal 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
+    end
+
+    it 'It will not cause an error even if there is no corresponding key' do
+      assert_nothing_raised { Model[:unknown] }
+    end
+
+    it 'In the case of fetch, if there is no corresponding key, an error occurs' do
+      assert_raises { Model.fetch(:unknown) }
+    end
+
+    it 'fetch_if' do
+      assert_nothing_raised { Model.fetch_if(nil) }
+    end
+  end
+
+  context 'Subscript access to instance' do
+    it do
+      instance[:name].should == 'A'
+      instance[:xxxx].should == nil
+    end
+  end
+
+  context 'to_s' do
+    it do
+      instance.to_s.should == 'A'
+    end
+  end
+
+  context 'instance accessor' do
+    it do
+      assert instance.attributes
+      assert instance.key
+      assert instance.code
+    end
+  end
+
+  context 'Re-set' do
+    before do
+      @model = __define [{key: :a}]
+      @model.memory_record_list_set [{key: :b}, {key: :c}]
+    end
+    it 'changed' do
+      assert_equal [:b, :c], @model.keys
+      assert_equal [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 = __define [{key: [:id, :desc]}]
+      assert_equal [:id_desc], model.keys
+    end
+
+    it 'Name method is automatically defined if it is not defined' do
+      model = __define []
+      assert_equal true, model.instance_methods.include?(:name)
+    end
+  end
+
+  it 'Japanese can be used for key' do
+    model = __define [{key: 'あ'}]
+    assert model['あ']
+  end
+
+  it 'When you define code and keys yourself' do
+    assert_equal 'A', Legacy[10].name
+  end
+
+  it 'We do not freeze values because memoization becomes impossible' do
+    Model.first.name.upcase!
+  end
+
+  describe 'super' do
+    class Model2
+      include MemoryRecord
+      memory_record [
+        {var: 'x'},
+      ], attr_reader: :var
+
+      def var
+        super + 'y'
+      end
+    end
+
+    it 'Since methods are defined in ancestry, you can use super' do
+      assert_equal 'xy', Model2.first.var
+    end
+  end
+
+  describe 'attr_reader_auto' do
+    class Model3
+      include MemoryRecord
+      memory_record [
+        {a: 1},
+        {b: 2},
+      ], attr_reader_auto: true
+    end
+
+    it do
+      assert_equal 1, Model3.first.a
+      assert_equal nil, Model3.first.b
+    end
+  end
+
+  describe 'Do not duplicate key and code' do
+    it do
+      expect { Model.memory_record_list_set([{key: :a}, {key: :a}]) }.to raise_error(ArgumentError)
+      expect { Model.memory_record_list_set([{code: 0}, {code: 0}]) }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe 'Human_attribute_name can not be used in anonymous class' do
+    let(:model) { __define [{foo: 1}] }
+
+    it 'It does not cause an error' do
+      model.first.name.should == nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$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

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: memory_record
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- akicho8
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A small number of records Easy handling library
+email:
+- akicho8@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.org
+- Rakefile
+- examples/0110_basic.rb
+- examples/0120_attr_reader_auto_option.rb
+- examples/0130_for_legacy_code.rb
+- examples/0140_key_join_underscore_if_array.rb
+- examples/0150_behavior_like_hash.rb
+- examples/0160_practice.rb
+- examples/0170_reset.rb
+- examples/0180_key_is_anything_ok.rb
+- examples/0190_tips_on_handling_boolean_type.rb
+- examples/0200_freeze_makes_it_impossible_to_memorize.rb
+- examples/0210_super_usable.rb
+- examples/0230_validation.rb
+- examples/0240_key_duplicate.rb
+- examples/0250_when_key_like_numeric.rb
+- examples/0260_with_use_activerecord_enum.rb
+- lib/memory_record.rb
+- lib/memory_record/memory_record.rb
+- lib/memory_record/version.rb
+- memory_record.gemspec
+- spec/memory_record_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: A small number of records Easy handling library
+test_files:
+- spec/memory_record_spec.rb
+- spec/spec_helper.rb