toc_doc 1.6.0 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50818c97b021143ebf2d502a867fb5f20a90299a822ec800b7d02ae4d20999eb
-  data.tar.gz: d4ef919a143957c2685fba1f28675786743922387b0703c521a6d5c0b9ab76c3
+  metadata.gz: a839823e2a82c7dd112617d6b969f275d7d88826e58f53b9ec9a5265701f277e
+  data.tar.gz: 6a3c3d24b598f0d2f85b2c0bd5f8faad939eeba847578692b072f0070fb5d3bb
 SHA512:
-  metadata.gz: 9aa3dd68984a7cec38789a3a718db4f7c9db9a0335ae8e47744f24990dccb73de12e41903aee8806e06f579288769c13a5b9f82327a031dd3c2052d096ae33e5
-  data.tar.gz: 10725265d2117c4d93720c89f5c06360ea567377c6d21f9a848e26151de7039876ac9a7b1da936801f0eaf9a7b8141689e8389b5a2917f3d550a01847aa52767
+  metadata.gz: 2580cf022a39c4f8e8d73c3b795927bf249ed3d4c9e6b36d051d326680d071ec4569e6f8da07143270584c7f65519f9df9c9efe824c7b623959d7be73f10f27f
+  data.tar.gz: 19ab224e5729cb04789e7739d1c0a6d9de16b02b2e32d850c1bc6fe3024c58b2c01d4ac9c1b7ffbfed45fb2d7e3498c537d169f9c77733b54d01da009b692047

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 ## [Unreleased]
 
+## [1.7.0] - 2026-04-04
+
+### Added
+
+- **`TocDoc::Middleware::Logging`** — new Faraday middleware that logs every outgoing request URL and the response status; plugged in automatically between the retry and raise-error layers; enabled via the new `logger` config key (accepts any Logger-compatible object; `nil` disables logging)
+- **`logger` config key** — module-level and per-client option; also available as a `TocDoc::Default::LOGGER` constant (defaults to `nil`); each client instance carries its own logger, so multiple clients can log to different destinations simultaneously
+- **`TocDoc::Resource#attribute_names`** — instance method returning the sorted list of attribute keys present on a resource instance
+- **`TocDoc::Resource` singleton method definition on first access** — reader methods are now defined as true singleton methods on the instance the first time an attribute is accessed, eliminating repeated `respond_to?` / `method_missing` dispatch on subsequent calls
+
+### Changed
+
+- **`TocDoc::Resource#to_h`** — now performs a deep conversion: nested `Resource` objects and arrays of `Resource` objects are recursively converted; previously returned a shallow hash with raw attribute values
+- **`TocDoc::Resource#to_json`** — delegates to the new deep `to_h`, so JSON output is fully recursive
+- **`TocDoc::BookingInfo#to_h`** and **`#to_json`** — override `Resource`'s implementation to include all typed sub-objects (`profile`, `specialities`, `visit_motives`, `agendas`, `places`, `practitioners`) as deeply converted hashes
+- **`TocDoc::BookingInfo#agendas`** — visit-motive resolution changed from O(n*m) nested iteration to O(n+m) hash lookup; no change to the public interface
+- **`TocDoc::Availability::Collection#filtered_entries`** — result is now memoized; cache is invalidated automatically when `#merge_page!` appends a new page, preventing redundant filtering on repeated `#each` / `#to_a` calls
+- **`#inspect`** for `TocDoc::Availability`, `TocDoc::Place`, `TocDoc::Speciality`, and `TocDoc::Profile::Organization`** — `main_attrs` declared on each class so inspect output stays concise; `TocDoc::Profile` and `TocDoc::Resource` inspect also improved
+
 ## [1.6.0] - 2026-03-30
 
 ### Added

data/README.md

