files.com 1.0.90

data/lib/files.com/models/user_cipher_use.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Files
+  class UserCipherUse
+    attr_reader :options, :attributes
+
+    def initialize(attributes = {}, options = {})
+      @attributes = attributes || {}
+      @options = options || {}
+    end
+
+    # int64 - UserCipherUse ID
+    def id
+      @attributes[:id]
+    end
+
+    # string - The protocol and cipher employed
+    def protocol_cipher
+      @attributes[:protocol_cipher]
+    end
+
+    # date-time - The earliest recorded use of this combination of interface and protocol and cipher (for this user)
+    def created_at
+      @attributes[:created_at]
+    end
+
+    # string - The interface accessed
+    def interface
+      @attributes[:interface]
+    end
+
+    # date-time - The most recent use of this combination of interface and protocol and cipher (for this user)
+    def updated_at
+      @attributes[:updated_at]
+    end
+
+    # int64 - ID of the user who performed this access
+    def user_id
+      @attributes[:user_id]
+    end
+
+    # Parameters:
+    #   user_id - int64 - User ID.  Provide a value of `0` to operate the current session's user.
+    #   page - int64 - Current page number.
+    #   per_page - int64 - Number of records to show per page.  (Max: 10,000, 1,000 or less is recommended).
+    #   action - string - Deprecated: If set to `count` returns a count of matching records rather than the records themselves.
+    def self.list(params = {}, options = {})
+      raise InvalidParameterError.new("Bad parameter: user_id must be an Integer") if params.dig(:user_id) and !params.dig(:user_id).is_a?(Integer)
+      raise InvalidParameterError.new("Bad parameter: page must be an Integer") if params.dig(:page) and !params.dig(:page).is_a?(Integer)
+      raise InvalidParameterError.new("Bad parameter: per_page must be an Integer") if params.dig(:per_page) and !params.dig(:per_page).is_a?(Integer)
+      raise InvalidParameterError.new("Bad parameter: action must be an String") if params.dig(:action) and !params.dig(:action).is_a?(String)
+
+      response, options = Api.send_request("/user_cipher_uses", :get, params, options)
+      response.data.map do |entity_data|
+        UserCipherUse.new(entity_data, options)
+      end
+    end
+
+    def self.all(params = {}, options = {})
+      list(params, options)
+    end
+  end
+end

