jimmy 0.5.1 → 2.0.0

data/lib/jimmy/json/collection.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Jimmy
+  module Json
+    # Common methods for {Hash} and {Array}
+    module Collection
+      include Enumerable
+
+      # Serialize the collection as JSON.
+      def to_json(**opts)
+        JSON.generate as_json, **opts
+      end
+
+      # @see Object#inspect
+      def inspect
+        to_json
+      end
+
+      # Returns true if the collection has no members.
+      # @return [true, false]
+      def empty?
+        @members.empty?
+      end
+
+      # Freeze the collection.
+      # @return [self]
+      def freeze
+        @members.freeze
+        super
+      end
+
+      # Get the member of the collection assigned to the given key.
+      def [](key)
+        @members[cast_key(key)]
+      end
+
+      # @see Hash#dig
+      def dig(key, *rest)
+        obj = self[cast_key(key)]
+        return obj if obj.nil? || rest.empty?
+
+        obj.dig(*rest)
+      end
+
+      # Transform the collection into plain JSON-compatible objects.
+      # @return [Hash, Array]
+      def as_json(id: '', index: {})
+        return index[object_id].as_json(id: id, index: {}) if index[object_id]
+
+        id = Json::URI.new(id)
+        index[object_id] = Jimmy.ref(id)
+
+        pairs = map do |key, value|
+          if value.respond_to? :as_json
+            value = value.as_json(id: id / key, index: index)
+          end
+          [key, value]
+        end
+
+        export_pairs pairs
+      end
+
+      # Removes all members.
+      # @return [self]
+      def clear
+        @members.clear
+        self
+      end
+
+      protected
+
+      def cast_value(value)
+        case value
+        when nil, true, false, Numeric, String, Collection then value
+        when ::Hash then Hash.new(value)
+        when ::Array, Set then Array.new(value)
+        else
+          unless value.respond_to? :as_json
+            raise Error::WrongType, "Incompatible JSON type #{value.class}"
+          end
+
+          value.as_json
+        end
+      end
+    end
+  end
+end
+
+require 'jimmy/json/array'
+require 'jimmy/json/hash'

data/lib/jimmy/json/hash.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require 'jimmy/json/collection'
+require 'jimmy/json/pointer'
+
+module Jimmy
+  module Json
+    # Represents a JSON object that is part of a JSON schema.
+    class Hash
+      include Collection
+
+      # @param [Hash, ::Hash] hash Items to be merged into the new hash.
+      def initialize(hash = {})
+        super()
+        @members = {}
+        merge! hash
+      end
+
+      # Set a value in the hash.
+      # @param [String, Symbol] key The key to set
+      # @param [Object] value The value to set
+      def []=(key, value)
+        key, value = cast(key, value)
+        @members[key] = value
+        sort!
+      end
+
+      # Fetch a value from the hash.
+      # @param [String, Symbol] key Key of the item to fetch
+      # @see ::Hash#fetch
+      # @return [Object]
+      def fetch(key, *args, &block)
+        @members.fetch cast_key(key), *args, &block
+      end
+
+      # Merge values of another hash into this hash.
+      # @param [Hash, ::Hash] hash
+      # @return [self]
+      def merge!(hash)
+        hash.each { |k, v| self[k] = v }
+        self
+      end
+
+      # Iterate over items in the hash. If a block with a single argument is
+      # given, only values will be yielded. Otherwise, keys and values will be
+      # yielded.
+      # @yieldparam [String] key The key of each item.
+      # @yieldparam [Object] member Each item.
+      # @return [Enumerable, self] If no block is given, an {::Enumerable} is
+      #   returned. Otherwise, +self+ is returned.
+      def each(&block)
+        return enum_for :each unless block
+
+        @members.each do |key, value|
+          if block.arity == 1
+            yield value
+          else
+            yield key, value
+          end
+        end
+      end
+
+      # Returns true if the given key is assigned.
+      # @param [String, Symbol] key The key to check.
+      def key?(key)
+        @members.key? cast_key(key)
+      end
+
+      # Get an array of all keys in the hash.
+      # @return [Array<String>]
+      def keys
+        @members.keys
+      end
+
+      # Get the JSON fragment for the given pointer. Returns nil if the pointer
+      # is unmatched.
+      # @param [Jimmy::Json::Pointer, String] json_pointer
+      # @return [Jimmy::Collection, nil]
+      def get_fragment(json_pointer)
+        json_pointer = Pointer.new(json_pointer)
+        return self if json_pointer.empty?
+
+        dig *json_pointer.to_a
+      end
+
+      protected
+
+      def export_pairs(pairs)
+        pairs.to_h
+      end
+
+      def sort!
+        return unless respond_to? :sort_keys_by
+
+        @members = @members.sort do |a, b|
+          sort_keys_by(*a) <=> sort_keys_by(*b)
+        end.to_h
+      end
+
+      def cast(key, value)
+        [
+          cast_key(key),
+          cast_value(value)
+        ]
+      end
+
+      def cast_key(key)
+        key = key.to_s.gsub(/_(.)/) { $1.upcase } if key.is_a? Symbol
+
+        unless key.is_a? String
+          raise Error::WrongType, "Invalid hash key of type #{key.class}"
+        end
+
+        key.strip
+      end
+    end
+  end
+end

