opushon 0.2.2 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 24fefd1822417befed8d3b8678ccda2e3f05eb7462617cdfd9bcf1d63302cded
-  data.tar.gz: 057236242425accea1ed1696b370b42cfbeedcf4cfce124734e3f6f0cac75552
+  metadata.gz: 8ada98b18f896449e5d7218ca1dcdfef49a4e107fab06800ed65e5af0c7f4ad3
+  data.tar.gz: 8ed7fdc8fa62f6198c0d3109b1d143e10dc4f115adb907b7dbdd06b7525a2621
 SHA512:
-  metadata.gz: 046e40f75c5a8bee027928d7b2af0da0fe00f6bd9d8d8a7732a959e643dbb93a373f7de43c479c4cb98e054eba7cd685a54796f1b55e628f6ab914c7f64f5d38
-  data.tar.gz: 1d95889786e06951548c92680e7a8795d97225839ba6a52aeb89723ac1bf0f8b6fb04fe82f022d1ac293783df6599483323f8b635c46032c20ab7d4503f07291
+  metadata.gz: 4400ebd14bb0079c7d0f67569fe444e042e4f741b26490030b7f8b72561e35e33e16f41a5d6570cbea6d62b2b485d74eb8e904b68beb1435900541d1a522bed8
+  data.tar.gz: 2862fc3e80b1c02a046306fda88b75ad1efb5c4738591a66520acb56f054a16d1d9576bd063026ad44f46fef07f0fe2e1e74b98f90893faaa11a6f06a9e52525

data/VERSION.semver

@@ -1 +1 @@
-0.2.2
+0.2.3

data/lib/opushon/body.rb

@@ -6,32 +6,70 @@ module Opushon
   # The body structure is a hash where each key is a HTTP method and each value
   # is a sub-hash, called an option object.
   class Body
-    include Virtus.model(strict: true)
+    def self.load(hash)
+      raise ArgumentError, "hash #{hash.inspect}" unless hash.is_a?(Hash)
 
-    attribute :GET,     Option, required: false
-    attribute :PATCH,   Option, required: false
-    attribute :PUT,     Option, required: false
-    attribute :POST,    Option, required: false
-    attribute :DELETE,  Option, required: false
+      get     = hash.fetch('GET',     nil)
+      patch   = hash.fetch('PATCH',   nil)
+      put     = hash.fetch('PUT',     nil)
+      post    = hash.fetch('POST',    nil)
+      delete  = hash.fetch('DELETE',  nil)
+
+      hash = {
+        get:    get,
+        patch:  patch,
+        put:    put,
+        post:   post,
+        delete: delete
+      }.compact
+
+      new(**hash)
+    end
+
+    attr_reader :get, :patch, :put, :post, :delete
+
+    def initialize(get: nil, patch: nil, put: nil, post: nil, delete: nil)
+      unless get.nil?
+        raise ArgumentError, "get #{get.inspect}" unless get.is_a?(Hash)
+      end
+
+      unless patch.nil?
+        raise ArgumentError, "patch #{patch.inspect}" unless patch.is_a?(Hash)
+      end
+
+      unless put.nil?
+        raise ArgumentError, "put #{put.inspect}" unless put.is_a?(Hash)
+      end
+
+      unless post.nil?
+        raise ArgumentError, "post #{post.inspect}" unless post.is_a?(Hash)
+      end
+
+      unless delete.nil?
+        raise ArgumentError, "delete #{delete.inspect}" unless delete.is_a?(Hash)
+      end
+
+      @get    = Option.load(get)    unless get.nil?
+      @patch  = Option.load(patch)  unless patch.nil?
+      @put    = Option.load(put)    unless put.nil?
+      @post   = Option.load(post)   unless post.nil?
+      @delete = Option.load(delete) unless delete.nil?
+    end
 
     def to_h
       {
-        GET:    maybe_to_h(@GET),
-        PATCH:  maybe_to_h(@PATCH),
-        PUT:    maybe_to_h(@PUT),
-        POST:   maybe_to_h(@POST),
-        DELETE: maybe_to_h(@DELETE)
-      }
+        GET:    maybe_to_h(get),
+        PATCH:  maybe_to_h(patch),
+        PUT:    maybe_to_h(put),
+        POST:   maybe_to_h(post),
+        DELETE: maybe_to_h(delete)
+      }.compact
     end
 
     private
 
     def maybe_to_h(object)
-      if object.nil?
-        nil
-      else
-        object.to_h
-      end
+      object&.to_h
     end
   end
 end

