nylas 5.17.0 → 6.0.3

data/lib/nylas/model/attributable.rb

@@ -1,89 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  module Model
-    # Allows defining of typecastable attributes on a model
-    module Attributable
-      def self.included(model)
-        model.extend(ClassMethods)
-      end
-
-      def initialize(**initial_data)
-        assign(**initial_data)
-      end
-
-      def attributes
-        @attributes ||= Attributes.new(self.class.attribute_definitions)
-      end
-
-      # @return [Hash] Representation of the model with values serialized into primitives based on their Type
-      def to_h(enforce_read_only: false)
-        attributes.to_h(enforce_read_only: enforce_read_only)
-      end
-
-      protected
-
-      def assign(**data)
-        data.each do |attribute_name, value|
-          next if value.nil?
-
-          if respond_to?(:"#{attribute_name}=")
-            send(:"#{attribute_name}=", value)
-          end
-        end
-      end
-
-      # Methods to call when tweaking Attributable classes
-      module ClassMethods
-        # rubocop:disable Naming/PredicateName
-        def has_n_of_attribute(name, type_name, read_only: false, default: [])
-          attribute_definitions[name] = ListAttributeDefinition.new(
-            type_name: type_name,
-            read_only: read_only,
-            default: default
-          )
-          define_accessors(name)
-        end
-        # rubocop:enable Naming/PredicateName
-
-        def attribute(name, type_name, read_only: false, default: nil)
-          attribute_definitions[name] = AttributeDefinition.new(
-            type_name: type_name,
-            read_only: read_only,
-            default: default
-          )
-          define_accessors(name)
-        end
-
-        def define_accessors(name)
-          define_method :"#{name}" do
-            attributes[name]
-          end
-
-          define_method :"#{name}=" do |value|
-            attributes[name] = value
-          end
-        end
-
-        # Allows a class to inherit parent's attributes
-        def inherit_attributes
-          return if superclass.nil?
-
-          parent_attributes = superclass.attribute_definitions
-          parent_attributes.each do |parent_attribute|
-            name = parent_attribute[0]
-            attr = parent_attribute[1]
-            next if attribute_definitions.key?(name)
-
-            attribute_definitions[name] = attr
-            define_accessors(name)
-          end
-        end
-
-        def attribute_definitions
-          @attribute_definitions ||= Registry.new
-        end
-      end
-    end
-  end
-end

data/lib/nylas/model/attribute_definition.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  module Model
-    # Define a particular attribute for a given model
-    class AttributeDefinition
-      extend Forwardable
-      def_delegators :type, :cast, :serialize, :serialize_for_api
-      attr_accessor :type_name, :read_only, :default
-
-      def initialize(type_name:, read_only:, default:)
-        self.type_name = type_name
-        self.read_only = read_only
-        self.default = default
-      end
-
-      private
-
-      def type
-        Types.registry[type_name]
-      end
-    end
-  end
-end

data/lib/nylas/model/attributes.rb

@@ -1,97 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  module Model
-    # Stores the actual model data to allow for type casting and clean/dirty checking
-    class Attributes
-      attr_accessor :data, :attribute_definitions
-
-      def initialize(attribute_definitions)
-        @attribute_definitions = attribute_definitions
-        @data = Registry.new(default_attributes)
-      end
-
-      def [](key)
-        data[key]
-      end
-
-      def []=(key, value)
-        data[key] = cast(key, value)
-      rescue Nylas::Registry::MissingKeyError
-        # Don't crash when a new attribute is added
-      end
-
-      # Merges data into the registry while casting input types correctly
-      def merge(new_data)
-        new_data.each do |attribute_name, value|
-          self[attribute_name] = value
-        end
-      end
-
-      # Convert the object to hash
-      # @param keys [Array<String>] The keys included
-      # @param enforce_read_only [Boolean] Whether to enforce read_only property (serializing for API)
-      # @return [Hash] The hash representation of the object
-      def to_h(keys: attribute_definitions.keys, enforce_read_only: false)
-        casted_data = {}
-        keys.each do |key|
-          value = attribute_to_hash(key, enforce_read_only)
-          # If the value is an empty hash but we specify that it is valid (via default value), serialize it
-          casted_data[key] = value unless value.nil? || (value.respond_to?(:empty?) && value.empty? &&
-            !(attribute_definitions[key].default == value && value.is_a?(Hash)))
-        end
-        casted_data
-      end
-
-      # Serialize the object
-      # @param keys [Array<String>] The keys included
-      # @param enforce_read_only [Boolean] Whether to enforce read_only property (serializing for API)
-      # @return [String] The serialized object as a JSON string
-      def serialize(keys: attribute_definitions.keys, enforce_read_only: false)
-        JSON.dump(to_h(keys: keys, enforce_read_only: enforce_read_only))
-      end
-
-      # Serialize the object to an API-compatible JSON string
-      # @param keys [Array<String>] The keys included
-      # @return [String] The serialized object as a JSON string
-      def serialize_for_api(keys: attribute_definitions.keys)
-        serialize(keys: keys, enforce_read_only: true)
-      end
-
-      def serialize_all_for_api(keys: attribute_definitions.keys)
-        api_keys = keys.delete_if { |key| attribute_definitions[key].read_only == true }
-
-        JSON.dump(
-          api_keys.each_with_object({}) do |key, casted_data|
-            casted_data[key] = attribute_definitions[key].serialize(self[key])
-          end
-        )
-      end
-
-      private
-
-      def cast(key, value)
-        attribute_definitions[key].cast(value)
-      rescue TypeError => e
-        raise TypeError, "#{key} #{e.message}"
-      end
-
-      def default_attributes
-        attribute_definitions.keys.zip([]).to_h
-      end
-
-      # Convert the attribute value as a hash
-      # @param key [String] The attribute's key
-      # @param enforce_read_only [Boolean] Whether to enforce read_only property (serializing for API)
-      # @return [nil | Hash] The appropriately serialized value
-      def attribute_to_hash(key, enforce_read_only)
-        attribute_definition = attribute_definitions[key]
-        if enforce_read_only
-          attribute_definition.read_only == true ? nil : attribute_definition.serialize_for_api(self[key])
-        else
-          attribute_definition.serialize(self[key])
-        end
-      end
-    end
-  end
-end