@@ -140,11 +140,12 @@ client.get('/availabilities.json', query: { visit_motive_ids: '123', agenda_ids:
 | Option | Default | Description |
 |---|---|---|
 | `api_endpoint` | `https://www.doctolib.fr` | Base URL. Change to `.de` / `.it` for other countries. |
-| `user_agent` | `TocDoc Ruby Gem 1.6.0` | `User-Agent` header sent with every request. |
+| `user_agent` | `TocDoc Ruby Gem 1.7.0` | `User-Agent` header sent with every request. |
 | `default_media_type` | `application/json` | `Accept` and `Content-Type` headers. |
 | `per_page` | `15` | Default number of availability dates per request (capped at `15`). Emits a warning if the value exceeds the cap. |
 | `connect_timeout` | `5` | TCP connect timeout in seconds, passed to Faraday as `open_timeout`. Override via `TOCDOC_CONNECT_TIMEOUT`. |
 | `read_timeout` | `10` | Response read timeout in seconds, passed to Faraday as `timeout`. Override via `TOCDOC_READ_TIMEOUT`. |
+| `logger` | `nil` | Logger-compatible object (e.g. `Logger.new($stdout)`). When set, `TocDoc::Middleware::Logging` logs each request URL and response status. `nil` disables logging. |
 | `middleware` | Retry + RaiseError + JSON + adapter | Full Faraday middleware stack. Override to customise completely. |
 | `connection_options` | `{}` | Options passed directly to `Faraday.new`. |
 

data/TODO.md

@@ -3,14 +3,6 @@
 [POTENTIAL_ENDPOINTS][POTENTIAL_ENDPOINTS.md]
 
 
-## 1.7 — DevX
-
-- [ ] Logging middleware (`:logger` config key)
-- [ ] Resource: `define_singleton_method` on first access + `#attribute_names`
-- [ ] Deep `to_h` and `to_json` on `Resource` and `BookingInfo`
-- [ ] `Collection#filtered_entries` memoization
-- [ ] `BookingInfo#agendas` O(n*m) → hash lookup
-
 ## 1.8 — HTTP Layer Robustness
 
 - [ ] Configurable availability pagination depth + `Collection#more?` / `#fetch_next_page`
@@ -41,6 +33,15 @@
 
 # DONE & RELEASED
 
+## 1.7
+
+- [x] Logging middleware (`:logger` config key)
+- [x] Resource: `define_singleton_method` on first access + `#attribute_names`
+- [x] Deep `to_h` and `to_json` on `Resource` and `BookingInfo`
+- [x] `Collection#filtered_entries` memoization
+- [x] `BookingInfo#agendas` O(n*m) → hash lookup
+- [x] Improve `#inspect` for `Availability`, `Place`, `Speciality`, `Profile::Organization`
+
 ## 1.6
 
 ### Default connection timeouts

data/lib/toc_doc/core/configurable.rb

@@ -31,6 +31,7 @@ module TocDoc
       per_page
       connect_timeout
       read_timeout
+      logger
     ].freeze
 
     # @!attribute [rw] api_endpoint
@@ -47,6 +48,8 @@ module TocDoc
     #   @return [Integer] TCP connect timeout in seconds
     # @!attribute [rw] read_timeout
     #   @return [Integer] read (response) timeout in seconds
+    # @!attribute [rw] logger
+    #   @return [Logger, :stdout, nil] logger for HTTP request logging; +nil+ disables logging
     attr_accessor(*VALID_CONFIG_KEYS)
 
     # Set the number of results per page, clamped to

data/lib/toc_doc/core/connection.rb

@@ -92,11 +92,27 @@ module TocDoc
     # @return [Hash] merged Faraday connection options
     def faraday_options
       opts = connection_options.dup
-      opts[:builder] = middleware if middleware
+      opts[:builder] = effective_middleware
       opts[:request] = { timeout: read_timeout, open_timeout: connect_timeout }
       opts
     end
 
+    # Returns the appropriate middleware stack for this client.
+    #
+    # When a logger is configured, builds a fresh stack with the logger injected
+    # so that the shared memoized default stack is never mutated.
+    # Falls back to the memoized {TocDoc::Default.middleware} when no logger is
+    # set.
+    #
+    # @return [Faraday::RackBuilder]
+    def effective_middleware
+      if logger
+        TocDoc::Default.build_middleware(logger: logger)
+      else
+        middleware
+      end
+    end
+
     # Sets default HTTP headers on a Faraday connection.
     #
     # @param conn [Faraday::Connection]

data/lib/toc_doc/core/default.rb

@@ -4,6 +4,7 @@ require 'faraday'
 require 'faraday/retry'
 
 require 'toc_doc/http/middleware/raise_error'
+require 'toc_doc/http/middleware/logging'
 
 module TocDoc
   # Provides sensible default values for every configurable option.
@@ -43,16 +44,9 @@ module TocDoc
       #
       # @return [Hash{Symbol => Object}]
       def options
-        {
-          api_endpoint: api_endpoint,
-          user_agent: user_agent,
-          default_media_type: default_media_type,
-          per_page: per_page,
-          middleware: middleware,
-          connection_options: connection_options,
-          connect_timeout: connect_timeout,
-          read_timeout: read_timeout
-        }
+        { api_endpoint:, user_agent:, default_media_type:, per_page:,
+          middleware:, connection_options:, connect_timeout:, read_timeout:,
+          logger: nil }
       end
 
       # The base API endpoint URL.
@@ -97,7 +91,7 @@ module TocDoc
         PER_PAGE
       end
 
-      # The default Faraday middleware stack.
+      # The default (memoized) Faraday middleware stack, built without a logger.
       #
       # Stack order (outermost first): RaiseError, retry, JSON parsing, adapter.
       # RaiseError is outermost so it wraps retry and maps the final response or
@@ -108,6 +102,29 @@ module TocDoc
         @middleware ||= build_middleware
       end
 
+      # Builds a Faraday middleware stack, optionally injecting a logger.
+      #
+      # When +logger+ is non-nil, {TocDoc::Middleware::Logging} is inserted
+      # between {TocDoc::Middleware::RaiseError} and the retry middleware so
+      # each logical request is logged exactly once after all retries are
+      # exhausted.
+      #
+      # Accepts +:stdout+ as a shorthand that writes to +$stdout+.
+      #
+      # @param logger [Logger, :stdout, nil] the logger to inject; +nil+ omits
+      #   the logging middleware entirely
+      # @return [Faraday::RackBuilder]
+      def build_middleware(logger: nil)
+        resolved = resolve_logger(logger)
+        Faraday::RackBuilder.new do |builder|
+          builder.use TocDoc::Middleware::RaiseError
+          builder.use TocDoc::Middleware::Logging, logger: resolved if resolved
+          builder.request :retry, retry_options
+          builder.response :json, content_type: /\bjson$/
+          builder.adapter Faraday.default_adapter
+        end
+      end
+
       # Default Faraday connection options (empty by default).
       #
       # @return [Hash]
@@ -153,12 +170,15 @@ module TocDoc
 
       private
 
-      def build_middleware
-        Faraday::RackBuilder.new do |builder|
-          builder.use TocDoc::Middleware::RaiseError
-          builder.request :retry, retry_options
-          builder.response :json, content_type: /\bjson$/
-          builder.adapter Faraday.default_adapter
+      def resolve_logger(logger)
+        case logger
+        when :stdout
+          require 'logger'
+          Logger.new($stdout, progname: 'TocDoc')
+        when nil, false
+          nil
+        else
+          logger
         end
       end
 

data/lib/toc_doc/core/version.rb

@@ -4,5 +4,5 @@ module TocDoc
   # The current version of the TocDoc gem.
   #
   # @return [String]
-  VERSION = '1.6.0'
+  VERSION = '1.7.0'
 end

data/lib/toc_doc/http/middleware/logging.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require 'faraday'
+
+module TocDoc
+  module Middleware
+    # Faraday middleware that logs the outcome of every HTTP request.
+    #
+    # Placed between {RaiseError} (outermost) and the retry middleware so that
+    # each logical request is logged exactly once — after all retry attempts have
+    # been exhausted — rather than once per attempt.
+    #
+    # Stack order (outermost first):
+    #   RaiseError > Logging > retry > JSON parse > adapter
+    #
+    # Log format:
+    #   TocDoc: GET /path.json -> 200 (42ms)          # success  → logger.info
+    #   TocDoc: GET /path.json -> error: Msg (42ms)   # failure  → logger.warn
+    #
+    # When no logger is provided the middleware is a no-op.
+    #
+    # @example Attach a custom logger
+    #   TocDoc.configure { |c| c.logger = Logger.new($stdout) }
+    #
+    # @example Use the :stdout shorthand
+    #   TocDoc.configure { |c| c.logger = :stdout }
+    class Logging < Faraday::Middleware
+      # @param app [#call] the next middleware in the stack
+      # @param logger [Logger, nil] the logger to write to; +nil+ disables logging
+      def initialize(app, logger: nil)
+        super(app)
+        @logger = logger
+      end
+
+      # Calls the next middleware, measures elapsed time, and logs the outcome.
+      #
+      # @param env [Faraday::Env] the Faraday request environment
+      # @return [Faraday::Response] the response on success
+      # @raise [StandardError] re-raises any exception after logging it
+      def call(env)
+        start    = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        response = @app.call(env)
+        duration = duration_ms(start)
+        log_request(env, response.status, duration)
+        response
+      rescue StandardError => e
+        duration = duration_ms(start)
+        log_error(env, e, duration)
+        raise
+      end
+
+      private
+
+      # @param start [Float] monotonic clock time at request start
+      # @return [Integer] elapsed time in milliseconds
+      def duration_ms(start)
+        ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start) * 1000).round
+      end
+
+      # Logs a successful HTTP response at +info+ level.
+      #
+      # @param env [Faraday::Env] the Faraday request environment
+      # @param status [Integer] the HTTP response status code
+      # @param duration [Integer] elapsed time in milliseconds
+      # @return [void]
+      def log_request(env, status, duration)
+        return unless @logger
+
+        @logger.info("TocDoc: #{env.method.to_s.upcase} #{env.url.path} -> #{status} (#{duration}ms)")
+      end
+
+      # Logs a failed request at +warn+ level.
+      #
+      # @param env [Faraday::Env] the Faraday request environment
+      # @param error [StandardError] the exception that was raised
+      # @param duration [Integer] elapsed time in milliseconds
+      # @return [void]
+      def log_error(env, error, duration)
+        return unless @logger
+
+        @logger.warn("TocDoc: #{env.method.to_s.upcase} #{env.url.path} -> error: #{error.message} (#{duration}ms)")
+      end
+    end
+  end
+end