data/lib/jimmy/json/pointer.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Jimmy
+  module Json
+    # Represents a JSON pointer per https://tools.ietf.org/html/rfc6901
+    class Pointer
+      ESCAPE   = [%r{[~/]}, { '~' => '~0', '/' => '~1' }.freeze].freeze
+      UNESCAPE = [/~[01]/, ESCAPE.last.invert.freeze].freeze
+
+      # @param [::Array<String>, Pointer, String] path A string starting with
+      #   a +/+ and in JSON pointer format, or an array of parts of the pointer.
+      def initialize(path)
+        @path =
+          case path
+          when ::Array, Pointer then path.to_a
+          when String then parse(path)
+          else
+            raise Error::WrongType, "Unexpected #{path.class}"
+          end
+      end
+
+      # @return [Array<String>] The individual parts of the pointer.
+      def to_a
+        @path.dup
+      end
+
+      # Make a new pointer by appending +other+ to self.
+      # @param [Pointer, Integer, String, ::Array<String>] other The pointer to
+      #   append.
+      # @return [Pointer]
+      def join(other)
+        if other.is_a? Integer
+          return shed(-other) if other.negative?
+
+          other = other.to_s
+        end
+
+        other = '/' + other if other.is_a?(String) && other[0] != '/'
+        self.class.new(@path + self.class.new(other).to_a)
+      end
+
+      alias + join
+
+      # Make a new pointer by removing +count+ parts from the end of self.
+      # @param [Integer] count
+      # @return [Pointer]
+      def shed(count)
+        unless count.is_a?(Integer) && !count.negative?
+          raise Error::BadArgument, 'Expected a non-negative integer'
+        end
+        return dup if count.zero?
+        raise Error::BadArgument, 'Out of range' if count > @path.length
+
+        self.class.new @path[0..(-count - 1)]
+      end
+
+      alias - shed
+
+      # Get the pointer as a string, either blank, or starting with a +/+.
+      # @return [String]
+      def to_s
+        return '' if @path.empty?
+
+        @path.map { |str| '/' + str.gsub(*ESCAPE) }.join
+      end
+
+      # Returns true if +other+ has the same string value as self.
+      # @param [Pointer] other
+      # @return [true, false]
+      def ==(other)
+        other.is_a?(self.class) && @path == other.to_a
+      end
+
+      # @see ::Object#inspect
+      def inspect
+        "#<#{self.class} #{self}>"
+      end
+
+      # Returns true if the pointer has no parts.
+      # @return [true, false]
+      def empty?
+        @path.empty?
+      end
+
+      # Remove the last part of the pointer.
+      # @return [String] The part that was removed.
+      def shift
+        @path.shift
+      end
+
+      # Return a new pointer with just the part of self that is not included
+      # in +other+.
+      #
+      #   Jimmy::Json::Pointer.new('/foo/bar/baz').remove_prefix('/foo')
+      #   # => #<Jimmy::Json::Pointer /bar/baz>
+      # @param [String, Pointer, ::Array<String>] other
+      def remove_prefix(other)
+        tail = dup
+        Pointer.new(other).to_a.each do |segment|
+          return nil unless tail.shift == segment
+        end
+        tail
+      end
+
+      private
+
+      def parse(path)
+        return [] if path == ''
+        return [''] if path == '/'
+
+        unless path[0] == '/'
+          raise Error::BadArgument, 'JSON pointers should start with /'
+        end
+
+        path[1..].split('/').map { |str| str.gsub *UNESCAPE }
+      end
+    end
+  end
+end