data/lib/nylas/model/list_attribute_definition.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  module Model
-    # Allows models to have an attribute which is a lists of another type of thing
-    class ListAttributeDefinition
-      attr_accessor :type_name, :read_only, :default
-
-      def initialize(type_name:, read_only:, default:)
-        self.type_name = type_name
-        self.read_only = read_only
-        self.default = default
-      end
-
-      def cast(list)
-        return default if list.nil? || list.empty?
-
-        list.map { |item| type.cast(item) }
-      end
-
-      def serialize(list, enforce_read_only: false)
-        list = default if list.nil? || list.empty?
-        if enforce_read_only
-          list.map { |item| type.serialize_for_api(item) }
-        else
-          list.map { |item| type.serialize(item) }
-        end
-      end
-
-      def serialize_for_api(list)
-        serialize(list, enforce_read_only: true)
-      end
-
-      def type
-        Types.registry[type_name]
-      end
-    end
-  end
-end

data/lib/nylas/model/transferable.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  module Model
-    # Allows definition of attributes, which should transfer to other dependent attributes
-    module Transferable
-      def self.included(model)
-        model.extend(ClassMethods)
-        model.init_attribute_recipients
-      end
-
-      def initialize(**initial_data)
-        assign(**initial_data)
-        transfer_attributes
-      end
-
-      private
-
-      def transfer_attributes
-        self.class.attribute_recipients.each_pair do |name, recipient_names|
-          value = send(:"#{name}")
-          next if value.nil?
-
-          recipient_names.each do |recipient_name|
-            recipient = send(:"#{recipient_name}")
-            transfer_to_recipient(name, value, recipient) unless recipient.nil?
-          end
-        end
-      end
-
-      def transfer_to_recipient(name, value, recipient)
-        if recipient.respond_to?(:each)
-          recipient.each { |item| item.send(:"#{name}=", value) }
-        else
-          recipient.send(:"#{name}=", value)
-        end
-      end
-
-      # Methods to call when tweaking Transferable classes
-      module ClassMethods
-        attr_accessor :attribute_recipients
-
-        def init_attribute_recipients
-          self.attribute_recipients ||= {}
-        end
-
-        def transfer(*attributes, **opts)
-          attributes.each { |name| self.attribute_recipients[name] = opts[:to] }
-        end
-      end
-    end
-  end
-end

data/lib/nylas/model.rb