data/lib/files.com/models/user_request.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Files
+  class UserRequest
+    attr_reader :options, :attributes
+
+    def initialize(attributes = {}, options = {})
+      @attributes = attributes || {}
+      @options = options || {}
+    end
+
+    # string - User's full name
+    def name
+      @attributes[:name]
+    end
+
+    def name=(value)
+      @attributes[:name] = value
+    end
+
+    # email - User email address
+    def email
+      @attributes[:email]
+    end
+
+    def email=(value)
+      @attributes[:email] = value
+    end
+
+    # string - Details of the user's request
+    def details
+      @attributes[:details]
+    end
+
+    def details=(value)
+      @attributes[:details] = value
+    end
+
+    def delete(params = {})
+      params ||= {}
+      params[:id] = @attributes[:id]
+      raise MissingParameterError.new("Current object doesn't have a id") unless @attributes[:id]
+      raise InvalidParameterError.new("Bad parameter: id must be an Integer") if params.dig(:id) and !params.dig(:id).is_a?(Integer)
+      raise MissingParameterError.new("Parameter missing: id") unless params.dig(:id)
+
+      Api.send_request("/user_requests/#{@attributes[:id]}", :delete, params, @options)
+    end
+
+    def destroy(params = {})
+      delete(params)
+    end
+
+    def save
+      if @attributes[:id]
+        raise NotImplementedError.new("The UserRequest object doesn't support updates.")
+      else
+        new_obj = UserRequest.create(@attributes, @options)
+        @attributes = new_obj.attributes
+      end
+    end
+
+    # Parameters:
+    #   page - int64 - Current page number.
+    #   per_page - int64 - Number of records to show per page.  (Max: 10,000, 1,000 or less is recommended).
+    #   action - string - Deprecated: If set to `count` returns a count of matching records rather than the records themselves.
+    def self.list(params = {}, options = {})
+      raise InvalidParameterError.new("Bad parameter: page must be an Integer") if params.dig(:page) and !params.dig(:page).is_a?(Integer)
+      raise InvalidParameterError.new("Bad parameter: per_page must be an Integer") if params.dig(:per_page) and !params.dig(:per_page).is_a?(Integer)
+      raise InvalidParameterError.new("Bad parameter: action must be an String") if params.dig(:action) and !params.dig(:action).is_a?(String)
+
+      response, options = Api.send_request("/user_requests", :get, params, options)
+      response.data.map do |entity_data|
+        UserRequest.new(entity_data, options)
+      end
+    end
+
+    def self.all(params = {}, options = {})
+      list(params, options)
+    end
+
+    # Parameters:
+    #   id (required) - int64 - User Request ID.
+    def self.find(id, params = {}, options = {})
+      params ||= {}
+      params[:id] = id
+      raise InvalidParameterError.new("Bad parameter: id must be an Integer") if params.dig(:id) and !params.dig(:id).is_a?(Integer)
+      raise MissingParameterError.new("Parameter missing: id") unless params.dig(:id)
+
+      response, options = Api.send_request("/user_requests/#{params[:id]}", :get, params, options)
+      UserRequest.new(response.data, options)
+    end
+
+    def self.get(id, params = {}, options = {})
+      find(id, params, options)
+    end
+
+    # Parameters:
+    #   name (required) - string - Name of user requested
+    #   email (required) - string - Email of user requested
+    #   details (required) - string - Details of the user request
+    def self.create(params = {}, options = {})
+      raise InvalidParameterError.new("Bad parameter: name must be an String") if params.dig(:name) and !params.dig(:name).is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: email must be an String") if params.dig(:email) and !params.dig(:email).is_a?(String)
+      raise InvalidParameterError.new("Bad parameter: details must be an String") if params.dig(:details) and !params.dig(:details).is_a?(String)
+      raise MissingParameterError.new("Parameter missing: name") unless params.dig(:name)
+      raise MissingParameterError.new("Parameter missing: email") unless params.dig(:email)
+      raise MissingParameterError.new("Parameter missing: details") unless params.dig(:details)
+
+      response, options = Api.send_request("/user_requests", :post, params, options)
+      UserRequest.new(response.data, options)
+    end
+
+    def self.delete(id, params = {}, options = {})
+      params ||= {}
+      params[:id] = id
+      raise InvalidParameterError.new("Bad parameter: id must be an Integer") if params.dig(:id) and !params.dig(:id).is_a?(Integer)
+      raise MissingParameterError.new("Parameter missing: id") unless params.dig(:id)
+
+      response, _options = Api.send_request("/user_requests/#{params[:id]}", :delete, params, options)
+      response.data
+    end
+
+    def self.destroy(id, params = {}, options = {})
+      delete(id, params, options)
+    end
+  end
+end

data/lib/files.com/response.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Files
+  class Response
+    attr_accessor :data, :http_body, :http_headers, :http_status
+
+    def self.from_faraday_hash(http_resp)
+      resp = new
+      resp.data = JSON.parse(http_resp[:body], symbolize_names: true) if http_resp[:status] != 204
+      resp.http_body = http_resp[:body]
+      resp.http_headers = http_resp[:headers]
+      resp.http_status = http_resp[:status]
+      resp
+    end
+
+    def self.from_faraday_response(http_resp)
+      resp = new
+      resp.data = JSON.parse(http_resp.body, symbolize_names: true) if http_resp.status != 204
+      resp.http_body = http_resp.body
+      resp.http_headers = http_resp.headers
+      resp.http_status = http_resp.status
+      resp
+    end
+  end
+end

data/lib/files.com/sizable_io.rb

@@ -0,0 +1,32 @@
+module Files
+  class SizableIO < IO
+    def self.pipe
+      r, w = super
+
+      w.instance_variable_set(:@read_io, r)
+
+      [ r, w ]
+    end
+
+    def size
+      read_io.content_length_promise.wait.value
+    end
+
+    def fulfill_content_length(length)
+      read_io.content_length = length
+      read_io.content_length_promise.execute
+    end
+
+    protected
+
+    attr_accessor :content_length
+
+    def content_length_promise
+      @content_length_promise ||= Concurrent::Promise.new { content_length }
+    end
+
+    def read_io
+      @read_io || self
+    end
+  end
+end