data/lib/jimmy/json/uri.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require 'jimmy/json/pointer'
+
+module Jimmy
+  module Json
+    # Wraps the URI class to provide additional functionality.
+    class URI
+      # Take from the back of URI::RFC3986_Parser::RFC3986_URI
+      FRAGMENT_ESCAPING = %r{[^!$&-.0-;=@-Z_a-z~/?]}.freeze
+
+      # @param [String, URI, ::URI] uri
+      # @param [true, false] container If true, a +/+ will be appended to the
+      #   given +uri+ if it was omitted. Otherwise, a +#+ will be appended.
+      def initialize(uri, container: false)
+        @uri = ::URI.parse(uri.to_s)
+        if container
+          @uri.path += '/' unless @uri.path.end_with? '/'
+        else
+          @uri.fragment ||= ''
+        end
+      end
+
+      # Get the fragment of this URI as a {Pointer}.
+      # @return [Pointer]
+      def pointer
+        Pointer.new ::URI.decode_www_form_component(fragment)
+      end
+
+      # Set the fragment of this URI using a {Pointer}.
+      # @param [String, Pointer, ::Array<String>] value
+      def pointer=(value)
+        # Loosely based on URI.encode_www_form_component
+        fragment = Pointer.new(value).to_s.dup
+        fragment.force_encoding Encoding::ASCII_8BIT
+        fragment.gsub!(FRAGMENT_ESCAPING) { |chr| '%%%02X' % chr.ord }
+        fragment.force_encoding Encoding::US_ASCII
+        self.fragment = fragment
+      end
+
+      undef to_s
+
+      # @see ::Object#inspect
+      def inspect
+        "#<#{self.class} #{self}>"
+      end
+
+      # Returns true if +other+ represents the same URI as self.
+      # @param [URI] other
+      def ==(other)
+        other.is_a?(self.class) && other.to_s == to_s
+      end
+
+      alias eql? ==
+
+      # @see ::URI#join
+      def join(other)
+        self.class.new(@uri + other.to_s)
+      end
+
+      alias + join
+
+      # Return a new URI with the given pointer appended.
+      # @param [Pointer, String, ::Array<String>] other
+      def /(other)
+        dup.tap { |uri| uri.pointer += other }
+      end
+
+      # @see ::Object#dup
+      # @return [URI]
+      def dup
+        self.class.new self
+      end
+
+      # @api private
+      def hash
+        [self.class, @uri].hash
+      end
+
+      # Get this URI as a string. If +id+ is given, the string will be this URI
+      # relative to the given URI.
+      #
+      #   uri = Jimmy::Json::URI.new('http://example.com/foo/bar#')
+      #   uri.as_json(id: 'http://example.com/foo/')
+      #   # => "bar#"
+      # @param [URI, ::URI, String] id If not nil, the URI will be represented
+      #   relative to +id+.
+      def as_json(id: nil, **)
+        return to_s unless id
+
+        id = URI.new(id)
+        id.absolute? ? id.route_to(id + self).to_s : to_s
+      end
+
+      # @see URI::Generic#route_to
+      # @param [Json::URI, URI, String] other
+      # @return [Json::URI]
+      def route_to(other)
+        self.class.new(@uri.route_to other.to_s)
+      end
+
+      # @!method fragment
+      #   @see URI::Generic#fragment
+      #   @return [String]
+      # @!method path
+      #   @see URI::Generic#path
+      #   @return [String]
+      # @!method host
+      #   @see URI::Generic#host
+      #   @return [String]
+      # @!method relative?
+      #   @see URI::Generic#relative?
+      #   @return [true, false]
+      # @!method absolute?
+      #   @see URI::Generic#absolute?
+      #   @return [true, false]
+      # @!method path=(value)
+      #   @see URI::Generic#path=
+      #   @param [String] value
+      # @!method fragment=(value)
+      #   @see URI::Generic#fragment=
+      #   @param [String] value
+
+      # @api private
+      def respond_to_missing?(name, *)
+        @uri.respond_to? name or super
+      end
+
+      # @api private
+      def method_missing(symbol, *args, &block)
+        if @uri.respond_to? symbol
+          self.class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{symbol}(*args, &block)
+              @uri.__send__ :#{symbol}, *args, &block
+            end
+          RUBY
+
+          return __send__ symbol, *args, &block
+        end
+        super
+      end
+    end
+  end
+end