tableau_server_client 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 492e70dc7a49eb33db9318b3ace0065b36cdb19d
+  data.tar.gz: d0bddfa685157808e77380898bc05d74bedacd89
+SHA512:
+  metadata.gz: 311e2452bd507ab1359e22bf690f835f6849e26bc7b689efd6e0c386e4cfadaf2952b5528189d474368d772193fd963386b686965f74f8ab0a4f8988a11e29e2
+  data.tar.gz: 17f5966cfb76ef52acb0748ff98209a279a951eb6bffd2416e6e6d6ef66648216afb2c2abe1e52d993a5b0ccaa850cfe4cac94fe6e96cd9953a0abb10ac2c4aa

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in pipelined_my_import.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,51 @@
+PATH
+  remote: .
+  specs:
+    tableau_server_client (0.0.1)
+      faraday (>= 0.14.0)
+      nokogiri (>= 1.8.2)
+      pry (>= 0.11.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    byebug (10.0.2)
+    coderay (1.1.2)
+    diff-lcs (1.3)
+    faraday (0.14.0)
+      multipart-post (>= 1.2, < 3)
+    method_source (0.9.0)
+    mini_portile2 (2.3.0)
+    multipart-post (2.0.0)
+    nokogiri (1.8.2)
+      mini_portile2 (~> 2.3.0)
+    pry (0.11.3)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    rake (10.5.0)
+    rspec (3.7.0)
+      rspec-core (~> 3.7.0)
+      rspec-expectations (~> 3.7.0)
+      rspec-mocks (~> 3.7.0)
+    rspec-core (3.7.1)
+      rspec-support (~> 3.7.0)
+    rspec-expectations (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-mocks (3.7.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.7.0)
+    rspec-support (3.7.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.13)
+  byebug
+  rake (~> 10.0)
+  rspec (~> 3.0)
+  tableau_server_client!
+
+BUNDLED WITH
+   1.16.0.pre.3

data/README.md

@@ -0,0 +1 @@
+# tableau-client

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'tableau-server-client/server'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require 'pry'
+Pry.start

data/lib/tableau-server-client/client.rb

@@ -0,0 +1,120 @@
+require 'uri'
+require 'faraday'
+require 'nokogiri'
+require 'tableau-server-client/request_url'
+require 'tableau-server-client/request_builder'
+require 'tableau-server-client/token'
+require 'tableau-server-client/paginatable_response'
+
+module TableauServerClient
+
+  class Client
+    include RequestBuilder
+
+    def initialize(server_url, username, password, site_name, api_version, token_lifetime, logger)
+      @server_url = server_url
+      @username = username
+      @password = password
+      @site_name = site_name
+      @api_version = api_version
+      @token_lifetime = token_lifetime
+      @logger
+    end
+
+    attr_reader :site_name, :username, :api_version, :token_lifetime, :logger
+
+    def server_url
+      @_server_url ||= URI(@server_url.chomp("/"))
+    end
+
+    def get_collection(resource_location, &block)
+      return self.to_enum(:get_collection, resource_location) unless block
+      req_url = request_url(resource_location.path, resource_location.query_params)
+      response = session.get req_url.to_s
+      TableauServerClient::PaginatableResponse.new(self, req_url, response).each_body do |b|
+        resource_location.klass.from_collection_response(self, resource_location.path, b) {|r| yield r }
+      end
+    end
+
+    def get(resource_location)
+      req_url = request_url(resource_location.path)
+      response = session.get req_url.to_s
+      resource_location.klass.from_response(self, resource_location.path, Nokogiri::XML(response.body))
+    end
+
+    def create(resource)
+    end
+
+    def delete(resource)
+    end
+
+    def update(resource)
+      session.put do |req|
+        req.url request_url(resource.path).to_s
+        req.body = resource.to_request
+      end
+    end
+
+    def session
+      faraday.headers['X-Tableau-Auth'] = token.to_s
+      faraday
+    end
+
+    def token
+      unless @token and @token.valid?
+        @token = signin
+      end
+      @token
+    end
+
+    private
+
+    attr_reader :password
+
+    def request_url(path, query_params={})
+      RequestUrl.new(server_url, api_version, path, query_params)
+    end
+
+    def request_body(&block)
+      build_request &block
+    end
+
+    def signin
+      request = request_body {|b|
+        b.credentials(name: username, password: password) {
+          b.site(contentUrl: content_url)
+        }
+      }
+      # POST without Token
+      res = faraday.post do |req|
+        req.url request_url("auth/signin").to_s
+        req.body = request
+      end
+      @token = TableauServerClient::Token.parse(res.body, token_lifetime)
+    end
+
+    def content_url
+      site_name == 'default' ? "" : site_name
+    end
+
+    def faraday
+      @faraday ||= Faraday.new(request: {params_encoder: EmptyEncoder.new}, headers: {'Content-Type' => 'application/xml'}) do |f|
+        f.response :raise_error
+        #TODO Cannot set log level (always print debug log)
+        #f.response :logger, logger
+        f.adapter Faraday.default_adapter
+      end
+    end
+
+    class EmptyEncoder
+      def encode(hash)
+        hash.keys.map {|k| "#{k}=#{hash[k]}" }.join('&')
+      end
+
+      def decode(str)
+        str.split('&').map {|p| p.split('=') }.to_h
+      end
+    end
+
+  end
+end

data/lib/tableau-server-client/paginatable_response.rb

@@ -0,0 +1,73 @@
+require 'nokogiri'
+
+module TableauServerClient
+  class PaginatableResponse
+    include Enumerable
+
+    def initialize(client, request_url, response)
+      @client = client
+      @request_url = request_url
+      @response = response
+    end
+
+    def each
+      yield @response
+      return unless paginated?
+      res = @response.dup
+      url = @request_url.dup
+      while true
+        pgn = Pagination.parse(res.body)
+        break unless pgn.next_page?
+        res = @client.session.get url.merge_params!(pgn.request_params).to_s
+        yield res
+      end
+    end
+
+    def each_body
+      each do |res|
+        yield Nokogiri::XML(res.body)
+      end
+    end
+
+    private
+
+    def paginated?
+      @paginated ||= !Pagination.parse(@response.body).nil?
+    end
+
+    class Pagination
+      def initialize(page_number, page_size, total_available)
+        @page_numner = page_number
+        @page_size = page_size
+        @total_available = total_available
+      end
+
+      def page_number
+        @page_number.to_i
+      end
+
+      def page_size
+        @page_size.to_i
+      end
+
+      def total_available
+        @total_available.to_i
+      end
+
+      def self.parse(xml)
+        pg = Nokogiri::XML(xml).xpath("//xmlns:pagination")[0]
+        return nil unless pg
+        Pagination.new(pg['pageNumber'], pg['pageSize'], pg['totalAvailable'])
+      end
+
+      def next_page?
+        page_number * page_size > total_available
+      end
+
+      def request_params
+        { pageSize: page_size, pageNumber: page_number + 1 }
+      end
+    end
+
+  end
+end

data/lib/tableau-server-client/request_builder.rb

@@ -0,0 +1,16 @@
+require 'nokogiri'
+
+module TableauServerClient
+  module RequestBuilder
+
+    def build_request
+      builder = Nokogiri::XML::Builder.new do |xml|
+        xml.tsRequest {
+          yield xml
+        }
+      end
+      builder.to_xml
+    end
+
+  end
+end

data/lib/tableau-server-client/request_url.rb

@@ -0,0 +1,29 @@
+require 'uri'
+
+module TableauServerClient
+  class RequestUrl
+    def initialize(url, api_version, path, params)
+      @url = url
+      @api_version = api_version
+      @path = path
+      @params = params
+    end
+
+    attr_reader :url, :api_version
+    attr_accessor :path, :params
+
+    def merge_params!(params)
+      @params.merge!(params)
+      self
+    end
+
+    def to_s
+      URI("#{url}/api/#{api_version}/#{path}?#{query_params}").to_s
+    end
+
+    def query_params
+      return "" if params.empty?
+      params.keys.map {|k| URI.encode("#{k}=#{params[k]}") }.join("&")
+    end
+  end
+end

data/lib/tableau-server-client/resources/connection.rb

@@ -0,0 +1,37 @@
+require 'tableau-server-client/resources/resource'
+
+module TableauServerClient
+  module Resources
+
+    class Connection < Resource
+
+      attr_reader :id, :type, :server_address, :server_port, :user_name, :password, :embed_password
+      attr_writer :user_name, :password, :embed_password
+
+      def self.from_response(client, path, xml)
+        attrs = extract_attributes(xml)
+        new(client, path, attrs)
+      end
+
+      def self.from_collection_response(client, path, xml)
+        xml.xpath("//xmlns:connections/xmlns:connection").each do |s|
+          id = s['id']
+          yield from_response(client, "#{path}/#{id}", s)
+        end
+      end
+
+      def to_request
+        request = build_request {|b|
+          b.connection(serverAddress: server_address, serverPort: server_port,
+                       userName: user_name, password: password, embedPassword: embed_password)
+        }
+      end
+
+      def update!
+        @client.update self
+      end
+
+    end
+
+  end
+end

data/lib/tableau-server-client/resources/datasource.rb

@@ -0,0 +1,35 @@
+require 'tableau-server-client/resources/resource'
+require 'tableau-server-client/resources/project'
+require 'tableau-server-client/resources/connection'
+
+module TableauServerClient
+  module Resources
+
+    class Datasource < Resource
+
+      attr_reader :id, :name, :content_url, :type, :created_at, :updated_at, :is_certified, :project, :owner
+
+      def self.from_response(client, path, xml)
+        attrs = extract_attributes(xml)
+        project = xml.xpath("xmlns:project")[0]
+        site_path = extract_site_path(path)
+        project_path = "#{site_path}/projects/#{project['id']}"
+        attrs['project'] = Project.from_response(client, project_path, project)
+        #TODO add owner
+        new(client, path, attrs)
+      end
+
+      def self.from_collection_response(client, path, xml)
+        xml.xpath("//xmlns:datasources/xmlns:datasource").each do |s|
+          id = s['id']
+          yield from_response(client, "#{path}/#{id}", s)
+        end
+      end
+
+      def connections
+        @client.get_collection Connection.location(path)
+      end
+
+    end
+  end
+end

data/lib/tableau-server-client/resources/project.rb

@@ -0,0 +1,35 @@
+require 'tableau-server-client/resources/resource'
+
+module TableauServerClient
+  module Resources
+
+    class Project < Resource
+
+      attr_reader :id, :name, :description, :content_permissions
+
+      def self.from_response(client, path, xml)
+        attrs = extract_attributes(xml)
+        new(client, path, attrs)
+      end
+
+      def self.from_collection_response(client, path, xml)
+        xml.xpath("//xmlns:projects/xmlns:project").each do |s|
+          id = s['id']
+          yield from_response(client, "#{path}/#{id}", s)
+        end
+      end
+
+      def reload
+        prjs = @client.get_collection Project.location(site_path, filter: ["name:eq:#{name}"])
+        prjs.select {|p| p.id == id }.first
+      end
+
+      def redshift_username
+        if md = description.match(/^REDSHIFT_USERNAME: (.+)$/)
+          return md[1]
+        end
+      end
+
+    end
+  end
+end

data/lib/tableau-server-client/resources/resource.rb

@@ -0,0 +1,88 @@
+module TableauServerClient
+  module Resources
+
+    class Resource
+      include RequestBuilder
+
+      def initialize(client, path, attributes)
+        @client = client
+        @path = path
+        attributes.each {|k,v| instance_variable_set("@#{k}",v) }
+      end
+
+      def self.attr_reader(*vars)
+          @attributes ||= []
+          @attributes.concat (vars.map { |v| Attribute.new(v.to_s) })
+          super(*vars)
+      end
+
+      def self.attributes
+        @attributes
+      end
+
+      def self.resource_name
+        self.name.split("::").last.downcase
+      end
+
+      def self.location(prefix, id=nil, filter: [])
+        path = [prefix, "#{resource_name}s", id].compact.join("/")
+        Location.new(self, path, filter)
+      end
+
+      def self.extract_attributes(xml)
+        unless xml.name == resource_name
+          raise "Element name (#{xml.name}) does not match with resource name (#{resource_name})"
+        end
+        attributes.select {|a| xml.key?(a.camelCase) }.map {|a| [a.to_sym, xml[a.camelCase]] }.to_h
+      end
+
+      def self.extract_site_path(path)
+        p = path.split('/')
+        p.slice(p.index('sites'),2).join('/')
+      end
+
+      def attributes
+        self.class.attributes
+      end
+
+      def path
+        @path
+      end
+
+      def site_path
+        self.class.extract_site_path(path)
+      end
+
+      class Location
+
+        def initialize(klass, path, filter)
+          @klass = klass
+          @path = path
+          @filter = filter
+        end
+
+        attr_reader :klass, :path
+
+        def filter
+          @filter.empty? ? {} : {filter: @filter.join(",")}
+        end
+
+        def query_params
+          filter
+        end
+      end
+
+      class Attribute < String
+
+        def camelCase
+         atr = self.split("_").map{ |w| w.capitalize }.join
+         atr[0] = atr[0].downcase
+         atr
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/tableau-server-client/resources/schedule.rb

@@ -0,0 +1,24 @@
+require 'tableau-server-client/resources/resource'
+
+module TableauServerClient
+  module Resources
+
+    class Schedule < Resource
+
+      attr_reader :id, :name, :state, :priority, :created_at, :updated_at, :type, :frequency, :next_run_at
+
+      def self.from_response(client, path, xml)
+        attrs = extract_attributes(xml)
+        new(client, path, attrs)
+      end
+
+      def self.from_collection_response(client, path, xml)
+        xml.xpath("//xmlns:schedules/xmlns:schedule").each do |s|
+          id = s.xpath("//xmlns:schedule/@id")[0].value
+          yield from_response(client, path, s)
+        end
+      end
+
+    end
+  end
+end

data/lib/tableau-server-client/resources/site.rb

@@ -0,0 +1,42 @@
+require 'tableau-server-client/resources/resource'
+require 'tableau-server-client/resources/datasource'
+require 'tableau-server-client/resources/workbook'
+
+module TableauServerClient
+  module Resources
+
+    class Site < Resource
+
+      attr_reader :id, :name, :content_url, :admin_mode, :storage_quota, :state
+
+      def self.from_response(client, path, xml)
+        attrs = extract_attributes(xml)
+        new(client, path, attrs)
+      end
+
+      def self.from_collection_response(client, path, xml)
+        xml.xpath("//xmlns:sites/xmlns:site").each do |s|
+          id = s['id']
+          yield from_response(client, "#{path}/#{id}", s)
+        end
+      end
+
+      def datasources(filter: [])
+        @client.get_collection Datasource.location(path, filter: filter)
+      end
+
+      def datasource(id)
+        @client.get Datasource.location(path, id)
+      end
+
+      def workbooks(filter: [])
+        @client.get_collection Workbook.location(path, filter: filter)
+      end
+
+      def workbook(id)
+        @client.get Workbook.location(path, id)
+      end
+
+    end
+  end
+end

data/lib/tableau-server-client/resources/workbook.rb

@@ -0,0 +1,35 @@
+require 'tableau-server-client/resources/resource'
+require 'tableau-server-client/resources/project'
+require 'tableau-server-client/resources/connection'
+
+module TableauServerClient
+  module Resources
+
+    class Workbook < Resource
+
+      attr_reader :id, :name, :content_url, :show_tabs, :size, :created_at, :updated_at, :project, :owner
+
+      def self.from_response(client, path, xml)
+        attrs = extract_attributes(xml)
+        project = xml.xpath("xmlns:project")[0]
+        site_path = extract_site_path(path)
+        project_path = "#{site_path}/projects/#{project['id']}"
+        attrs['project'] = Project.from_response(client, project_path, project)
+        #TODO add owner
+        new(client, path, attrs)
+      end
+
+      def self.from_collection_response(client, path, xml)
+        xml.xpath("//xmlns:workbooks/xmlns:workbook").each do |s|
+          id = s['id']
+          yield from_response(client, "#{path}/#{id}", s)
+        end
+      end
+
+      def connections
+        @client.get_collection Connection.location(path)
+      end
+
+    end
+  end
+end

data/lib/tableau-server-client/server.rb

@@ -0,0 +1,37 @@
+require 'tableau-server-client/client'
+require 'tableau-server-client/resources/site'
+require 'tableau-server-client/resources/schedule'
+require 'logger'
+
+module TableauServerClient
+  class Server
+
+    def initialize(server_url, username, password,
+                   site_name: "default", api_version: "2.8", token_lifetime: 240)
+      @logger = ::Logger.new(STDOUT)
+      @logger.level = ::Logger::INFO
+      @client = Client.new(server_url, username, password, site_name, api_version, token_lifetime, @logger)
+    end
+
+    def sites
+      client.get_collection Resources::Site.location(path)
+    end
+
+    def site(id)
+      client.get Resources::Site.location(path, id)
+    end
+
+    def schedules
+      client.get_collection Resources::Schedule.location(path)
+    end
+
+    def path
+      nil
+    end
+
+    private
+
+    attr_reader :client
+
+  end
+end

data/lib/tableau-server-client/token.rb

@@ -0,0 +1,36 @@
+require 'nokogiri'
+
+module TableauServerClient
+
+  class Token
+
+    def initialize(site_id, user_id, token, lifetime, created_at = Time.now)
+      @site_id = site_id
+      @user_id = user_id
+      @token = token
+      @lifetime = lifetime
+      @created_at = created_at
+    end
+
+    attr_reader :site_id, :user_id, :token
+
+    def self.parse(xml, lifetime)
+      cred = Nokogiri::XML(xml).xpath("//xmlns:credentials")
+      sid = cred.xpath("//xmlns:site")[0]['id']
+      uid = cred.xpath("//xmlns:user")[0]['id']
+      new(sid, uid, cred[0]['token'], lifetime)
+    end
+
+    SAFETY_BUFFER_MIN = 10
+
+    def valid?
+      Time.now < @created_at + (@lifetime + SAFETY_BUFFER_MIN) * 60
+    end
+
+    def to_s
+      @token
+    end
+
+  end
+
+end

data/lib/tableau-server-client/version.rb

@@ -0,0 +1,3 @@
+module TableauServerClient
+  VERSION = "0.0.3"
+end

data/tableau_server_client.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'tableau-server-client/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "tableau_server_client"
+  spec.version       = TableauServerClient::VERSION
+  spec.authors       = ["shimpeko"]
+  spec.email         = ["shimpeko@swimmingpython.com"]
+
+  spec.summary       = %q{Tableau Server REST API Client}
+  spec.description   = %q{REST API Client for Tableau Server.}
+  spec.homepage      = "https://github.com/shimpeko/tableau-server-client"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "bin"
+  spec.executables   = ["console"]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "byebug"
+
+  spec.add_dependency 'faraday', '>= 0.14.0'
+  spec.add_dependency 'nokogiri', '>= 1.8.2'
+  spec.add_dependency 'pry', '>= 0.11.3'
+end

metadata

@@ -0,0 +1,163 @@
+--- !ruby/object:Gem::Specification
+name: tableau_server_client
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- shimpeko
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-04-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.2
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.3
+description: REST API Client for Tableau Server.
+email:
+- shimpeko@swimmingpython.com
+executables:
+- console
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/console
+- lib/tableau-server-client/client.rb
+- lib/tableau-server-client/paginatable_response.rb
+- lib/tableau-server-client/request_builder.rb
+- lib/tableau-server-client/request_url.rb
+- lib/tableau-server-client/resources/connection.rb
+- lib/tableau-server-client/resources/datasource.rb
+- lib/tableau-server-client/resources/project.rb
+- lib/tableau-server-client/resources/resource.rb
+- lib/tableau-server-client/resources/schedule.rb
+- lib/tableau-server-client/resources/site.rb
+- lib/tableau-server-client/resources/workbook.rb
+- lib/tableau-server-client/server.rb
+- lib/tableau-server-client/token.rb
+- lib/tableau-server-client/version.rb
+- tableau_server_client.gemspec
+homepage: https://github.com/shimpeko/tableau-server-client
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: Tableau Server REST API Client
+test_files: []