data/lib/toc_doc/models/availability/collection.rb

@@ -88,15 +88,16 @@ module TocDoc
       def merge_page!(page_data)
         @data['availabilities'] = @data.fetch('availabilities', []) + page_data.fetch('availabilities', [])
         @data['total']          = @data.fetch('total', 0) + page_data.fetch('total', 0)
+        @filtered_entries = nil
         self
       end
 
       private
 
       def filtered_entries
-        Array(@data['availabilities'])
-          .select { |entry| Array(entry['slots']).any? }
-          .map { |entry| TocDoc::Availability.new(entry) }
+        @filtered_entries ||= Array(@data['availabilities'])
+                              .select { |entry| Array(entry['slots']).any? }
+                              .map { |entry| TocDoc::Availability.new(entry) }
       end
     end
   end

data/lib/toc_doc/models/availability.rb

@@ -9,13 +9,19 @@ module TocDoc
   # @example
   #   avail = TocDoc::Availability.new('date' => '2026-02-28', 'slots' => ['2026-02-28T10:00:00.000+01:00'])
   #   avail.date       #=> #<Date: 2026-02-28>
-  #   avail.raw_date   #=> "2026-02-28"
+  #   avail['date']    #=> "2026-02-28"
   #   avail.slots      #=> [#<DateTime: 2026-02-28T10:00:00.000+01:00>]