data/lib/files.com/system_profiler.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Files
+  class SystemProfiler
+    def self.uname
+      if ::File.exist?("/proc/version")
+        ::File.read("/proc/version").strip
+      else
+        case RbConfig::CONFIG["host_os"]
+        when /linux|darwin|bsd|sunos|solaris|cygwin/i
+          uname_from_system
+        when /mswin|mingw/i
+          uname_from_system_ver
+        else
+          "unknown platform"
+        end
+      end
+    end
+
+    def self.uname_from_system
+      (`uname -a 2>/dev/null` || "").strip
+    rescue Errno::ENOENT
+      "uname executable not found"
+    rescue Errno::ENOMEM # couldn't create subprocess
+      "uname lookup failed"
+    end
+
+    def self.uname_from_system_ver
+      (`ver` || "").strip
+    rescue Errno::ENOENT
+      "ver executable not found"
+    rescue Errno::ENOMEM # couldn't create subprocess
+      "uname lookup failed"
+    end
+
+    def initialize
+      @uname = self.class.uname
+    end
+
+    def user_agent
+      lang_version = "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})"
+
+      {
+        application: Files.app_info,
+        bindings_version: Files::VERSION,
+        lang: "ruby",
+        lang_version: lang_version,
+        platform: RUBY_PLATFORM,
+        engine: defined?(RUBY_ENGINE) ? RUBY_ENGINE : "",
+        publisher: "Action Verb LLC",
+        uname: @uname,
+        hostname: Socket.gethostname,
+      }.delete_if { |_k, v| v.nil? }
+    end
+  end
+end

data/lib/files.com/util.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Files
+  module Util
+    OPTS = Set[:api_key, :client, :session_id].freeze
+    COLOR_CODES = {
+      black:   0, light_black:   60,
+      red:     1, light_red:     61,
+      green:   2, light_green:   62,
+      yellow:  3, light_yellow:  63,
+      blue:    4, light_blue:    64,
+      magenta: 5, light_magenta: 65,
+      cyan:    6, light_cyan:    66,
+      white:   7, light_white:   67,
+      default: 9,
+    }.freeze
+
+    def self.colorize(val, color, isatty)
+      return val unless isatty
+
+      mode = 0 # default
+      foreground = 30 + COLOR_CODES.fetch(color)
+      background = 40 + COLOR_CODES.fetch(:default)
+
+      "\033[#{mode};#{foreground};#{background}m#{val}\033[0m"
+    end
+
+    def self.level_name(level)
+      case level
+      when LEVEL_DEBUG then "debug"
+      when LEVEL_ERROR then "error"
+      when LEVEL_INFO  then "info"
+      else level
+      end
+    end
+
+    def self.log_error(message, data = {})
+      if !Files.logger.nil? ||
+         !Files.log_level.nil? && Files.log_level <= Files::LEVEL_ERROR
+        log_internal(message, data, color: :cyan, level: Files::LEVEL_ERROR,
+                                    logger: Files.logger, out: $stderr
+        )
+      end
+    end
+
+    def self.log_info(message, data = {})
+      if !Files.logger.nil? ||
+         !Files.log_level.nil? && Files.log_level <= Files::LEVEL_INFO
+        log_internal(message, data, color: :cyan, level: Files::LEVEL_INFO,
+                                    logger: Files.logger, out: $stdout
+        )
+      end
+    end
+
+    def self.log_debug(message, data = {})
+      if !Files.logger.nil? ||
+         !Files.log_level.nil? && Files.log_level <= Files::LEVEL_DEBUG
+        log_internal(message, data, color: :blue, level: Files::LEVEL_DEBUG,
+                                    logger: Files.logger, out: $stdout
+        )
+      end
+    end
+
+    def self.log_internal(message, data = {}, color: nil, level: nil,
+                          logger: nil, out: nil)
+      data_str = data.reject { |_k, v| v.nil? }
+                     .map do |(k, v)|
+        format("%<key>s=%<value>s",
+               key: colorize(k, color, logger.nil? && !out.nil? && out.isatty),
+               value: v
+              )
+      end.join(" ")
+
+      if !logger.nil?
+        # the library's log levels are mapped to the same values as the
+        # standard library's logger
+        logger.log(level,
+                   format("message=%<message>s %<data_str>s",
+                          message: message,
+                          data_str: data_str
+                         )
+                  )
+      elsif out.isatty
+        out.puts format("%<level>s %<message>s %<data_str>s",
+                        level: colorize(level_name(level)[0, 4].upcase,
+                                        color, out.isatty
+                        ),
+                        message: message,
+                        data_str: data_str
+                       )
+      else
+        out.puts format("message=%<message>s level=%<level>s %<data_str>s",
+                        message: message,
+                        level: level_name(level),
+                        data_str: data_str
+                       )
+      end
+    end
+
+    def self.check_api_key!(key)
+      raise TypeError, "api_key must be a string" unless key.is_a?(String)
+
+      key
+    end
+  end
+end

