jsof 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c83f6ee1b4cb426245690720ddfe8d25cc64a80bdb432a37e4dea766a9d066c8
+  data.tar.gz: e55a4b4a98f039ff9c864318a72649be3ff363add77e46d693b3e648da1ee85a
+SHA512:
+  metadata.gz: 4285733477cc69de5f682d26c21f3069946341eece8eb826ea67fc69985bcba42cd87f4c0b0c53a1e476bbe6c9d437c07f58bf310f41a1499225841209f88a6e
+  data.tar.gz: 874d2e9d7ecf1dd735f0398a679477f4aae5b4530b9624e49adbbb8d9b7dfbfc80d0665b5040cf356c21c546f8b53919288dde528a8c3de6fc4047385ce5a7be

data/.rubocop.yml

@@ -0,0 +1,13 @@
+AllCops:
+  TargetRubyVersion: 2.6
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Max: 120

data/Gemfile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in jsof.gemspec
+gemspec
+
+gem "rake", "~> 13.0"
+
+gem "minitest", "~> 5.0"
+
+gem "rubocop", "~> 1.21"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Riki Ishikawa
+
+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,86 @@
+# Jsof
+
+Jsof is library to utilize manipuration of JSON object in Ruby.
+It provides wrapper class for Hash and Array to access properties like JavaScript fasion.
+If you want, you can define properties explicitly, and add type to them.
+
+(Jsof stand for "JavaScript of".)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'jsof'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install jsof
+
+## Usage
+
+### For normal use
+
+```ruby
+require 'jsof'
+
+x = Jsof({a: 1, b: {c: 'a'}})
+p x.a  # => 1
+p x.b.c  # => 'a'
+x.d = 3
+x.e = {ee: 4}
+p x.to_h  # => {a: 1, b: {c: 'a'}, d: 3, e: {ee: 4}}
+```
+
+### define explicit attributes
+
+```ruby
+require 'jsof'
+
+class X < Jsof::WrapObject
+  define_attr :a    # untyped property
+  define_attr :b, type: Integer    # typed property
+  define_attr :c, type: Array    # untyped array property
+end
+
+x = X.new
+x.a = 1
+x.b = 'a'    # raise TypeError
+x.c = [1, 2]
+x.d = 1    # raise NoMethodError
+```
+
+Also, you can define nested structure with type.
+
+```ruby
+class Y < Jsof::WrapObject
+  define_attr :xx, type: X
+end
+
+y = Y.new
+y.x = {}
+y.x.a = 1
+y.x.unknown = 1  # raise TypeError
+
+y.x = {unknown: 1}    # Currently, this kind type check is not implemented.
+```
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/jljse/jsof.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[test rubocop]

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "jsof"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/jsof.gemspec

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "lib/jsof/version"
+
+Gem::Specification.new do |spec|
+  spec.name = "jsof"
+  spec.version = Jsof::VERSION
+  spec.authors = ["Riki Ishikawa"]
+  spec.email = ["riki.ishikawa@gmail.com"]
+
+  spec.summary = "JSON object wrapper to access properties like JavaScript."
+  # spec.description = "TODO: Write a longer description or delete this line."
+  spec.homepage = "https://github.com/jljse/jsof/"
+  spec.license = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
+
+  # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/jljse/jsof/"
+  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (f == __FILE__) || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+    end
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  # Uncomment to register a new dependency of your gem
+  # spec.add_dependency "example-gem", "~> 1.0"
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end

data/lib/jsof/global.rb

@@ -0,0 +1,13 @@
+
+# Wrap JSON like object
+# @pram [Hash] obj  Wrap target object
+# @return [Jsof::WrapObject, Jsof::WrapArray]
+def Jsof(obj = {})
+  if obj.is_a? Hash
+    return Jsof::WrapObject.new(obj)
+  end
+  if obj.is_a? Array
+    return Jsof::WrapArray.new(obj)
+  end
+  obj
+end

data/lib/jsof/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Jsof
+  VERSION = "0.1.0"
+end

data/lib/jsof/wrap_array.rb

