simple-hash 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 86c14cd18a17ad8363b701cbdeb19b67fa397a89261ace9efbfb259191ade56f
+  data.tar.gz: 88cae9a242fe2688fd637df91a6f90e455cb5c12d5106e72c9529530ca38c0d0
+SHA512:
+  metadata.gz: 35fcc9911bdbe6fd66d454488ff2e0cec18e4df5f0cb891a851223178ab7692722ab87d9a64134b261c4761320a62da5ad037846725738d3e76d4cd1b8b7e1a1
+  data.tar.gz: 7786b3ced8331dae799a3713ae790a1e313b90369621383ae09f97ef5df9792d59fa37b9b1cf980d65a334fcb186d54ac5b908e7d5135f1d31253c11380dbb85

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+pkg/

data/Gemfile

@@ -0,0 +1,2 @@
+source "https://rubygems.org"
+gemspec

data/LICENSE

@@ -0,0 +1,2 @@
+this work is licensed under the terms of the MIT license,
+see https://opensource.org/licenses/MIT

data/README.md

@@ -0,0 +1,33 @@
+# Simple::Hash
+
+typically make JSON into object with accessors
+
+## installation
+
+    $ gem install simple-hash
+
+**or**
+
+```ruby
+gem 'simple-hash'
+```
+
+    $ bundle
+
+## usage
+
+```ruby
+user = SimpleHash.new(name: "localhostdotdev", writing?: true)
+user.name # => "localhostdotdev"
+user.writing? # => true
+user[:name] # => "localhostdotdev"
+user["name"] # => "localhostdotdev"
+user.namme # => NoMethodError, did you mean? name
+user.try(:nammmes) # => nil
+user.keys # => [:name, :writing?]
+user.values # => ["localhostdotdev", true]
+
+# what about that?
+user = SimpleHash[emails: [{ domain: "localhost.dev" }]]
+user.emails.first.domain # "localhost.dev"
+```

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: :test

data/bin/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "simple/hash"
+
+require "irb"
+
+IRB.start(__FILE__)

data/lib/simple/hash.rb

@@ -0,0 +1,36 @@
+require_relative 'hash_with_indifferent_access'
+
+module Simple
+end
+
+class Simple::Hash < Simple::HashWithIndifferentAccess
+  VERSION = "1.0.0"
+
+  def method_missing(method_name, *args, &block)
+    if keys.map(&:to_s).include?(method_name.to_s) && args.empty? && block.nil?
+      fetch(method_name)
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(method_name, include_private = false)
+    keys.map(&:to_s).include?(method_name.to_s) || super
+  end
+
+  def methods
+    super + keys.map(&:to_sym)
+  end
+
+  protected
+
+  def convert_value(value, options = {})
+    if value.is_a?(Hash)
+      Simple::Hash.new(value).freeze
+    elsif value.is_a?(Array)
+      value.map { |val| convert_value(val, options) }
+    else
+      value
+    end
+  end
+end

data/lib/simple/hash_with_indifferent_access.rb