data/lib/files.com/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Files
+  VERSION = "1.0"
+end

data/spec/list_spec.rb

@@ -0,0 +1,214 @@
+require "spec_helper"
+
+RSpec.describe Files::List do
+  ResourceWrapper = Struct.new(:object, :options)
+  let(:options) { { client: client } }
+  let(:client) { instance_double(Files::ApiClient, cursor: nil) }
+  let(:params) { {} }
+
+  describe "#auto_paging_each" do
+    context "when per_page is set" do
+      let(:params) { { per_page: per_page } }
+      let(:per_page) { 3 }
+
+      context "when response includes a cursor" do
+        let(:client) { instance_double(Files::ApiClient) }
+        let(:stubbed_cursors) {
+          [
+            '3',
+            '6',
+            nil
+          ]
+        }
+
+        before do
+          allow(client).to receive(:cursor).and_return(*stubbed_cursors)
+        end
+
+        it "does not call the API until out of responses" do
+          server_results = ('a'..'h').to_a
+          times_block_yielded = 0
+          request_cursor = nil
+          response_cursor = nil
+
+          list = described_class.new(ResourceWrapper, params) {
+            times_block_yielded += 1
+            request_cursor = params[:cursor]
+            range_start = params[:cursor] ? params[:cursor].to_i : 0
+
+            response_data = server_results[range_start, per_page]
+            response_cursor = (range_start + per_page).to_s
+            [
+              instance_double(Files::Response, data: response_data, http_status: 200, http_headers: { "x-files-cursor" => response_cursor }),
+              options
+            ]
+          }
+          results = list.auto_paging_each
+          expect(results.class).to eq(Enumerator::Lazy)
+          expect(times_block_yielded).to eq(0)
+          expect(results.next.object).to eq('a')
+          expect(times_block_yielded).to eq(1)
+          expect(request_cursor).to eq(nil)
+          expect(results.next.object).to eq('b')
+          expect(results.next.object).to eq('c')
+          expect(results.next.object).to eq('d')
+          expect(times_block_yielded).to eq(2)
+          expect(request_cursor).to eq("3")
+          expect(results.next.object).to eq('e')
+          expect(results.next.object).to eq('f')
+          expect(results.next.object).to eq('g')
+          expect(results.next.object).to eq('h')
+          expect(times_block_yielded).to eq(3)
+          expect(request_cursor).to eq("6")
+        end
+
+        it "stops calling the API once there is an error" do
+          server_results = ('a'..'h').to_a
+          times_block_yielded = 0
+          list = described_class.new(ResourceWrapper, params) {
+            times_block_yielded += 1
+            [
+              instance_double(Files::Response, data: server_results.shift(per_page), http_status: 400),
+              options
+            ]
+          }
+          results = list.auto_paging_each
+          expect(results.count).to eq(0)
+          expect(times_block_yielded).to eq(1)
+        end
+      end
+
+      context "when response does not include a cursor" do
+        let(:client) { instance_double(Files::ApiClient, cursor: nil) }
+
+        it "stops requesting any more results after the first try" do
+          server_results = ('a'..'h').to_a
+          times_block_yielded = 0
+          list = described_class.new(ResourceWrapper, params) {
+            times_block_yielded += 1
+            [
+              instance_double(Files::Response, data: server_results.shift(per_page), http_status: 200),
+              options
+            ]
+          }
+          results = list.auto_paging_each
+          expect(results.count).to eq(3)
+          expect(times_block_yielded).to eq(1)
+        end
+      end
+    end
+
+    it "returns all results at once" do
+      server_results = ('a'..'h').to_a
+      times_block_yielded = 0
+      list = described_class.new(ResourceWrapper, params) {
+        times_block_yielded += 1
+        [
+          instance_double(Files::Response, data: server_results, http_status: 200),
+          options
+        ]
+      }
+      results = list.auto_paging_each
+      expect(results.count).to eq(8)
+      expect(times_block_yielded).to eq(1)
+    end
+  end
+
+  describe "#each" do
+    it "returns all results at once" do
+      server_results = ('a'..'h').to_a
+      times_block_yielded = 0
+      results = described_class.new(ResourceWrapper, params) {
+        times_block_yielded += 1
+        [
+          instance_double(Files::Response, data: server_results, http_status: 200),
+          options
+        ]
+      }
+      expect(results.count).to eq(8)
+      expect(times_block_yielded).to eq(1)
+    end
+
+    context "when per_page is set" do
+      let(:params) { { per_page: per_page } }
+      let(:per_page) { 3 }
+
+      context "when response includes a cursor" do
+        let(:client) { instance_double(Files::ApiClient, cursor: "XXX-XXX") }
+
+        it "does not call the API until out of responses" do
+          server_results = ('a'..'h').to_a
+          times_block_yielded = 0
+          list = described_class.new(ResourceWrapper, params) {
+            times_block_yielded += 1
+            [
+              instance_double(Files::Response, data: server_results.shift(per_page), http_status: 200),
+              options
+            ]
+          }
+          results = list.enum_for(:each)
+          expect(times_block_yielded).to eq(0)
+          expect(results.next.object).to eq('a')
+          expect(times_block_yielded).to eq(1)
+          expect(results.next.object).to eq('b')
+          expect(results.next.object).to eq('c')
+          next_results = list.next_page.enum_for(:each)
+          expect(times_block_yielded).to eq(2)
+          expect(next_results.next.object).to eq('d')
+          expect(next_results.next.object).to eq('e')
+          expect(next_results.next.object).to eq('f')
+          next_results = list.next_page.enum_for(:each)
+          expect(times_block_yielded).to eq(3)
+          expect(next_results.next.object).to eq('g')
+          expect(next_results.next.object).to eq('h')
+          next_results = list.next_page.enum_for(:each)
+          expect(next_results.count).to eq(0)
+        end
+
+        it "return the same data when call more than once" do
+          server_results = ('a'..'h').to_a
+          list = described_class.new(ResourceWrapper, params) {
+            [
+              instance_double(Files::Response, data: server_results.shift(per_page), http_status: 200),
+              options
+            ]
+          }
+          expect(list.to_a).to eq(list.to_a)
+        end
+
+        it "stops calling the API once there is an error" do
+          server_results = ('a'..'h').to_a
+          times_block_yielded = 0
+          results = described_class.new(ResourceWrapper, params) {
+            times_block_yielded += 1
+            [
+              instance_double(Files::Response, data: server_results, http_status: 400),
+              options
+            ]
+          }
+          expect(results.count).to eq(0)
+          expect(times_block_yielded).to eq(1)
+        end
+      end
+
+      context "when response does not include a cursor" do
+        let(:client) { instance_double(Files::ApiClient, cursor: nil) }
+
+        it "stops requesting any more results after the first try" do
+          server_results = ('a'..'h').to_a
+          times_block_yielded = 0
+          list = described_class.new(ResourceWrapper, params) {
+            times_block_yielded += 1
+            [
+              instance_double(Files::Response, data: server_results, http_status: 200),
+              options
+            ]
+          }
+          results = list.enum_for(:each)
+          expect(results.count).to eq(8)
+          expect(times_block_yielded).to eq(1)
+        end
+      end
+    end
+  end
+end