@@ -0,0 +1,84 @@
+
+# Wrapper class for Array.
+class Jsof::WrapArray
+  # Create wrapper for Array
+  # @param [Array] obj  Wrap target array
+  # @param [Class, Jsof::WrapArrayType] typeof_element  Type of each element
+  def initialize(obj = [], typeof_element: nil)
+    @internal_object = obj
+    @wrapped = []
+    @typeof_element = typeof_element
+  end
+
+  # Return reference to wrapped array.
+  def internal_object
+    @internal_object
+  end
+
+  def typeof_element
+    @typeof_element
+  end
+
+  def [](index)
+    raise ArgumentError unless index.is_a? Integer
+
+    return @wrapped[index] if @wrapped[index]
+
+    elem = @internal_object[index]
+    boxed = Jsof::WrapHelper.boxing(elem, typeof_element)
+    @wrapped[index] = boxed if elem != boxed
+    return boxed
+  end
+
+  def []=(index, val)
+    raise ArgumentError unless index.is_a? Integer
+
+    if typeof_element
+      raise TypeError unless Jsof::WrapHelper.assignable?(typeof_element, val)
+    end
+
+    boxed = Jsof::WrapHelper.boxing(val, typeof_element)
+    @wrapped[index] = boxed if Jsof::WrapHelper.wrapped_value?(boxed)
+    @internal_object[index] = Jsof::WrapHelper.unboxing(val)
+    val
+  end
+
+  # Clean internal cache.
+  # Call this after you changed wrapped object directly.
+  def clear_internal
+    @wrapped.clear
+  end
+
+  # @return [Integer]
+  def size
+    @internal_object.size
+  end
+
+  # Delete element. (Same as Array#delete_at)
+  # @param [Integer] pos  Element index to delete
+  def delete_at(pos)
+    @internal_object.delete_at(pos)
+    @wrapped.delete_at(pos)
+  end
+
+  include Enumerable
+  def each
+    if block_given?
+      for i in 0...@internal_object.size
+        yield self[i]
+      end
+    else
+      Enumerator.new(self, :each)
+    end
+  end
+
+  # Return reference to wrapped array.
+  def to_ary
+    @internal_object
+  end
+
+  # Return reference to wrapped array.
+  def to_a
+    @internal_object
+  end
+end

data/lib/jsof/wrap_array_type.rb

@@ -0,0 +1,24 @@
+
+# Used with define_attr to define typed array property.
+class Jsof::WrapArrayType
+  # @param [Class, WrapArrayType] typeof_element  Type of each element
+  def initialize(typeof_element: nil)
+    @typeof_element = typeof_element
+  end
+
+  # Create wrapper instance.
+  # @return [Jsof::WrapArray]
+  def new(obj)
+    Jsof::WrapArray.new(obj, typeof_element: @typeof_element)
+  end
+
+  # Check value can be wrapped by this type.
+  # @return [Boolean]
+  def assignable?(val)
+    if @typeof_element && val
+      return false unless val.is_a? Array
+      return val.all?{|elem| Jsof::WrapHelper.assignable?(@typeof_element, elem)}
+    end
+    true
+  end
+end

data/lib/jsof/wrap_helper.rb

@@ -0,0 +1,69 @@
+
+
+# Helper methods.
+module Jsof::WrapHelper
+  # @return [Boolean]  Already wrapped or not
+  def self.wrapped_value?(val)
+    return true if val.is_a?(Jsof::WrapObject)
+    return true if val.is_a?(Jsof::WrapArray)
+    return false
+  end
+
+  # @return [Boolean]  Wrappable by Jsof::WrapObject or not
+  def self.require_wrap_value?(val)
+    return true if val.is_a?(Hash)
+    return false
+  end
+
+  # @return [Boolean]  Wrappable by Jsof::WrapArray or not
+  def self.require_array_wrap_value?(val)
+    return true if val.is_a?(Array)
+    return false
+  end
+
+  # Wrap value if wrappable.
+  # @param [Object] val  Wrap target object
+  # @param [Class, Jsof::WrapArrayType]  Wrapper type. if nil, use WrapObject/WrapArray.
+  def self.boxing(val, wrapper_type)
+    if require_wrap_value?(val)
+      return wrapper_type.new(val) if wrapper_type
+      return Jsof::WrapObject.new(val)
+    end
+    if require_array_wrap_value?(val)
+      return wrapper_type.new(val) if wrapper_type
+      return Jsof::WrapArray.new(val)
+    end
+    return val
+  end
+
+  # Take internal object if wrapped.
+  # @param [Object] val   Unwrap target object
+  def self.unboxing(val)
+    if wrapped_value?(val)
+      return val.internal_object
+    end
+    return val
+  end
+
+  # Check value can be wrapped by specific type.
+  # @param [Class, Jsof::WrapArrayType] type  Expected type
+  # @param [Object] val  Check target object
+  # @return [Boolean]
+  def self.assignable?(type, val)
+    return true unless val
+
+    if type.is_a? Jsof::WrapArrayType
+      return type.assignable?(val)
+    end
+    if type == Jsof::BooleanType
+      return val == true || val == false
+    end
+    if type < Jsof::WrapObject
+      return type.assignable?(val)
+    end
+    if type.is_a? Class
+      return val.is_a? type
+    end
+    true
+  end
+end

data/lib/jsof/wrap_object.rb