@@ -1,217 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "model/attribute_definition"
-require_relative "model/list_attribute_definition"
-require_relative "model/attributable"
-require_relative "model/attributes"
-require_relative "model/transferable"
-module Nylas
-  # Include this to define a class to represent an object returned from the API
-  module Model
-    attr_accessor :api
-
-    def model_class
-      self.class
-    end
-
-    def self.included(model)
-      model.include(Attributable)
-      model.include(Transferable)
-      model.extend(ClassMethods)
-      model.extend(Forwardable)
-      model.def_delegators :model_class, :creatable?, :filterable?, :listable?, :searchable?, :showable?,
-                           :updatable?, :destroyable?, :id_listable?, :countable?
-      model.init_operations
-    end
-
-    def save
-      result = if persisted?
-                 raise ModelNotUpdatableError, self unless updatable?
-
-                 update_call(attributes.serialize_for_api)
-               else
-                 create
-               end
-      attributes.merge(result)
-    end
-
-    def persisted?
-      !id.nil?
-    end
-
-    def execute(method:, payload: nil, path:, query: {}, auth_method: self.auth_method)
-      api.execute(method: method, payload: payload, path: path, query: query, auth_method: auth_method)
-    end
-
-    def create
-      raise ModelNotCreatableError, self unless creatable?
-
-      execute(
-        method: :post,
-        payload: attributes.serialize_for_api,
-        path: resources_path,
-        query: query_params
-      )
-    end
-
-    def update(**data)
-      raise ModelNotUpdatableError, model_class unless updatable?
-
-      attributes.merge(**data)
-      payload = attributes.serialize_for_api(keys: data.keys)
-      update_call(payload)
-
-      true
-    rescue Registry::MissingKeyError => e
-      raise ModelMissingFieldError.new(e.key, self)
-    end
-
-    def save_all_attributes
-      result = if persisted?
-                 raise ModelNotUpdatableError, self unless updatable?
-
-                 execute(
-                   method: :put,
-                   payload: attributes.serialize_all_for_api,
-                   path: resource_path
-                 )
-               else
-                 create
-               end
-
-      attributes.merge(result)
-    end
-
-    def update_all_attributes(**data)
-      raise ModelNotUpdatableError, model_class unless updatable?
-
-      attributes.merge(**data)
-      payload = attributes.serialize_all_for_api(keys: data.keys)
-      update_call(payload)
-
-      true
-    rescue Registry::MissingKeyError => e
-      raise ModelMissingFieldError.new(e.key, self)
-    end
-
-    def reload
-      assign(**execute(method: :get, path: resource_path))
-      true
-    end
-
-    def resource_path
-      "#{resources_path}/#{id}"
-    end
-
-    def resources_path
-      self.class.resources_path(api: api)
-    end
-
-    def auth_method
-      self.class.auth_method(api: api)
-    end
-
-    def destroy
-      raise ModelNotDestroyableError, self unless destroyable?
-
-      execute(method: :delete, path: resource_path, query: query_params)
-    end
-
-    # @return [String] JSON String of the model.
-    def to_json(_opts = {})
-      JSON.dump(to_h)
-    end
-
-    private
-
-    def update_call(payload)
-      result = execute(
-        method: :put,
-        payload: payload,
-        path: resource_path,
-        query: query_params
-      )
-      attributes.merge(result) if result
-    end
-
-    def query_params
-      {}
-    end
-
-    # Allows you to narrow in exactly what kind of model you're working with
-    module ClassMethods
-      attr_accessor :raw_mime_type, :creatable, :showable, :filterable, :searchable, :listable, :updatable,
-                    :destroyable, :id_listable, :countable
-      attr_writer :resources_path, :auth_method
-
-      def init_operations
-        self.creatable = false
-        self.showable = false
-        self.listable = false
-        self.filterable = false
-        self.searchable = false
-        self.updatable = false
-        self.destroyable = false
-        self.id_listable = false
-        self.countable = false
-      end
-
-      def creatable?
-        creatable
-      end
-
-      def showable?
-        showable
-      end
-
-      def listable?
-        listable
-      end
-
-      def filterable?
-        filterable
-      end
-
-      def searchable?
-        searchable
-      end
-
-      def updatable?
-        updatable
-      end
-
-      def destroyable?
-        destroyable
-      end
-
-      def id_listable?
-        id_listable
-      end
-
-      def countable?
-        countable
-      end
-
-      def resources_path(*)
-        @resources_path
-      end
-
-      def auth_method(*)
-        @auth_method || HttpClient::AuthMethod::BEARER
-      end
-
-      def exposable_as_raw?
-        !raw_mime_type.nil?
-      end
-
-      def from_json(json, api:)
-        from_hash(JSON.parse(json, symbolize_names: true), api: api)
-      end
-
-      def from_hash(data, api:)
-        instance = new(**data.merge(api: api))
-        instance
-      end
-    end
-  end
-end

