neohash 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7ebf4d1873a29aacc1400bff53f99a4347a48b430df16368d5b0a3661caca84d
+  data.tar.gz: 428a6969244858c844789f2842bd42a9353a264aabe927a92589176b5ea8b425
+SHA512:
+  metadata.gz: 8703d7ff38bd455f3e4e6bb056caf7499430c10adf2f697b499ea3201d06bcb2222d87c0bb5ef03bd8ff1f9c86020d2bfd1c23e687132332253d1a3dbcdd3e0f
+  data.tar.gz: 533f3261479ab0e001f7831b52931eda5b5920568961be08bfff4cd9d58d63d9a93615290ee0a544bb1606539d3ea21009a6af5a3c874b3a7030ee36fd3d3544

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/rdoc/
+/pkg/
+/spec/reports/
+/tmp/
+/Gemfile.lock
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in neohash.gemspec
+gemspec
+
+group :test do
+  gem 'simplecov', require: false
+end

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Toshimitsu Takahashi
+
+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.md

@@ -0,0 +1,46 @@
+# NeoHash
+
+[![Gem Version](https://badge.fury.io/rb/neohash.svg)](https://badge.fury.io/rb/neohash)
+[![Build Status](https://travis-ci.org/tilfin/neohash.svg?branch=master)](https://travis-ci.org/tilfin/neohash)
+[![Code Climate](https://codeclimate.com/github/tilfin/neohash/badges/gpa.svg)](https://codeclimate.com/github/tilfin/neohash)
+[![Test Coverage](https://codeclimate.com/github/tilfin/neohash/badges/coverage.svg)](https://codeclimate.com/github/tilfin/neohash/coverage)
+
+Accessible Hash and attaching it to an Object
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'neohash'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install neohash
+
+## Usage
+
+```ruby
+class DynamicObject
+  include NeoHash::Support
+  
+  def initialize(hash)
+    set_inner_hash(hash)
+  end
+end
+
+obj = DynamicObject.new({ port: 80, "host" => "localhost" })
+p obj.port   # 80
+p obj[:host] # "localhost"
+obj[:host] = "192.168.1.1"
+p obj.host   # "192.168.1.1"
+```
+
+## License
+
+  [MIT](LICENSE)

data/Rakefile

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

data/lib/neo_hash/neo_hash.rb

@@ -0,0 +1,8 @@
+# Hash with attribute accessor
+class NeoHash
+  # Constructor
+  # @param [Hash] h ({}) initial hash
+  def initialize(h = {})
+    set_inner_hash(h)
+  end
+end

data/lib/neo_hash/support.rb

@@ -0,0 +1,120 @@
+class NeoHash
+  # Provides attribute readers and Hash features
+  # A class that includes this has `@h` as inner hash.
+  # @example
+  #   class DynamicObject
+  #     include NeoHash::Support
+  #     
+  #     def initialize(hash)
+  #       set_inner_hash(hash)
+  #     end
+  #   end
+  # 
+  #   obj = DynamicObject.new({ port: 80, "host" => "localhost" })
+  #   p obj.port   # 80
+  #   p obj[:host] # "localhost"
+  #   obj[:host] = "192.168.1.1"
+  #   p obj.host   # "192.168.1.1"
+  module Support
+    # @see Hash#[]
+    def [](key)
+      @h[key.to_sym]
+    end
+
+    # @see Hash#[]=
+    def []=(key, value)
+      sk = key.to_sym
+      define_attr_accessor(sk) unless @h.key?(sk)
+      @h[sk] = convert_val(value)
+    end
+
+    # @see Hash#include?
+    def include?(key)
+      @h.include?(key.to_sym)
+    end
+
+    alias_method :has_key?, :include?
+    alias_method :key?, :include?
+    alias_method :member?, :include?
+
+    # @see Hash#delete
+    def delete(key, &block)
+      @h.delete(key.to_sym, &block)
+    end
+
+    # @see Hash#fetch
+    def fetch(*args, &block)
+      args[0] = args[0].to_sym
+      @h.fetch(*args, &block)
+    end
+
+    def method_missing(method, *args, &block)
+      if Hash.public_method_defined?(method)
+        @h.send method, *args, &block
+      else
+        super
+      end
+    end
+
+    # Convert to original Hash
+    #
+    # @return [Hash] hash
+    # @param [Hash] opts the options to intialize
+    # @option opts [String] :symbolize_keys (true) whether symbolize names or not
+    def to_h(opts = {})
+      symbolize = opts.fetch(:symbolize_keys, true)
+
+      @h.map {|key, val|
+        [symbolize ? key : key.to_s, to_primitive(val, opts)]
+      }.to_h
+    end
+
+    # Implicitly convert to Hash
+    # @return [Hash] generated hash
+    def to_hash
+      to_h
+    end
+
+    protected
+
+    # Set inner hash and replace hashes in descendant with wrapping them recursively
+    def set_inner_hash(hash)
+      @h = coerce_hash(hash)
+      define_attr_accessors
+    end
+
+    private
+
+    def define_attr_accessors
+      @h.each_key {|name| define_attr_accessor(name) }
+    end
+
+    def define_attr_accessor(name)
+      define_singleton_method name, lambda { @h[name] }
+      define_singleton_method "#{name}=", lambda {|val| @h[name] = convert_val(val) }
+    end
+
+    def coerce_hash(hash)
+      {}.tap do |new_h|
+        hash.each do |name, val|
+          new_h[name.to_sym] = convert_val(val)
+        end
+      end
+    end
+
+    def convert_val(val)
+      return NeoHash.new(val) if val.is_a?(Hash)
+      return val.map {|item| convert_val(item) } if val.instance_of?(Array)
+      val
+    end
+
+    def to_primitive(val, opts)
+      return val.to_h(opts) if val.instance_of?(NeoHash)
+      return val.to_hash if val.respond_to?(:to_hash)
+      return val.map {|item| to_primitive(item, opts) } if val.instance_of?(Array)
+      val
+    end
+  end
+
+  include Support
+end

data/lib/neo_hash/version.rb

@@ -0,0 +1,3 @@
+class NeoHash
+  VERSION = '0.3.0'
+end

data/lib/neohash.rb

@@ -0,0 +1,3 @@
+require 'neo_hash/version'
+require 'neo_hash/neo_hash'
+require 'neo_hash/support'

data/spec/neo_hash_spec.rb

@@ -0,0 +1,168 @@
+require 'spec_helper'
+
+describe NeoHash do
+  subject { described_class.new(h) }
+
+  let!(:h) do
+    {
+      'port' => 80,
+      'log' => { 'level' => 'warn' },
+      'array' => [123, {
+        'data' => 'data'
+      }, {
+        'value' => 100
+      }]
+    }
+  end
+
+  let!(:h_symbol) do
+    {
+      port: 80,
+      log: { level: 'warn' },
+      array: [123, {
+        data: 'data'
+      }, {
+        value: 100
+      }]
+    }
+  end
+
+  describe '#initialize' do
+    it 'an instance that has accessors by method' do
+      expect(subject.port).to eq(80)
+      expect(subject.log.level).to eq('warn')
+      expect(subject.array[0]).to eq(123)
+      expect(subject.array[1].data).to eq('data')
+      expect(subject.array[2].value).to eq(100)
+    end
+
+    it 'an instance that has accessors by symbol' do
+      expect(subject[:port]).to eq(80)
+      expect(subject[:log][:level]).to eq('warn')
+      expect(subject[:array][0]).to eq(123)
+      expect(subject[:array][1].data).to eq('data')
+      expect(subject[:array][2].value).to eq(100)
+    end
+
+    it 'an instance that has accessors by string' do
+      expect(subject['port']).to eq(80)
+      expect(subject['log']['level']).to eq('warn')
+      expect(subject['array'][0]).to eq(123)
+      expect(subject['array'][1].data).to eq('data')
+      expect(subject['array'][2].value).to eq(100)
+    end
+
+    it 'an instance that has accessors by various ways' do
+      expect(subject.log[:level]).to eq('warn')
+      expect(subject.log['level']).to eq('warn')
+      expect(subject[:log].level).to eq('warn')
+      expect(subject[:log]['level']).to eq('warn')
+      expect(subject['log'].level).to eq('warn')
+      expect(subject['log'][:level]).to eq('warn')
+    end
+  end
+
+  describe '#to_h' do
+    it 'creates an hash with name as symbol' do
+      expect(subject.to_h).to eq(h_symbol)
+    end
+
+    it 'creates an hash with name as symbol' do
+      expect(subject.to_h(symbolize_keys: true)).to eq(h_symbol)
+    end
+
+    it 'creates an hash with name as string' do
+      expect(subject.to_h(symbolize_keys: false)).to eq(h)
+    end
+  end
+
+  describe '#to_hash' do
+    it 'creates an hash with name as symbol' do
+      expect(subject.to_hash).to eq(h_symbol)
+    end
+  end
+
+  describe 'dynamically change settings' do
+    it 'can add new settings' do
+      subject.log['file'] = '/var/log/app.log'
+      subject[:backend] = { host: 'cms.example.com', "port" => 7080 }
+
+      expect(subject.log.level).to eq('warn')
+      expect(subject.log.file).to eq('/var/log/app.log')
+      expect(subject.backend.host).to eq('cms.example.com')
+      expect(subject.backend.port).to eq(7080)
+    end
+
+    it 'can update values' do
+      subject['port'] = 8888
+      expect(subject.port).to eq(8888)
+
+      subject.port = 789
+      expect(subject.port).to eq(789)
+
+      subject.log.level = :trace
+      expect(subject.log.level).to eq(:trace)
+
+      subject.log = { file: '/var/log/app2.log' }
+      expect{ subject.log.level }.to raise_error(NoMethodError)
+      expect(subject.log.file).to eq('/var/log/app2.log')
+    end
+  end
+
+  describe '#include?' do
+    it 'call inner hash#include?' do
+      expect(subject.include?(:port)).to be_truthy
+      expect(subject.include?('port')).to be_truthy
+    end
+  end
+
+  describe '#fetch' do
+    it 'call inner hash#fetch' do
+      expect(subject.fetch(:port)).to eq(80)
+      expect(subject.fetch('port')).to eq(80)
+      expect{ subject.fetch(:none) }.to raise_error(KeyError)
+      expect(subject.fetch(:none, 'none')).to eq('none')
+      expect(subject.fetch(:none) {|k| k }).to eq(:none)
+    end
+  end
+
+  describe '#delete' do
+    it 'call inner hash#delete' do
+      expect(subject.delete(:none)).to be_nil
+      expect(subject.delete('port')).to eq(80)
+      expect(subject.delete(:log)).not_to be_nil
+    end
+  end
+
+  describe '#method_missing' do
+    it 'can call inner hash#each' do
+      subject.each do |k, v|
+        expect(k).to eq :port
+        expect(v).to eq 80
+        break
+      end
+    end
+
+    it 'can call inner hash#empty?' do
+      expect(subject.empty?).to be_falsey
+    end
+
+    it 'can call inner hash#keys' do
+      expect(subject.keys).to eq([:port, :log, :array])
+    end
+
+    it 'can call inner hash#map' do
+      expect(subject.map {|k, v| k }).to eq [:port, :log, :array]
+    end
+
+    it 'can call inner hash#select' do
+      h = subject.select {|k, v| k == :port }
+      expect(h[:port]).to eq(80)
+    end
+
+    it 'can call inner hash#store' do
+      subject.store(:port, 999)
+      expect(subject.port).to eq(999)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter "/spec/"
+end
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'neohash'

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: neohash
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Toshimitsu Takahashi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Accessible Hash and attaching it to an Object
+email:
+- toshi@tilfin.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- lib/neo_hash/neo_hash.rb
+- lib/neo_hash/support.rb
+- lib/neo_hash/version.rb
+- lib/neohash.rb
+- spec/neo_hash_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/tilfin/neohash
+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.7.3
+signing_key: 
+specification_version: 4
+summary: Accessible Hash and attaching it to an Object
+test_files:
+- spec/neo_hash_spec.rb
+- spec/spec_helper.rb