@@ -0,0 +1,134 @@
+# Wrapper class for Object(Hash).
+class Jsof::WrapObject
+  # Create wrapper for Hash.
+  # @param [Hash] obj  Wrap target hash
+  # @param [Boolean] allow_implicit_attr
+  #     Allow to use undefined properties or not.
+  #     If nil, assume true if it's instance of WrapObject,
+  #     and assume false if it's instance of derived classes.
+  def initialize(obj = {}, allow_implicit_attr: nil)
+    unless self.class.initialized?
+      self.class.resolve_typeof_properties
+      self.class.initialize()
+      self.class.initialized = true
+    end
+
+    @internal_object = obj
+    @wrapped = {}
+    @is_allow_implicit_attr = allow_implicit_attr
+    if @is_allow_implicit_attr == nil
+      @is_allow_implicit_attr = self.class.typeof_properties.empty?
+    end
+  end
+
+  @typeof_properties = {}
+  def self.inherited(subclass)
+    subclass.instance_variable_set(:@typeof_properties, @typeof_properties.dup)
+  end
+  # Explicitly defined properties.
+  # @return [Hash{Symbol => Class, Jsof::WrapArrayType, Proc}]
+  def self.typeof_properties
+    @typeof_properties
+  end
+  def self.resolve_typeof_properties
+    @typeof_properties.keys.each do |sym|
+      if @typeof_properties[sym].is_a? Proc
+        @typeof_properties[sym] = @typeof_properties[sym].call
+      end
+    end
+  end
+  @initialized = false
+  # Whether self.initialize was already called or not.
+  def self.initialized?
+    @initialized
+  end
+  def self.initialized=(val)
+    @initialized = val
+  end
+  # Place to define properties by define_attr.
+  # Override this for derived class.
+  # This method will be called when the first instace is created.
+  def self.initialize
+    # override
+  end
+
+  # Define explicit accessor methods for attribute(property).
+  # @param [Symbol] sym  Attribute name.
+  # @param [Class, Jsof::WrapArrayType, Proc] type
+  #    If nil, the property is untyped.
+  #    Usually, pass Class to specify the type of the property.
+  #    If you want to specify typed Array, then pass instance of Jsof::WrapArrayType.
+  #    If you want to use the class not defined yet (defined later) , then wrap with Proc like `->{ YourClass }`.
+  def self.define_attr(sym, type: nil)
+    @typeof_properties[sym] = type
+    self.define_method(sym) do
+      self[sym]
+    end
+    self.define_method((sym.to_s + "=").to_sym) do |val|
+      self[sym] = val
+    end
+  end
+
+  # Check value can be wrapped by this type.
+  # TODO: Currently, will not check properties's types,
+  # but this behavior might be changed in future version.
+  # @return [Boolean]
+  def self.assignable?(val)
+    # TODO:
+    return true if val == nil
+    return true if val.is_a? Hash
+    false
+  end
+
+  # Return reference to wrapped array.
+  def internal_object
+    @internal_object
+  end
+
+  def [](key)
+    sym = key.to_sym
+    return @wrapped[sym] if @wrapped.key?(sym)
+
+    elem = @internal_object[sym]
+    boxed = Jsof::WrapHelper.boxing(elem, self.class.typeof_properties[sym])
+    @wrapped[sym] = boxed if elem != boxed
+    return boxed
+  end
+
+  def []=(key, val)
+    sym = key.to_sym
+    if type = self.class.typeof_properties[sym]
+      raise TypeError unless Jsof::WrapHelper.assignable?(type, val)
+    end
+    boxed = Jsof::WrapHelper.boxing(val, self.class.typeof_properties[sym])
+    @wrapped[sym] = boxed if Jsof::WrapHelper.wrapped_value?(boxed)
+    @internal_object[sym] = Jsof::WrapHelper.unboxing(val)
+    val
+  end
+
+  # Clean internal cache.
+  # Call this after you changed wrapped object directly.
+  def clear_internal
+    @wrapped.clear
+  end
+
+  def method_missing(name, *args)
+    raise NoMethodError.new("", name) unless @is_allow_implicit_attr
+
+    if name.to_s.end_with?('=')
+      self[name.to_s[0...-1].to_sym] = args.first
+    else
+      self[name]
+    end
+  end
+
+  # Return reference to wrapped array.
+  def to_hash
+    @internal_object
+  end
+
+  # Return reference to wrapped array.
+  def to_h
+    @internal_object
+  end
+end

data/lib/jsof.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative "jsof/version"
+
+module Jsof
+  class BooleanType end
+end
+
+require_relative 'jsof/wrap_array'
+require_relative 'jsof/wrap_array_type'
+require_relative 'jsof/wrap_object'
+require_relative 'jsof/wrap_helper'
+require_relative 'jsof/global'

data/sig/jsof.rbs

@@ -0,0 +1,4 @@
+module Jsof
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: jsof
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Riki Ishikawa
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2022-01-19 00:00:00.000000000 Z
+dependencies: []
+description:
+email:
+- riki.ishikawa@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- jsof.gemspec
+- lib/jsof.rb
+- lib/jsof/global.rb
+- lib/jsof/version.rb
+- lib/jsof/wrap_array.rb
+- lib/jsof/wrap_array_type.rb
+- lib/jsof/wrap_helper.rb
+- lib/jsof/wrap_object.rb
+- sig/jsof.rbs
+homepage: https://github.com/jljse/jsof/
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/jljse/jsof/
+  source_code_uri: https://github.com/jljse/jsof/
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: JSON object wrapper to access properties like JavaScript.
+test_files: []