-  #   avail.raw_slots  #=> ["2026-02-28T10:00:00.000+01:00"]
+  #   avail['slots']   #=> ["2026-02-28T10:00:00.000+01:00"]
   class Availability < Resource
+    main_attrs :date, :slots
+
     extend TocDoc::UriUtils
 
-    attr_reader :date, :slots
+    # @return [Date, nil] the parsed availability date
+    attr_reader :date
+
+    # @return [Array<DateTime>] the parsed slot datetimes
+    attr_reader :slots
 
     # API path for the availabilities endpoint.
     # @return [String]
@@ -96,6 +102,11 @@ module TocDoc
 
     private
 
+    # Extracts the +date+ and +slots+ keys from the raw attribute hash,
+    # providing an empty array fallback for missing slots.
+    #
+    # @param attrs [Hash{String => Object}] normalized attribute hash
+    # @return [Hash{String => Object}]
     def build_raw(attrs)
       {
         'date' => attrs['date'],

data/lib/toc_doc/models/booking_info.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'json'
 require 'toc_doc/models/profile'
 require 'toc_doc/models/speciality'
 require 'toc_doc/models/place'
@@ -78,14 +79,19 @@ module TocDoc
 
     # All agendas for this booking context.
     #
+    # Visit motives are resolved via a hash index keyed by ID, so lookup is O(1)
+    # per motive rather than O(n) per agenda. Unknown visit_motive_ids are
+    # silently dropped.
+    #
     # @return [Array<TocDoc::Agenda>]
     def agendas
-      @agendas ||= Array(@data['agendas']).map do |agenda_attrs|
-        agenda_visit_motives = visit_motives.select do |vm|
-          agenda_attrs['visit_motive_ids'].include?(vm.id)
-        end
+      @agendas ||= begin
+        vm_index = visit_motives.to_h { |vm| [vm.id, vm] }
 
-        Agenda.new(agenda_attrs.merge('visit_motives' => agenda_visit_motives))
+        Array(@data['agendas']).map do |agenda_attrs|
+          agenda_visit_motives = Array(agenda_attrs['visit_motive_ids']).filter_map { |id| vm_index[id] }
+          Agenda.new(agenda_attrs.merge('visit_motives' => agenda_visit_motives))
+        end
       end
     end
 
@@ -120,11 +126,35 @@ module TocDoc
       profile.organization?
     end
 
-    # Returns the raw data hash.
+    # Returns the raw data hash as received from the API.
     #
     # @return [Hash]
-    def to_h
+    def raw
       @data
     end
+
+    # Returns a hydrated hash with all typed collections serialized to plain
+    # Hashes. Unlike {#raw}, nested objects are converted via their own
+    # +#to_h+ methods.
+    #
+    # @return [Hash{String => Object}]
+    def to_h
+      {
+        'profile' => profile.to_h,
+        'specialities' => specialities.map(&:to_h),
+        'visit_motives' => visit_motives.map(&:to_h),
+        'agendas' => agendas.map(&:to_h),
+        'places' => places.map(&:to_h),
+        'practitioners' => practitioners.map(&:to_h)
+      }
+    end
+
+    # Serialize the booking info to a JSON string.
+    #
+    # @param args [Array] forwarded to +Hash#to_json+
+    # @return [String]
+    def to_json(*)
+      to_h.to_json(*)
+    end
   end
 end

data/lib/toc_doc/models/place.rb

@@ -27,6 +27,8 @@ module TocDoc
   #   place.latitude         #=> 44.8386722
   #   place.elevator         #=> true
   class Place < Resource
+    main_attrs :id, :city, :full_address
+
     # Returns the geographic coordinates of the place.
     #
     # @return [Array(Float, Float)] +[latitude, longitude]+

data/lib/toc_doc/models/profile/organization.rb

@@ -3,6 +3,8 @@
 module TocDoc
   class Profile
     # An organization profile.
-    class Organization < Profile; end
+    class Organization < Profile
+      main_attrs :name
+    end
   end
 end

data/lib/toc_doc/models/profile.rb

@@ -165,6 +165,28 @@ module TocDoc
     def organization?
       is_a?(Organization)
     end
+
+    # Returns the profile ID, falling back to the +value+ key used in
+    # autocomplete responses when +id+ is absent.
+    #
+    # @return [Integer, String, nil]
+    def id
+      self['id'] || self['value']
+    end
+
+    # Replaces this profile's attributes with those from the full profile page,
+    # making a network request only when the profile is currently partial.
+    # Returns +self+ for chaining.
+    #
+    # @return [self]
+    def load_full_profile!
+      return unless partial
+
+      full_profile = self.class.find(id)
+      @attrs = full_profile.instance_variable_get(:@attrs)
+      @partial = false
+      self
+    end
   end
 end
 

data/lib/toc_doc/models/resource.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'json'
+
 module TocDoc
   # A lightweight wrapper providing dot-notation access to response fields.
   # Backed by a Hash, with +method_missing+ for attribute access and +#to_h+ for
@@ -14,6 +16,8 @@ module TocDoc
   #   resource[:date] #=> "2026-02-28"
   #   resource.to_h   #=> { "date" => "2026-02-28", "slots" => [] }
   class Resource
+    attr_reader :attrs
+
     class << self
       # Normalises a raw attribute hash to string keys, mirroring what
       # {#initialize} does internally. Useful in class-level factory methods
@@ -73,11 +77,20 @@ module TocDoc
       @attrs[key.to_s] = value
     end
 
-    # Return a plain Hash representation (shallow copy).
+    # Return a plain Hash representation with all nested {Resource} values
+    # recursively converted to plain Hashes.
     #
     # @return [Hash{String => Object}]
     def to_h
-      @attrs.dup
+      @attrs.transform_values { |v| deep_convert(v) }
+    end
+
+    # Serialize the resource to a JSON string.
+    #
+    # @param args [Array] forwarded to +Hash#to_json+
+    # @return [String]
+    def to_json(*)
+      to_h.to_json(*)
     end
 
     # Equality comparison.
@@ -100,24 +113,80 @@ module TocDoc
       @attrs.key?(method_name.to_s) || super
     end
 
+    # Returns the list of attribute names present on this resource.
+    #
+    # @return [Array<String>] attribute names as strings
+    #
+    # @example
+    #   resource = TocDoc::Resource.new('date' => '2026-02-28', 'slots' => [])
+    #   resource.attribute_names #=> ["date", "slots"]
+    def attribute_names
+      @attrs.keys
+    end
+
     # Provides dot-notation access to response fields.
     #
-    # Any method call whose name matches a key in the underlying attribute
-    # hash is dispatched here.
+    # On first access, defines a singleton method so that subsequent calls
+    # bypass +method_missing+ entirely. The defined method reads live from
+    # +@attrs+, so mutations via +[]=+ are always reflected.
     #
     # @param method_name [Symbol] the method name
     # @return [Object] the attribute value
     # @raise [NoMethodError] when the key does not exist
     def method_missing(method_name, *_args)
       key = method_name.to_s
-      @attrs.key?(key) ? @attrs[key] : super
+      if @attrs.key?(key)
+        define_singleton_method(key) { @attrs[key] }
+        @attrs[key]
+      else
+        super
+      end
     end
 
-    # @!visibility private
+    # Returns a human-readable representation of the resource showing only the
+    # declared {.main_attrs} (or all attrs when none are declared).
+    #
+    # @return [String]
     def inspect
-      keys  = self.class.main_attrs || @attrs.keys
-      pairs = keys.map { |k| "@#{k}=#{@attrs[k.to_s].inspect}" }.join(', ')
+      pairs = inspect_hash.map do |key, value|
+        "@#{key}=#{value.inspect}"
+      end.join(', ')
+
       "#<#{self.class} #{pairs}>"
     end
+
+    private
+
+    # Builds the key/value pairs used by {#inspect}.
+    #
+    # For each target key, the raw value from +@attrs+ is used when present.
+    # When the key is absent from +@attrs+ but the resource responds to the
+    # method (e.g. a computed attribute defined by a subclass), the method
+    # return value is used as a fallback.
+    #
+    # @return [Hash{String => Object}]
+    def inspect_hash
+      target_keys = self.class.main_attrs || @attrs.keys
+
+      target_keys.to_h do |target_key|
+        value = @attrs[target_key.to_s]
+        value = send(target_key) if value.nil? && respond_to?(target_key)
+        [target_key, value]
+      end
+    end
+
+    # Recursively converts {Resource} instances, Hashes, and Arrays to plain
+    # Ruby structures so that +to_h+ is fully serializable.
+    #
+    # @param value [Object]
+    # @return [Object]
+    def deep_convert(value)
+      case value
+      when Resource then value.to_h
+      when Hash     then value.transform_values { |v| deep_convert(v) }
+      when Array    then value.map { |v| deep_convert(v) }
+      else value
+      end
+    end
   end
 end

data/lib/toc_doc/models/speciality.rb

@@ -12,5 +12,6 @@ module TocDoc
   #   speciality.slug   #=> "homeopathe"
   #   speciality.name   #=> "Homéopathe"
   class Speciality < Resource
+    main_attrs :name, :slug
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: toc_doc
 version: !ruby/object:Gem::Version
-  version: 1.6.0
+  version: 1.7.0
 platform: ruby
 authors:
 - 01max
@@ -70,6 +70,7 @@ files:
 - lib/toc_doc/core/error.rb
 - lib/toc_doc/core/uri_utils.rb
 - lib/toc_doc/core/version.rb
+- lib/toc_doc/http/middleware/logging.rb
 - lib/toc_doc/http/middleware/raise_error.rb
 - lib/toc_doc/middleware/.keep
 - lib/toc_doc/models.rb