data/lib/opushon/option.rb

@@ -5,19 +5,44 @@ require_relative 'response'
 
 module Opushon
   class Option
-    include Virtus.model(strict: true)
+    def self.load(hash)
+      raise ArgumentError, "hash #{hash.inspect}" unless hash.is_a?(Hash)
 
-    attribute :title,       String,   default: '',            required: true
-    attribute :description, String,   default: '',            required: true
-    attribute :request,     Request,  default: Request.new,   required: true
-    attribute :response,    Response, default: Response.new,  required: true
+      title       = hash.fetch('title',       nil)
+      description = hash.fetch('description', nil)
+      request     = hash.fetch('request',     nil)
+      response    = hash.fetch('response',    nil)
+
+      hash = {
+        title:        title,
+        description:  description,
+        request:      request,
+        response:     response
+      }.compact
+
+      new(**hash)
+    end
+
+    attr_reader :title, :description, :request, :response
+
+    def initialize(title: '', description: '', request: {}, response: {})
+      raise ArgumentError, "title #{title.inspect}"             unless title.is_a?(String)
+      raise ArgumentError, "description #{description.inspect}" unless description.is_a?(String)
+      raise ArgumentError, "request #{request.inspect}"         unless request.is_a?(Hash)
+      raise ArgumentError, "response #{response.inspect}"       unless response.is_a?(Hash)
+
+      @title        = title
+      @description  = description
+      @request      = Request.load(request)
+      @response     = Response.load(response)
+    end
 
     def to_h
       {
-        title:        @title,
-        description:  @description,
-        request:      @request.to_h,
-        response:     @response.to_h
+        title:        title,
+        description:  description,
+        request:      request.to_h,
+        response:     response.to_h
       }
     end
   end

data/lib/opushon/parameter.rb

@@ -6,42 +6,109 @@ module Opushon
   # The content of headers, query string and body params MUST be described with
   #   the keys below. When a key is missing, its default value is assigned.
   class Parameter
-    include Virtus.model(strict: true)
-
-    attribute :title,             String,                 default: '',        required: true
-    attribute :description,       String,                 default: '',        required: true
-    attribute :type,              String,                 default: 'string',  required: true
-    attribute :nullifiable,       Boolean,                default: true,      required: true
-    attribute :restricted_values, Array[RestrictedValue],                     required: false
-    attribute :example,           BasicObject,                                required: false
-    attribute :minlen,            Integer,                                    required: false
-    attribute :maxlen,            Integer,                                    required: false
-    attribute :pattern,           Regexp,                                     required: false
-    attribute :min,               Integer,                                    required: false
-    attribute :max,               Integer,                                    required: false
+    def self.load(hash)
+      raise ArgumentError, "hash #{hash.inspect}" unless hash.is_a?(Hash)
+
+      title             = hash.fetch('title',             nil)
+      description       = hash.fetch('description',       nil)
+      type              = hash.fetch('type',              nil)
+      nullifiable       = hash.fetch('nullifiable',       nil)
+      restricted_values = hash.fetch('restricted_values', nil)
+      example           = hash.fetch('example',           nil)
+      minlen            = hash.fetch('minlen',            nil)
+      maxlen            = hash.fetch('maxlen',            nil)
+      pattern           = hash.fetch('pattern',           nil)
+      min               = hash.fetch('min',               nil)
+      max               = hash.fetch('max',               nil)
+
+      hash = {
+        title:              title,
+        description:        description,
+        type:               type,
+        nullifiable:        nullifiable,
+        restricted_values:  restricted_values,
+        example:            example,
+        minlen:             minlen,
+        maxlen:             maxlen,
+        pattern:            pattern,
+        min:                min,
+        max:                max
+      }.compact
+
+      new(**hash)
+    end
+
+    attr_reader :title, :description, :type, :nullifiable, :restricted_values, :example, :minlen, :maxlen, :pattern, :min, :max
+
+    def initialize(title: '', description: '', type: 'string', nullifiable: true, restricted_values: nil, example: nil, minlen: nil, maxlen: nil, pattern: nil, min: nil, max: nil)
+      raise ArgumentError, "title #{title.inspect}"             unless title.is_a?(String)
+      raise ArgumentError, "description #{description.inspect}" unless description.is_a?(String)
+      raise ArgumentError, "type #{type.inspect}"               unless type.is_a?(String)
+      raise ArgumentError, "nullifiable #{nullifiable.inspect}" unless [false, true].include?(nullifiable)
+
+      unless restricted_values.nil?
+        raise ArgumentError, "restricted_values #{restricted_values.inspect}" unless restricted_values.is_a?(Array)
+      end
+
+      unless example.nil?
+        raise ArgumentError, "example #{example.inspect}" unless example.is_a?(BasicObject)
+      end
+
+      unless minlen.nil?
+        raise ArgumentError, "minlen #{minlen.inspect}" unless minlen.is_a?(Integer)
+      end
+
+      unless maxlen.nil?
+        raise ArgumentError, "maxlen #{maxlen.inspect}" unless maxlen.is_a?(Integer)
+      end
+
+      unless pattern.nil?
+        raise ArgumentError, "pattern #{pattern.inspect}" unless pattern.is_a?(String)
+      end
+
+      unless min.nil?
+        raise ArgumentError, "min #{min.inspect}" unless min.is_a?(Integer)
+      end
+
+      unless max.nil?
+        raise ArgumentError, "max #{max.inspect}" unless max.is_a?(Integer)
+      end
+
+      @title              = title
+      @description        = description
+      @type               = type
+      @nullifiable        = nullifiable
+      @restricted_values  = restricted_values.map { |restricted_value| RestrictedValue.load(restricted_value) } unless restricted_values.nil?
+      @example            = example
+      @minlen             = minlen
+      @maxlen             = maxlen
+      @pattern            = Regexp.new(pattern) unless pattern.nil?
+      @min                = min
+      @max                = max
+    end
 
     def to_h
       h = {
-        title:              @title,
-        description:        @description,
-        type:               @type,
-        nullifiable:        @nullifiable,
-        restricted_values:  maybe_to_a(@restricted_values),
-        example:            @example
+        title:              title,
+        description:        description,
+        type:               type,
+        nullifiable:        nullifiable,
+        restricted_values:  maybe_to_a_of_h(restricted_values),
+        example:            example
       }
 