@@ -0,0 +1,237 @@
+require "active_support/core_ext/hash/keys"
+require "active_support/core_ext/hash/reverse_merge"
+require "active_support/core_ext/hash/except"
+
+module Simple
+end
+
+class Simple::HashWithIndifferentAccess < Hash
+  def extractable_options?
+    true
+  end
+
+  def with_indifferent_access
+    dup
+  end
+
+  def nested_under_indifferent_access
+    self
+  end
+
+  def initialize(constructor = {})
+    if constructor.respond_to?(:to_hash)
+      super()
+      update(constructor)
+
+      hash = constructor.to_hash
+      self.default = hash.default if hash.default
+      self.default_proc = hash.default_proc if hash.default_proc
+    else
+      super(constructor)
+    end
+  end
+
+  def self.[](*args)
+    new.merge!(Hash[*args])
+  end
+
+  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+  alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+  def []=(key, value)
+    regular_writer(convert_key(key), convert_value(value, for: :assignment))
+  end
+
+  alias_method :store, :[]=
+
+  def update(other_hash)
+    if other_hash.is_a?(Simple::HashWithIndifferentAccess)
+      super(other_hash)
+    else
+      other_hash.to_hash.each_pair do |key, value|
+        if block_given? && key?(key)
+          value = yield(convert_key(key), self[key], value)
+        end
+        regular_writer(convert_key(key), convert_value(value))
+      end
+      self
+    end
+  end
+
+  alias_method :merge!, :update
+
+  def key?(key)
+    super(convert_key(key))
+  end
+
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  def [](key)
+    convert_value(super(convert_key(key)))
+  end
+
+  def assoc(key)
+    convert_values(super(convert_key(key)))
+  end
+
+  def fetch(key, *extras)
+    convert_value(super(convert_key(key), *extras))
+  end
+
+  def dig(*args)
+    args[0] = convert_key(args[0]) if args.size > 0
+    convert_value(super(*args))
+  end
+
+  def default(*args)
+    super(*args.map { |arg| convert_key(arg) })
+  end
+
+  def values_at(*keys)
+    convert_values(super(*keys.map { |key| convert_key(key) }))
+  end
+
+  def fetch_values(*indices, &block)
+    convert_values(super(*indices.map { |key| convert_key(key) }, &block))
+  end
+
+  def dup
+    self.class.new(self).tap do |new_hash|
+      set_defaults(new_hash)
+    end
+  end
+
+  def merge(hash, &block)
+    dup.update(hash, &block)
+  end
+
+  def reverse_merge(other_hash)
+    super(self.class.new(other_hash))
+  end
+
+  alias_method :with_defaults, :reverse_merge
+
+  def reverse_merge!(other_hash)
+    super(self.class.new(other_hash))
+  end
+
+  alias_method :with_defaults!, :reverse_merge!
+
+  def replace(other_hash)
+    super(self.class.new(other_hash))
+  end
+
+  def delete(key)
+    super(convert_key(key))
+  end
+
+  def except(*keys)
+    slice(*self.keys - keys.map { |key| convert_key(key) })
+  end
+
+  alias_method :without, :except
+
+  def stringify_keys!; self end
+  def deep_stringify_keys!; self end
+  def stringify_keys; dup end
+  def deep_stringify_keys; dup end
+  undef :symbolize_keys!
+  undef :deep_symbolize_keys!
+  def symbolize_keys; to_hash.symbolize_keys! end
+  alias_method :to_options, :symbolize_keys
+  def deep_symbolize_keys; to_hash.deep_symbolize_keys! end
+  def to_options!; self end
+
+  def select(*args, &block)
+    return to_enum(:select) unless block_given?
+    dup.tap { |hash| hash.select!(*args, &block) }
+  end
+
+  def reject(*args, &block)
+    return to_enum(:reject) unless block_given?
+    dup.tap { |hash| hash.reject!(*args, &block) }
+  end
+
+  def transform_values(*args, &block)
+    return to_enum(:transform_values) unless block_given?
+    dup.tap { |hash| hash.transform_values!(*args, &block) }
+  end
+
+  def transform_keys(*args, &block)
+    return to_enum(:transform_keys) unless block_given?
+    dup.tap { |hash| hash.transform_keys!(*args, &block) }
+  end
+
+  def transform_keys!
+    return enum_for(:transform_keys!) { size } unless block_given?
+    keys.each do |key|
+      self[yield(key)] = delete(key)
+    end
+    self
+  end
+
+  def slice(*keys)
+    keys.map! { |key| convert_key(key) }
+    self.class.new(super)
+  end
+
+  def slice!(*keys)
+    keys.map! { |key| convert_key(key) }
+    super
+  end
+
+  def compact
+    dup.tap(&:compact!)
+  end
+
+  def to_hash
+    _new_hash = Hash.new
+    set_defaults(_new_hash)
+
+    each do |key, value|
+      _new_hash[key] = convert_value(value, for: :to_hash)
+    end
+    _new_hash
+  end
+
+  private
+
+  def convert_keys(keys)
+    keys.map { |key| convert_key(key) }
+  end
+
+  def convert_key(key)
+    key.kind_of?(Symbol) ? key.to_s : key
+  end
+
+  def convert_values(values)
+    values.map { |value| convert_value(value) }
+  end
+
+  def convert_value(value, options = {})
+    if value.is_a? Hash
+      if options[:for] == :to_hash
+        value.to_hash
+      else
+        value.nested_under_indifferent_access
+      end
+    elsif value.is_a?(Array)
+      if options[:for] != :assignment || value.frozen?
+        value = value.dup
+      end
+      value.map! { |e| convert_value(e, options) }
+    else
+      value
+    end
+  end
+
+  def set_defaults(target)
+    if default_proc
+      target.default_proc = default_proc.dup
+    else
+      target.default = default
+    end
+  end
+end

data/simple-hash.gemspec

@@ -0,0 +1,14 @@
+require_relative "lib/simple/hash"
+
+Gem::Specification.new do |spec|
+  spec.name = "simple-hash"
+  spec.version = Simple::Hash::VERSION
+  spec.authors = ["localhostdotdev"]
+  spec.email = ["localhostdotdev@protonmail.com"]
+  spec.summary = "typically make JSON into object with accessors"
+  spec.homepage = "https://github.com/simple-updates/simple-hash"
+  spec.license = "MIT"
+  spec.files = `git ls-files`.split("\n")
+  spec.require_paths = ["lib"]
+  spec.add_dependency "activesupport", "~> 6.0.0beta3"
+end

data/test/simple/hash_test.rb

@@ -0,0 +1,97 @@
+require "minitest/autorun"
+require_relative '../../lib/simple/hash'
+
+class TestSimpleHash < Minitest::Test
+  extend MiniTest::Spec::DSL
+
+  @@counter = 0
+
+  def self.it(&block)
+    @@counter += 1
+
+    define_method("test_#{@@counter}", &block)
+  end
+
+  def assert_nothing_raised(&block)
+    error = nil
+
+    begin
+      block.call
+    rescue => e
+      error = e
+      puts e.message
+      puts e.backtrace
+    end
+
+    assert_nil(error)
+  end
+
+  def assert_raises_message(message, &block)
+    error = nil
+
+    begin
+      block.call
+    rescue => e
+      error = e
+    end
+
+    assert_includes(error&.message.to_s, message)
+  end
+
+  before do
+    @data = { a: 1, b: [{ c: { d: 2 } }, { e: 3 }], f: { g: 4 } }
+    @simple_hash = Simple::Hash[@data]
+  end
+
+  # initialize
+  it { assert_nothing_raised { Simple::Hash.new(@data).b } }
+  it { assert_nothing_raised { Simple::Hash[@data].b } }
+  it { assert_nothing_raised { Simple::Hash[@data.to_a].b } }
+  it { assert_nothing_raised { Simple::Hash[:a, 1, :b, 2].b } }
+  it { assert_raises(ArgumentError) { Simple::Hash.new(:a, 1, :b, 2).b } }
+
+  # access by method
+  it { assert_equal(1, @simple_hash.a) }
+  it { assert_equal(2, @simple_hash.b[0].c.d) }
+  it { assert_equal(2, @simple_hash.b[0].c.d) }
+  it { assert_equal(3, @simple_hash.b[1].e) }
+  it { assert_equal(4, @simple_hash.f.g) }
+
+  # raise if no method
+  it { assert_raises(NoMethodError) { @simple_hash.something } }
+  it { assert_raises(NoMethodError) { @simple_hash.a.something } }
+  it { assert_raises(NoMethodError) { @simple_hash.b.first.something } }
+  it { assert_raises(NoMethodError) { @simple_hash.b.first.c.something } }
+
+  # access by indifferent key
+  it { assert_equal(1, @simple_hash["a"]) }
+  it { assert_equal(2, @simple_hash[:b][0].fetch("c").d) }
+  it { assert_equal(2, @simple_hash[:b][0][:c][:d]) }
+  it { assert_equal(2, @simple_hash.b[0][:c]["d"]) }
+  it { assert_equal(3, @simple_hash.b[1].fetch("e")) }
+  it { assert_equal(4, @simple_hash.fetch(:f).g) }
+
+  # can get keys/values
+  it { assert_equal(["a", "b", "f"], @simple_hash.keys) }
+  it { assert_equal(1, @simple_hash.values.first) }
+  it { assert_equal({ "g" => 4 }, @simple_hash.values.last) }
+
+  # did you mean
+  it { assert_raises_message('Did you mean?  a') { @simple_hash.aa } }
+  it { assert_raises_message('Did you mean?  b') { @simple_hash.bb } }
+  it { assert_raises_message('Did you mean?  d') { @simple_hash.b[0].c.dd } }
+
+  # to_json
+  it do
+    require 'json'
+    assert_equal('{"a":1}', Simple::Hash[a: 1].to_json)
+  end
+
+  it do
+    require 'json'
+    assert_equal('{"a":{"b":2}}', Simple::Hash[a: { b: 2 }].to_json)
+  end
+
+  # can't modify deep keys
+  it { assert_raises { @simple_hash.b.first.c.merge!(d: 5) } }
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: simple-hash
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- localhostdotdev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-04-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.0beta3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.0beta3
+description: 
+email:
+- localhostdotdev@protonmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- bin/console
+- lib/simple/hash.rb
+- lib/simple/hash_with_indifferent_access.rb
+- simple-hash.gemspec
+- test/simple/hash_test.rb
+homepage: https://github.com/simple-updates/simple-hash
+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: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: typically make JSON into object with accessors
+test_files: []