nylas 3.2.0 → 4.0.0.rc2

data/lib/restful_model.rb

@@ -1,82 +0,0 @@
-require 'time_attr_accessor'
-require 'parameters'
-
-module Nylas
-  class RestfulModel
-    extend Nylas::TimeAttrAccessor
-    include Nylas::Parameters
-
-    parameter :id
-    parameter :account_id
-    parameter :cursor  # Only used by the delta sync API
-    time_attr_accessor :created_at
-    attr_reader :raw_json
-
-    def self.collection_name
-      "#{self.to_s.downcase}s".split('::').last
-    end
-
-    def initialize(api, account_id = nil)
-      raise StandardError.new unless api.class <= Nylas::API
-      @account_id = account_id
-      @_api = api
-    end
-
-    def ==(comparison_object)
-      comparison_object.equal?(self) || (comparison_object.instance_of?(self.class) && comparison_object.id == id)
-    end
-
-    def inflate(json)
-      @raw_json = json
-      parameters.each do |property_name|
-        send("#{property_name}=", json[property_name]) if json.has_key?(property_name)
-      end
-    end
-
-    def save!(params={})
-      if id
-        update('PUT', '', as_json(), params)
-      else
-        update('POST', '', as_json(), params)
-      end
-    end
-
-    def url(action = "")
-      action = "/#{action}" unless action.empty?
-      @_api.url_for_path("/#{self.class.collection_name}/#{id}#{action}")
-    end
-
-    def as_json(options = {})
-      hash = {}
-      parameters.each do |getter|
-        unless options[:except] && options[:except].include?(getter)
-          value = send(getter)
-          unless value.is_a?(RestfulModelCollection)
-            value = value.as_json(options) if value.respond_to?(:as_json)
-            hash[getter] = value
-          end
-        end
-      end
-      hash
-    end
-
-    def update(http_method, action, data = {}, params = {})
-      http_method = http_method.downcase
-
-      ::RestClient.send(http_method, self.url(action), data.to_json, :content_type => :json, :params => params) do |response, request, result|
-        unless http_method == 'delete'
-          json = Nylas.interpret_response(result, response, :expected_class => Object)
-          inflate(json)
-        end
-      end
-      self
-    end
-
-    def destroy(params = {})
-      ::RestClient.send('delete', self.url, :params => params) do |response, request, result|
-        Nylas.interpret_response(result, response, {:raw_response => true})
-      end
-    end
-
-  end
-end

data/lib/restful_model_collection.rb

@@ -1,160 +0,0 @@
-require 'restful_model'
-
-module Nylas
-  class RestfulModelCollection
-
-    attr_accessor :filters
-
-    def initialize(model_class, api, filters = {})
-      raise StandardError.new unless api.class <= Nylas::API
-      @model_class = model_class
-      @filters = filters
-      @_api = api
-    end
-
-    def each
-      return enum_for(:each) unless block_given?
-
-      get_model_collection do |items|
-        items.each do |item|
-          yield item
-        end
-      end
-    end
-
-    def count
-      RestClient.get(url, params: @filters.merge(view: 'count')) { |response,request,result|
-        json = Nylas.interpret_response(result, response)
-        return json['count']
-      }
-    end
-
-    def first
-      get_model_collection.first
-    end
-
-    def all
-      range(0, Float::INFINITY)
-    end
-
-    def where(filters)
-      collection = self.clone
-
-      # deep copy the object, otherwise filter is shared among all
-      # the instances of the collection, which leads to confusing behaviour.
-      # - karim
-      if collection.filters == nil
-        collection.filters = {}
-      else
-        collection.filters = Marshal.load(Marshal.dump(collection.filters))
-      end
-
-      collection.filters.merge!(filters)
-      collection
-    end
-
-    def range(offset = 0, limit = 100)
-
-      accumulated = get_model_collection(offset, limit)
-
-      accumulated = accumulated[0..limit] if limit < Float::INFINITY
-      accumulated
-    end
-
-    def delete(item_or_id)
-      item_or_id = item_or_id.id if item_or_id.is_a?(RestfulModel)
-      RestClient.delete("#{url}/#{item_or_id}")
-    end
-
-    def find(id)
-      return nil unless id
-      get_model(id)
-    end
-
-    def build(args)
-      for key in args.keys
-        args[key.to_s] = args[key]
-      end
-      model = @model_class.new(@_api)
-      model.inflate(args)
-      model
-    end
-
-    def inflate_collection(items = [])
-      models = []
-
-      return unless items.is_a?(Array)
-      items.each do |json|
-        if @model_class < RestfulModel
-          model = @model_class.new(@_api)
-          model.inflate(json)
-        else
-          model = @model_class.new(json)
-        end
-        models.push(model)
-      end
-      models
-    end
-
-    def url
-      @_api.url_for_path("/#{@model_class.collection_name}")
-    end
-
-    private
-
-    def get_model(id)
-      model = nil
-
-      RestClient.get("#{url}/#{id}"){ |response,request,result|
-        json = Nylas.interpret_response(result, response, {:expected_class => Object})
-        if @model_class < RestfulModel
-          model = @model_class.new(@_api)
-          model.inflate(json)
-        else
-          model = @model_class.new(json)
-        end
-      }
-      model
-    end
-
-    def get_model_collection(offset = nil, limit = nil, pagination_options = { per_page: 100 })
-      filters = @filters.clone
-      filters[:offset] = offset || filters[:offset] || 0
-      filters[:limit] = limit || filters[:limit] || 100
-
-      accumulated = []
-
-      finished = false
-
-      current_calls_filters = filters.clone
-      while (!finished) do
-        current_calls_filters[:limit] = pagination_options[:per_page] > filters[:limit] ? filters[:limit] : pagination_options[:per_page]
-        RestClient.get(url, :params => current_calls_filters) do |response, request, result|
-          items = Nylas.interpret_response(result, response, { :expected_class => Array })
-          new_items = inflate_collection(items)
-          yield new_items if block_given?
-          accumulated = accumulated.concat(new_items)
-          finished = no_more_pages?(accumulated, items, filters, pagination_options)
-        end
-
-        current_calls_filters[:offset] += pagination_options[:per_page]
-      end
-
-      accumulated
-    end
-
-    def no_more_pages?(accumulated, items, filters, pagination_options)
-      accumulated.length >= filters[:limit] || items.length < pagination_options[:per_page]
-    end
-  end
-
-
-  # a ManagementModelCollection is similar to a RestfulModelCollection except
-  # it's used by models under the /a/<app_id> namespace (mostly account status
-  # and billing methods).
-  class ManagementModelCollection < RestfulModelCollection
-    def url
-      @_api.url_for_management
-    end
-  end
-end

data/lib/time_attr_accessor.rb

@@ -1,12 +0,0 @@
-module Nylas
-  module TimeAttrAccessor
-    def time_attr_accessor(attr)
-      parameter attr
-      define_method "#{attr}=" do |value|
-        if value
-            instance_variable_set "@#{attr}", Time.at(value).utc
-        end
-      end
-    end
-  end
-end

data/lib/version.rb

@@ -1,3 +0,0 @@
-module Nylas
-  VERSION = "3.2.0"
-end