json_resource 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: dbada0c6c6821280079957d75f002a39fa338c6566a4daf7cda3650b98fb29fd
+  data.tar.gz: a232cf53b5e86dd6e9df328786c5db0ab150747284e11682d5b51bf426fef46c
+SHA512:
+  metadata.gz: 1a8a3aae1d4e7b21df4e09cc5d8da6f807219e6fc3841c02ca200d9bce621aa222f5e4caa1ee61b190c6041d2b1269674dcaf9b3453e4d8ccdebf3bc41e3e518
+  data.tar.gz: ab5f72f1a266e1ba3e8ae993d951339c9f63c66a5960e241968931343233ce2bafdcf8667eb58378589e698b628573d0f4b2f9b54d427693667095c574348d5b

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+## 1.0.0
+
+- First release
+

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Matthias Grosser
+
+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,64 @@
+[![Gem Version](https://badge.fury.io/rb/json_resource.svg)](http://badge.fury.io/rb/json_resource)
+[![build](https://github.com/mtgrosser/json_resource/actions/workflows/build.yml/badge.svg)](https://github.com/mtgrosser/json_resource/actions/workflows/build.yml)
+
+# json_resource – Create Ruby objects from JSON data
+
+```ruby
+class Post
+  include JsonResource::Model
+  
+  attribute :id,          type: :integer
+  attribute :body,        type: :string
+  attribute :timestamp,   type: :time
+  attribute :status_code, type: :integer, path: %w[status statusCode]
+  attribute :status_text, type: :string,  path: %w[status statusText]
+  
+  has_collection :comments
+end
+
+class Comment
+  include JsonResource::Model
+  
+  attribute :author,    type: :string
+  attribute :text,      type: :string
+  attribute :timestamp, type: :time
+end
+```
+
+```json
+{
+  "posts": [
+    {
+      "id": 123,
+      "body": "Lorem ipsum",
+      "timestamp": "2021-12-08T18:43:00",
+      "status": {
+        "statusCode": 2,
+        "statusText": "published"
+      },
+      "comments": [
+        {
+          "author": "Mr. Spock",
+          "text":   "Fascinating!",
+          "timestamp": "2350-05-01T19:00:00"
+        },
+        {
+          "author": "Chekov",
+          "text":   "Warp 10",
+          "timestamp": "2350-05-01T20:00:00"
+        }
+      ]
+      
+    }
+  ]
+}
+```
+
+```ruby
+posts = Post.collection_from_json(json, root: 'posts')
+
+posts.first.id => 123
+posts.first.body => 'Lorem ipsum'
+posts.first.status_text => 'published'
+posts.first.comments.first.author => 'Mr. Spock'
+```

data/lib/json_resource/errors.rb

@@ -0,0 +1,5 @@
+module JsonResource
+  class Error < StandardError; end
+  class ParseError < Error; end
+  class TypeCastError < Error; end
+end

data/lib/json_resource/inflections.rb

@@ -0,0 +1,78 @@
+module JsonResource
+  module Inflections
+    
+    class << self
+      attr_accessor :pluralizations, :singularizations, :irregulars, :uncountables, :acronyms
+    end
+    
+    self.pluralizations = [
+      [/\z/, 's'],
+      [/s\z/i, 's'],
+      [/(ax|test)is\z/i, '\1es'],
+      [/(.*)us\z/i, '\1uses'],
+      [/(octop|vir|cact)us\z/i, '\1i'],
+      [/(octop|vir)i\z/i, '\1i'],
+      [/(alias|status)\z/i, '\1es'],
+      [/(buffal|domin|ech|embarg|her|mosquit|potat|tomat)o\z/i, '\1oes'],
+      [/(?<!b)um\z/i, '\1a'],
+      [/([ti])a\z/i, '\1a'],
+      [/sis\z/i, 'ses'],
+      [/(.*)(?:([^f]))fe*\z/i, '\1\2ves'],
+      [/(hive|proof)\z/i, '\1s'],
+      [/([^aeiouy]|qu)y\z/i, '\1ies'],
+      [/(x|ch|ss|sh)\z/i, '\1es'],
+      [/(stoma|epo)ch\z/i, '\1chs'],
+      [/(matr|vert|ind)(?:ix|ex)\z/i, '\1ices'],
+      [/([m|l])ouse\z/i, '\1ice'],
+      [/([m|l])ice\z/i, '\1ice'],
+      [/^(ox)\z/i, '\1en'],
+      [/^(oxen)\z/i, '\1'],
+      [/(quiz)\z/i, '\1zes'],
+      [/(.*)non\z/i, '\1na'],
+      [/(.*)ma\z/i, '\1mata'],
+      [/(.*)(eau|eaux)\z/, '\1eaux']]
+
+    self.singularizations = [
+      [/s\z/i, ''],
+      [/(n)ews\z/i, '\1ews'],
+      [/([ti])a\z/i, '\1um'],
+      [/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)(sis|ses)\z/i, '\1\2sis'],
+      [/(^analy)(sis|ses)\z/i, '\1sis'],
+      [/([^f])ves\z/i, '\1fe'],
+      [/(hive)s\z/i, '\1'],
+      [/(tive)s\z/i, '\1'],
+      [/([lr])ves\z/i, '\1f'],
+      [/([^aeiouy]|qu)ies\z/i, '\1y'],
+      [/(s)eries\z/i, '\1eries'],
+      [/(m)ovies\z/i, '\1ovie'],
+      [/(ss)\z/i, '\1'],
+      [/(x|ch|ss|sh)es\z/i, '\1'],
+      [/([m|l])ice\z/i, '\1ouse'],
+      [/(us)(es)?\z/i, '\1'],
+      [/(o)es\z/i, '\1'],
+      [/(shoe)s\z/i, '\1'],
+      [/(cris|ax|test)(is|es)\z/i, '\1is'],
+      [/(octop|vir)(us|i)\z/i, '\1us'],
+      [/(alias|status)(es)?\z/i, '\1'],
+      [/^(ox)en/i, '\1'],
+      [/(vert|ind)ices\z/i, '\1ex'],
+      [/(matr)ices\z/i, '\1ix'],
+      [/(quiz)zes\z/i, '\1'],
+      [/(database)s\z/i, '\1']]
+    
+    self.irregulars = [
+      ['person', 'people'],
+      ['man', 'men'],
+      ['human', 'humans'],
+      ['child', 'children'],
+      ['sex', 'sexes'],
+      ['foot', 'feet'],
+      ['tooth', 'teeth'],
+      ['goose', 'geese'],
+      ['forum', 'forums']]
+
+    self.uncountables = %w[hovercraft moose deer milk rain Swiss grass equipment information rice money species series fish sheep jeans]
+
+    self.acronyms = {}
+  end
+end

data/lib/json_resource/model.rb

@@ -0,0 +1,211 @@
+module JsonResource
+  using JsonResource::Refinements
+
+  module Model
+    TRUE_VALUES = [true, 1, '1', 't', 'T', 'true', 'TRUE', 'on', 'ON'].to_set
+    
+    def self.included(base)
+      base.extend ClassMethods
+      base.class_attribute :attributes, :collections, :objects, :inflection
+      base.attributes = {}
+      base.collections = {}
+      base.objects = {}
+      base.inflection = :lower_camelcase
+    end
+
+    module ClassMethods
+      
+      def from_json(obj, defaults: {}, root: nil)
+        return unless json = parse(obj)
+        json = json_dig(json, *root) if root
+        attrs = {}
+        self.attributes.each do |name, options|
+          if path = attribute_path(name)
+            value = json_dig(json, *path)
+            if !value.nil? && type = attribute_type(name)
+              value = cast_to(type, value)
+            end
+            attrs[name] = value
+          end
+        end
+        instance = new(defaults.merge(attrs.compact))
+        self.objects.each do |name, options|
+          if path = object_path(name) and obj = json_dig(json, *path)
+            instance.public_send("#{name}=", object_class(name).from_json(obj))
+          end
+        end
+        self.collections.each do |name, options|
+          collection = if path = collection_path(name) and obj = json_dig(json, *path)
+            instance.public_send("#{name}=", collection_class(name).collection_from_json(obj))
+          else
+            []
+          end
+        end
+        instance
+      end
+    
+      def collection_from_json(obj, defaults: {}, root: nil)
+        json = parse(obj)
+        json = json_dig(json, root) if root
+        json.map { |hsh| from_json(hsh, defaults: defaults) }.compact
+      end
+    
+      def basename
+        name.sub(/^.*::/, '')
+      end
+    
+      [:attribute, :object, :collection].each do |method_name|
+        define_method "#{method_name}_names" do
+          send("#{method_name}s").keys
+        end
+      end
+    
+      protected
+    
+      def attribute(name, options = {})
+        self.attributes = attributes.merge(name.to_sym => options.symbolize_keys)
+        attribute_accessor_method name
+      end
+    
+      def attributes(*args)
+        options = args.extract_options!
+        args.each { |arg| has_attribute arg, options }
+      end
+    
+      def has_object(name, options = {})
+        self.objects = objects.merge(name.to_sym => options.symbolize_keys)
+        attr_accessor name
+      end
+    
+      def has_collection(name, options = {})
+        self.collections = collections.merge(name.to_sym => options.symbolize_keys)
+        define_method "#{name}" do
+          instance_variable_get("@#{name}") or instance_variable_set("@#{name}", [])
+        end
+        define_method "#{name}=" do |assignment|
+          instance_variable_set("@#{name}", assignment) if assignment
+        end
+      end
+
+      private
+    
+      def attribute_accessor_method(name)
+        define_method("#{name}") { self[name] }
+        define_method("#{name}=") { |value| self[name] = value }
+      end
+
+      [:attribute, :object, :collection].each do |method_name|
+        define_method "#{method_name}_path" do |name|
+          options = send(method_name.to_s.pluralize)
+          Array(options[name].try(:[], :path)).presence || [inflect(name)]
+        end
+      end
+
+      def attribute_type(name)
+        attributes[name] && attributes[name][:type]
+      end
+    
+      def object_class(name)
+        if objects[name] && class_name = objects[name][:class_name]
+          class_name.constantize
+        else
+          name.to_s.classify.constantize
+        end
+      end
+    
+      def collection_class(name)
+        if collections[name] && class_name = collections[name][:class_name]
+          class_name.constantize
+        else
+          name.to_s.singularize.classify.constantize
+        end
+      end
+    
+      def cast_to(type, value)  # only called for non-nil values
+        case type
+        when :string    then value
+        when :integer   then value.to_i
+        when :float     then value.to_f
+        when :boolean   then cast_to_boolean(value)
+        when :decimal   then BigDecimal(value)
+        when :date      then value.presence && Date.parse(value)
+        when :time      then value.presence && Time.parse(value)
+        else
+          raise JsonResource::TypeCastError, "don't know how to cast #{value.inspect} to #{type}"
+        end
+      end
+
+      def cast_to_boolean(value)
+        if value.is_a?(String) && value.blank?
+          nil
+        else
+          TRUE_VALUES.include?(value)
+        end
+      end
+
+      def parse(obj)
+        case obj
+        when Hash, Array then obj
+        when String then JSON.parse(obj)
+        else
+          raise JsonResource::ParseError, "cannot parse #{obj.inspect}"
+        end 
+      end
+      
+      def inflect(string)
+        string = string.to_s
+        case inflection
+        when :lower_camelcase
+          string.camelcase(:lower)
+        when :upper_camelcase
+          string.camelcase(:upper)
+        when :dasherize
+          string.underscore.dasherize
+        when nil
+          string.underscore
+        else
+          string.public_send(inflection)
+        end
+      end
+      
+      def json_dig(obj, *path)
+        path.inject(obj) do |receiver, key|
+          next nil if receiver.nil?
+          if key.respond_to?(:match) and idx = key.match(/\A\[(?<idx>\d+)\]\z/).try(:[], :idx)
+            receiver[idx.to_i]
+          else
+            receiver[key]
+          end
+        end
+      end
+    end
+  
+    def initialize(attrs = {})
+      self.attributes = attrs if attrs
+      super()
+    end
+
+    def valid?
+      true
+    end
+  
+    def attributes=(attrs)
+      attrs.each do |attr, value|
+        self.public_send("#{attr}=", value)
+      end
+    end
+  
+    def attributes
+      @attributes ||= {}
+    end
+  
+    def [](attr_name)
+      attributes[attr_name.to_sym]
+    end
+  
+    def []=(attr_name, value)
+      attributes[attr_name.to_sym] = value
+    end
+  
+  end
+end

data/lib/json_resource/refinements.rb

@@ -0,0 +1,209 @@
+module JsonResource
+  module Refinements
+
+    refine Object do
+
+      def blank?
+        respond_to?(:empty?) ? !!empty? : !self
+      end
+
+      def present?
+        !blank?
+      end
+
+      def presence
+        self if present?
+      end
+      
+      def try(*a, &b)
+        try!(*a, &b) if a.empty? || respond_to?(a.first)
+      end
+
+      def try!(*a, &b)
+        if a.empty? && block_given?
+          if b.arity == 0
+            instance_eval(&b)
+          else
+            yield self
+          end
+        else
+          public_send(*a, &b)
+        end
+      end
+
+    end
+
+    refine NilClass do
+
+      def try(*args)
+        nil
+      end
+
+      def try!(*args)
+        nil
+      end
+
+    end
+
+    refine Class do
+
+      def class_attribute(*attrs)
+        attrs.each do |name|
+          define_singleton_method(name) { nil }
+
+          ivar = "@#{name}"
+
+          define_singleton_method("#{name}=") do |val|
+            singleton_class.class_eval do
+              undef_method(name) if method_defined?(name) || private_method_defined?(name)
+              define_method(name) { val }
+            end
+
+            if singleton_class?
+              class_eval do
+                undef_method(name) if method_defined?(name) || private_method_defined?(name)
+                define_method(name) do
+                  if instance_variable_defined? ivar
+                    instance_variable_get ivar
+                  else
+                    singleton_class.send name
+                  end
+                end
+              end
+            end
+            val
+          end
+
+          undef_method(name) if method_defined?(name) || private_method_defined?(name)
+          define_method(name) do
+            if instance_variable_defined?(ivar)
+              instance_variable_get ivar
+            else
+              self.class.public_send name
+            end
+          end
+
+          attr_writer name
+        end
+      end
+
+    end
+    
+    refine String do
+
+      def constantize
+        if blank? || !include?("::")
+          Object.const_get(self)
+        else
+          names = split("::")
+
+          # Trigger a built-in NameError exception including the ill-formed constant in the message.
+          Object.const_get(self) if names.empty?
+
+          # Remove the first blank element in case of '::ClassName' notation.
+          names.shift if names.size > 1 && names.first.empty?
+
+          names.inject(Object) do |constant, name|
+            if constant == Object
+              constant.const_get(name)
+            else
+              candidate = constant.const_get(name)
+              next candidate if constant.const_defined?(name, false)
+              next candidate unless Object.const_defined?(name)
+
+              # Go down the ancestors to check if it is owned directly. The check
+              # stops when we reach Object or the end of ancestors tree.
+              constant = constant.ancestors.inject(constant) do |const, ancestor|
+                break const    if ancestor == Object
+                break ancestor if ancestor.const_defined?(name, false)
+                const
+              end
+
+              # owner is in Object, so raise
+              constant.const_get(name, false)
+            end
+          end
+        end
+      end
+
+      def camelcase(*separators)
+        case separators.first
+        when Symbol, TrueClass, FalseClass, NilClass
+          first_letter = separators.shift
+        end
+
+        separators = ['_', '\s'] if separators.empty?
+
+        str = self.dup
+
+        separators.each do |s|
+          str = str.gsub(/(?:#{s}+)([a-z])/){ $1.upcase }
+        end
+
+        case first_letter
+        when :upper, true
+          str = str.gsub(/(\A|\s)([a-z])/){ $1 + $2.upcase }
+        when :lower, false
+          str = str.gsub(/(\A|\s)([A-Z])/){ $1 + $2.downcase }
+        end
+
+        str
+      end
+
+      def underscore
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr('-', '_').
+        gsub(/\s/, '_').
+        gsub(/__+/, '_').
+        downcase
+      end
+
+      def dasherize
+        underscore.gsub('_', '-')
+      end
+
+      def pluralize
+        return dup if Inflections.uncountables.reverse.any? { |suffix| end_with?(suffix) }
+        Inflections.irregulars.reverse.each do |suffix, irregluar|
+          return sub(/#{Regexp.escape(suffix)}\z/, irregluar) if end_with?(suffix)
+        end
+        plural = dup
+        Inflections.pluralizations.reverse.each do |pattern, substitution|
+          return plural if plural.gsub!(pattern, substitution)
+        end
+        plural
+      end
+
+      def singularize
+        return dup if Inflections.uncountables.reverse.any? { |suffix| end_with?(suffix) }
+        Inflections.irregulars.reverse.each do |suffix, irregular|
+          return sub(/#{Regexp.escape(irregular)}\z/, suffix) if end_with?(irregular)
+        end
+        singular = dup
+        Inflections.singularizations.reverse.each do |pattern, substitution|
+          return singular if singular.gsub!(pattern, substitution)
+        end
+        singular
+      end
+
+      def camelize
+        camelcase(:upper)
+      end
+
+      def classify
+        sub(/.*\./, '').singularize.camelize
+      end
+
+    end
+
+    refine Hash do
+
+      def symbolize_keys
+        transform_keys(&:to_sym)
+      end
+      
+    end
+
+  end
+end

data/lib/json_resource/version.rb

@@ -0,0 +1,3 @@
+module JsonResource
+  VERSION = '1.0.0'
+end

data/lib/json_resource.rb

@@ -0,0 +1,9 @@
+require 'bigdecimal'
+require 'json'
+require 'time'
+
+require_relative 'json_resource/version'
+require_relative 'json_resource/errors'
+require_relative 'json_resource/inflections'
+require_relative 'json_resource/refinements'
+require_relative 'json_resource/model'

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: json_resource
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Matthias Grosser
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-12-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  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: 
+email:
+- mtgrosser@gmx.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/json_resource.rb
+- lib/json_resource/errors.rb
+- lib/json_resource/inflections.rb
+- lib/json_resource/model.rb
+- lib/json_resource/refinements.rb
+- lib/json_resource/version.rb
+homepage: https://github.com/mtgrosser/json_resource
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.6.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: Create Ruby objects from JSON data
+test_files: []