-      if @type.eql?('string')
-        h.update(
-          minlen:   @minlen,
-          maxlen:   @maxlen,
-          pattern:  @pattern&.to_s
+      if type.eql?('string')
+        return h.merge(
+          minlen:   minlen,
+          maxlen:   maxlen,
+          pattern:  pattern&.to_s
         )
       end
 
-      if @type.eql?('number')
-        h.update(
-          min: @min,
-          max: @max
+      if type.eql?('number')
+        return h.merge(
+          min: min,
+          max: max
         )
       end
 
@@ -50,7 +117,7 @@ module Opushon
 
     private
 
-    def maybe_to_a(object)
+    def maybe_to_a_of_h(object)
       return if object.nil?
 
       object.map(&:to_h)

data/lib/opushon/request.rb

@@ -4,17 +4,39 @@ require_relative 'parameter'
 
 module Opushon
   class Request
-    include Virtus.model(strict: true)
+    def self.load(hash)
+      raise ArgumentError, "hash #{hash.inspect}" unless hash.is_a?(Hash)
 
-    attribute :headers,       Hash[Symbol => Parameter], default: {}, required: true
-    attribute :query_string,  Hash[Symbol => Parameter], default: {}, required: true
-    attribute :body,          Hash[Symbol => Parameter], default: {}, required: true
+      headers       = hash.fetch('headers',       nil)
+      query_string  = hash.fetch('query_string',  nil)
+      body          = hash.fetch('body',          nil)
+
+      hash = {
+        headers:      headers,
+        query_string: query_string,
+        body:         body
+      }.compact
+
+      new(**hash)
+    end
+
+    attr_reader :headers, :query_string, :body
+
+    def initialize(headers: {}, query_string: {}, body: {})
+      raise ArgumentError, "headers #{headers.inspect}"           unless headers.is_a?(Hash)
+      raise ArgumentError, "query_string #{query_string.inspect}" unless query_string.is_a?(Hash)
+      raise ArgumentError, "body #{body.inspect}"                 unless body.is_a?(Hash)
+
+      @headers      = headers.map       { |k, v| [k.to_sym, Parameter.load(v)] }.to_h
+      @query_string = query_string.map  { |k, v| [k.to_sym, Parameter.load(v)] }.to_h
+      @body         = body.map          { |k, v| [k.to_sym, Parameter.load(v)] }.to_h
+    end
 
     def to_h
       {
-        headers:      @headers.map       { |k, v| [k, v.to_h] }.to_h,
-        query_string: @query_string.map  { |k, v| [k, v.to_h] }.to_h,
-        body:         @body.map          { |k, v| [k, v.to_h] }.to_h
+        headers:      headers.map       { |k, v| [k, v.to_h] }.to_h,
+        query_string: query_string.map  { |k, v| [k, v.to_h] }.to_h,
+        body:         body.map          { |k, v| [k, v.to_h] }.to_h
       }
     end
   end

data/lib/opushon/response.rb

@@ -4,15 +4,34 @@ require_relative 'parameter'
 
 module Opushon
   class Response
-    include Virtus.model(strict: true)
+    def self.load(hash)
+      raise ArgumentError, "hash #{hash.inspect}" unless hash.is_a?(Hash)
 
-    attribute :headers, Hash[Symbol => Parameter], default: {}, required: true
-    attribute :body,    Hash[Symbol => Parameter], default: {}, required: true
+      headers = hash.fetch('headers', nil)
+      body    = hash.fetch('body',    nil)
+
+      hash = {
+        headers:  headers,
+        body:     body
+      }.compact
+
+      new(**hash)
+    end
+
+    attr_reader :headers, :body
+
+    def initialize(headers: {}, body: {})
+      raise ArgumentError, "headers #{headers.inspect}" unless headers.is_a?(Hash)
+      raise ArgumentError, "body #{body.inspect}"       unless body.is_a?(Hash)
+
+      @headers  = headers.map { |k, v| [k.to_sym, Parameter.load(v)] }.to_h
+      @body     = body.map    { |k, v| [k.to_sym, Parameter.load(v)] }.to_h
+    end
 
     def to_h
       {
-        headers:  @headers.map { |k, v| [k, v.to_h] }.to_h,
-        body:     @body.map    { |k, v| [k, v.to_h] }.to_h
+        headers:  headers.map { |k, v| [k, v.to_h] }.to_h,
+        body:     body.map    { |k, v| [k, v.to_h] }.to_h
       }
     end
   end

data/lib/opushon/restricted_value.rb

@@ -4,17 +4,39 @@ module Opushon
   # If present, the value of restricted_values is an array where each item
   #   contains a hash.
   class RestrictedValue
-    include Virtus.model(strict: true)
+    def self.load(hash)
+      raise ArgumentError, "hash #{hash.inspect}" unless hash.is_a?(Hash)
 
-    attribute :title,       String,       default: '',  required: true
-    attribute :description, String,       default: '',  required: true
-    attribute :value,       BasicObject,                required: true
+      title       = hash.fetch('title',       nil)
+      description = hash.fetch('description', nil)
+      value       = hash.fetch('value',       nil)
+
+      hash = {
+        title:        title,
+        description:  description,
+        value:        value
+      }.compact
+
+      new(**hash)
+    end
+
+    attr_reader :title, :description, :value
+
+    def initialize(title: '', description: '', value:)
+      raise ArgumentError, "title #{title.inspect}"             unless title.is_a?(String)
+      raise ArgumentError, "description #{description.inspect}" unless description.is_a?(String)
+      raise ArgumentError, "value #{value.inspect}"             unless value.is_a?(BasicObject)
+
+      @title        = title
+      @description  = description
+      @value        = value
+    end
 
     def to_h
       {
-        title:        @title,
-        description:  @description,
-        value:        @value
+        title:        title,
+        description:  description,
+        value:        value
       }
     end
   end

data/lib/opushon.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'virtus'
 require 'json'
 
 # Namespace for the Opushon library.
@@ -20,7 +19,7 @@ module Opushon
   # @return [Body] the Ruby data structure
   def self.load(opushon_string)
     opushon_hash = JSON.parse(opushon_string)
-    Body.new(opushon_hash)
+    Body.load(opushon_hash)
   end
 
   # Dump Ruby object to a Opushon string.

data/opushon.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |spec|
   spec.email         = ['contact@cyril.email']
 
   spec.summary       = 'A HTTP Opushon parser and emitter'
-  spec.description   = 'An Opushon\'s body parser and emitter.'
+  spec.description   = "An Opushon's body parser and emitter."
   spec.homepage      = 'https://github.com/cyril/opushon.rb'
   spec.license       = 'MIT'
 
@@ -16,8 +16,6 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'virtus',                 '~> 1.0.5'
-
   spec.add_development_dependency 'bundler',    '~> 2.0'
   spec.add_development_dependency 'rake',       '~> 12.3'
   spec.add_development_dependency 'simplecov',  '~> 0.17'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: opushon
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.2.3
 platform: ruby
 authors:
 - Cyril Kato
@@ -10,20 +10,6 @@ bindir: bin
 cert_chain: []
 date: 2019-08-26 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: virtus
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.0.5
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 1.0.5
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement