nylas 3.2.0 → 4.0.0.rc2

data/lib/nylas/model.rb

@@ -0,0 +1,92 @@
+require_relative "model/attribute_definition"
+require_relative "model/list_attribute_definition"
+require_relative "model/attributable"
+require_relative "model/attributes"
+module Nylas
+  # Include this to define a class to represent an object returned from the API
+  module Model
+    attr_accessor :api
+
+    def self.included(model)
+      model.include(Attributable)
+      model.extend(ClassMethods)
+      model.collectionable = true
+      model.searchable = true
+      model.read_only = false
+    end
+
+    def save
+      raise_if_read_only
+      result = if id
+                 api.execute(method: :put, payload: attributes.serialize, path: resource_path)
+               else
+                 api.execute(method: :post, payload: attributes.serialize, path: resources_path)
+               end
+      attributes.merge(result)
+    end
+
+    def update(**data)
+      raise_if_read_only
+      attributes.merge(**data)
+      api.execute(method: :put, payload: attributes.serialize(keys: data.keys), path: resource_path)
+      true
+    end
+
+    def reload
+      attributes.merge(api.execute(method: :get, path: resource_path))
+      true
+    end
+
+    def resource_path
+      "#{resources_path}/#{id}"
+    end
+
+    def resources_path
+      self.class.resources_path
+    end
+
+    def destroy
+      api.execute(method: :delete, path: resource_path)
+    end
+
+    # @return [String] JSON String of the model.
+    def to_json
+      JSON.dump(to_h)
+    end
+
+    def raise_if_read_only
+      self.class.raise_if_read_only
+    end
+
+    # Allows you to narrow in exactly what kind of model you're working with
+    module ClassMethods
+      attr_accessor :resources_path, :searchable, :read_only, :collectionable
+
+      def read_only?
+        read_only == true
+      end
+
+      def raise_if_read_only
+        raise NotImplementedError, "#{self} is read only" if read_only?
+      end
+
+      def searchable?
+        searchable == true
+      end
+
+      def collectionable?
+        collectionable == true
+      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)
+        instance.api = api
+        instance
+      end
+    end
+  end
+end

data/lib/nylas/model/attributable.rb

@@ -0,0 +1,57 @@
+module Nylas
+  module Model
+    # Allows defining of tyypecastable attributes on a model
+    module Attributable
+      def self.included(model)
+        model.extend(ClassMethods)
+      end
+
+      def initialize(**initial_data)
+        initial_data.each do |attribute_name, value|
+          send(:"#{attribute_name}=", value)
+        end
+      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
+        attributes.to_h
+      end
+
+      # Methods to call when tweaking Attributable classes
+      module ClassMethods
+        # rubocop:disable Style/PredicateName
+        def has_n_of_attribute(name, type_name, exclude_when: [], default: [])
+          attribute_definitions[name] = ListAttributeDefinition.new(type_name: type_name,
+                                                                    exclude_when: exclude_when,
+                                                                    default: default)
+          define_accessors(name)
+        end
+        # rubocop:enable Style/PredicateName
+
+        def attribute(name, type_name, exclude_when: [], default: nil)
+          attribute_definitions[name] = AttributeDefinition.new(type_name: type_name,
+                                                                exclude_when: exclude_when, 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
+
+        def attribute_definitions
+          @attribute_definitions ||= Registry.new
+        end
+      end
+    end
+  end
+end

data/lib/nylas/model/attribute_definition.rb

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

data/lib/nylas/model/attributes.rb

@@ -0,0 +1,47 @@
+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)
+      end
+
+      private def cast(key, value)
+        attribute_definitions[key].cast(value)
+      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
+
+      def to_h(keys: attribute_definitions.keys)
+        keys.each_with_object({}) do |key, casted_data|
+          value = attribute_definitions[key].serialize(self[key])
+          casted_data[key] = value unless value.nil? || value.empty?
+        end
+      end
+
+      def serialize(keys: attribute_definitions.keys)
+        JSON.dump(to_h(keys: keys))
+      end
+
+      private def default_attributes
+        attribute_definitions.keys.zip([]).to_h
+      end
+    end
+  end
+end

data/lib/nylas/model/list_attribute_definition.rb

@@ -0,0 +1,28 @@
+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, :exclude_when, :default
+
+      def initialize(type_name:, exclude_when:, default:)
+        self.type_name = type_name
+        self.exclude_when = exclude_when
+        self.default = default
+      end
+
+      def cast(list)
+        return default if list.nil? || list.empty?
+        list.map { |item| type.cast(item) }
+      end
+
+      def serialize(list)
+        list = default if list.nil? || list.empty?
+        list.map { |item| type.serialize(item) }
+      end
+
+      def type
+        Types.registry[type_name]
+      end
+    end
+  end
+end

data/lib/nylas/nylas_date.rb

@@ -0,0 +1,20 @@
+module Nylas
+  # Structure to represent Nylas's more complex Date Schema
+  # @see https://docs.nylas.com/reference#contactsid
+  class NylasDate
+    extend Forwardable
+    def_delegators :date, :===, :==, :<=>, :eql?, :equal?
+
+    include Model::Attributable
+    attribute :object, :string
+    attribute :date, :date
+  end
+
+  # Serializes, Deserializes between {NylasDate} objects and a {Hash}
+  class NylasDateType < Types::HashType
+    casts_to NylasDate
+    def cast(value)
+      value.is_a?(String) ? super({ object: "date", date: value }) : super
+    end
+  end
+end

data/lib/nylas/phone_number.rb

@@ -0,0 +1,14 @@
+module Nylas
+  # Structure to represent the Phone Number Schema
+  # @see https://docs.nylas.com/reference#contactsid
+  class PhoneNumber
+    include Model::Attributable
+    attribute :type, :string
+    attribute :number, :string
+  end
+
+  # Serializes, Deserializes between {PhoneNumber} objects and a {Hash}
+  class PhoneNumberType < Types::HashType
+    casts_to PhoneNumber
+  end
+end

data/lib/nylas/physical_address.rb

@@ -0,0 +1,19 @@
+module Nylas
+  # Structure to represent the Physical Address schema
+  # @see https://docs.nylas.com/reference#contactsid
+  class PhysicalAddress
+    include Model::Attributable
+    attribute :format, :string
+    attribute :type, :string
+    attribute :street_address, :string
+    attribute :postal_code, :string
+    attribute :state, :string
+    attribute :city, :string
+    attribute :country, :string
+  end
+
+  # Serializes, Deserializes between {PhysicalAddress} objects and a {Hash}
+  class PhysicalAddressType < Types::HashType
+    casts_to PhysicalAddress
+  end
+end

data/lib/nylas/registry.rb

@@ -0,0 +1,37 @@
+module Nylas
+  # Used to create a hash-like structure which defaults to raising an exception in the event the key to
+  # retrieve does not exist.
+  class Registry
+    # Used to indicate an attempt to retrieve something not yet registered in a registry
+    # Includes the list of keys in the registry for debug purposes.
+    class MissingKeyError < Error
+      def initialize(key, keys)
+        super("key #{key} not in #{keys}")
+      end
+    end
+    attr_accessor :registry_data
+
+    extend Forwardable
+    def_delegators :registry_data, :keys, :each, :reduce
+
+    def initialize(initial_data = {})
+      self.registry_data = initial_data.each.each_with_object({}) do |(key, value), registry|
+        registry[key] = value
+      end
+    end
+
+    def [](key)
+      registry_data.fetch(key)
+    rescue KeyError
+      raise MissingKeyError.new(key, keys)
+    end
+
+    def []=(key, value)
+      registry_data[key] = value
+    end
+
+    def to_h
+      registry_data
+    end
+  end
+end

data/lib/nylas/types.rb

@@ -0,0 +1,83 @@
+module Nylas
+  # Collection of attribute types
+  module Types
+    def self.registry
+      @registry ||= Registry.new
+    end
+
+    # Type for attributes that are persisted in the API as a hash but exposed in ruby as a particular
+    # structure
+    class HashType
+      def serialize(object)
+        object.to_h
+      end
+
+      def self.casts_to(model)
+        @casts_to_model = model
+      end
+
+      class << self
+        attr_reader :casts_to_model
+      end
+
+      def model
+        self.class.casts_to_model
+      end
+
+      def cast(value)
+        return model.new if value.nil?
+        return value if already_cast?(value)
+        return model.new(**actual_attributes(value)) if value.respond_to?(:key?)
+        raise TypeError, "Unable to cast #{value} to a #{model}"
+      end
+
+      def already_cast?(value)
+        model.attribute_definitions.keys.all? { |attribute_name| value.respond_to?(attribute_name) }
+      end
+
+      def actual_attributes(hash)
+        model.attribute_definitions.keys.each_with_object({}) do |attribute_name, attributes|
+          attributes[attribute_name] = hash[attribute_name]
+        end
+      end
+    end
+
+    # Type for attributes that do not require casting/serializing/deserializing.
+    class ValueType
+      def cast(object)
+        object
+      end
+
+      def serialize(object)
+        object
+      end
+
+      def deseralize(object)
+        object
+      end
+    end
+
+    # Type for attributes represented as an iso8601 dates in the API and Date in Ruby
+    class DateType < ValueType
+      def cast(value)
+        return nil if value.nil?
+        Date.parse(value)
+      end
+
+      def serialize(value)
+        return value.iso8601 if value.respond_to?(:iso8601)
+        value
+      end
+    end
+    Types.registry[:date] = DateType.new
+
+    # Type for attributes represented as pure strings both within the API and in Ruby
+    class StringType < ValueType
+      # @param value [Object] Casts the passed in object to a string using #to_s
+      def cast(value)
+        value.to_s
+      end
+    end
+    Types.registry[:string] = StringType.new
+  end
+end

data/lib/nylas/version.rb

@@ -0,0 +1,3 @@
+module Nylas
+  VERSION = "4.0.0.rc2".freeze
+end

data/lib/nylas/web_page.rb

@@ -0,0 +1,14 @@
+module Nylas
+  # Structure to represent the Web Page Schema
+  # @see https://docs.nylas.com/reference#contactsid
+  class WebPage
+    include Model::Attributable
+    attribute :type, :string
+    attribute :url, :string
+  end
+
+  # Serializes, Deserializes between {WebPage} objects and a {Hash}
+  class WebPageType < Types::HashType
+    casts_to WebPage
+  end
+end