data/lib/nylas/native_authentication.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Authenticate your application using the native interface
-  # @see https://docs.nylas.com/reference#native-authentication-1
-  class NativeAuthentication
-    attr_accessor :api
-
-    def initialize(api:)
-      self.api = api
-    end
-
-    def authenticate(name:, email_address:, provider:, settings:, reauth_account_id: nil,
-                     scopes: nil, return_full_response: false)
-      scopes ||= %w[email calendar contacts]
-      scopes = scopes.join(",") unless scopes.is_a?(String)
-      code = retrieve_code(name: name, email_address: email_address, provider: provider,
-                           settings: settings, reauth_account_id: reauth_account_id, scopes: scopes)
-
-      exchange_code_for_access_token(code, return_full_response)
-    end
-
-    private
-
-    def retrieve_code(name:, email_address:, provider:, settings:, reauth_account_id:, scopes:)
-      payload = { client_id: api.client.app_id, name: name, email_address: email_address,
-                  provider: provider, settings: settings, scopes: scopes }
-      payload[:reauth_account_id] = reauth_account_id
-      response = api.execute(method: :post, path: "/connect/authorize", payload: JSON.dump(payload))
-      response[:code]
-    end
-
-    def exchange_code_for_access_token(code, return_full_response)
-      payload = { client_id: api.client.app_id, client_secret: api.client.app_secret, code: code }
-      response = api.execute(method: :post, path: "/connect/token", payload: JSON.dump(payload))
-      return_full_response ? response : response[:access_token]
-    end
-  end
-end

data/lib/nylas/neural.rb

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Class containing methods for accessing Neural API features.
-  # @see https://developer.nylas.com/docs/intelligence/
-  class Neural
-    attr_accessor :api
-
-    def initialize(api:)
-      self.api = api
-    end
-
-    def sentiment_analysis_message(message_ids)
-      body = { message_id: message_ids }
-      response = request(NeuralSentimentAnalysis.resources_path, body)
-
-      collection = []
-      response.each do |sentiment|
-        collection.push(NeuralSentimentAnalysis.new(**sentiment.merge(api: api)))
-      end
-      collection
-    end
-
-    def sentiment_analysis_text(text)
-      body = { text: text }
-      NeuralSentimentAnalysis.new(**request(NeuralSentimentAnalysis.resources_path, body).merge(api: api))
-    end
-
-    def extract_signature(message_ids, options = nil)
-      body = { message_id: message_ids }
-      body = body.merge(options) unless options.nil?
-      response = request(NeuralSignatureExtraction.resources_path, body)
-
-      collection = []
-      response.each do |signature|
-        collection.push(NeuralSignatureExtraction.new(**signature.merge(api: api)))
-      end
-      collection
-    end
-
-    def ocr_request(file_id, pages = nil)
-      body = { file_id: file_id }
-      body[:pages] = pages unless pages.nil?
-
-      NeuralOcr.new(**request(NeuralOcr.resources_path, body).merge(api: api))
-    end
-
-    def categorize(message_ids)
-      body = { message_id: message_ids }
-      response = request(NeuralCategorizer.resources_path, body)
-
-      collection = []
-      response.each do |categorize|
-        collection.push(NeuralCategorizer.new(**categorize.merge(api: api)))
-      end
-      collection
-    end
-
-    def clean_conversation(message_ids, options = nil)
-      body = { message_id: message_ids }
-      body = body.merge(delete_from_hash(options.to_hash, :parse_contact)) unless options.nil?
-
-      response = request(NeuralCleanConversation.resources_path, body)
-      collection = []
-      response.each do |conversation|
-        collection.push(NeuralCleanConversation.new(**conversation.merge(api: api)))
-      end
-      collection
-    end
-
-    private
-
-    def request(path, body)
-      api.execute(
-        method: :put,
-        path: path,
-        payload: JSON.dump(body)
-      )
-    end
-
-    # For Ruby < 3.0 support, as it doesn't support Hash.except
-    def delete_from_hash(hash, to_delete)
-      hash.delete(to_delete)
-      hash
-    end
-  end
-end

data/lib/nylas/neural_categorizer.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Nylas
-  # Structure to represent a the Neural Categorizer object.
-  # @see https://developer.nylas.com/docs/intelligence/categorizer/#categorize-message-response
-  class NeuralCategorizer < Message
-    include Model
-    self.resources_path = "/neural/categorize"
-    self.listable = true
-
-    attribute :categorizer, :categorize
-    # Overrides Message's label attribute as currently categorize returns
-    # list of strings for labels instead of label object types
-    has_n_of_attribute :labels, :string
-
-    inherit_attributes
-
-    def recategorize(category)
-      body = { message_id: id, category: category }
-      api.execute(
-        method: :post,
-        path: "#{resources_path}/feedback",
-        payload: JSON.dump(body)
-      )
-      list = api.neural.categorize([id])
-      list[0]
-    end
-  end
-end