superset 0.2.5 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78b162c6717782494955c5f03e690639d0d8b2e3b32ce470ca8c2bc702a07006
-  data.tar.gz: e29075c257b3dceeaa66c4c8c658e525b1e409520497552ab062525ad9523d97
+  metadata.gz: c6b2b4cb255df5113b61de937f565c6f004c5df347bb047f0c47e6f1c06eadd2
+  data.tar.gz: a34377f58a2dbbfc0bcbcf7a897bee918760707c01b33c41d1119af0d940840d
 SHA512:
-  metadata.gz: 7b809cc5af02b9133b983bb10952830b4749b7249706667292ed6d1fcdbbaa3f67b8e99c9f12dd71fbc0141b599448dcdb939a3e4c720fd1b31703959ac6e0fe
-  data.tar.gz: c90cb4464d4f267367d3a53d5b79c55aa5d5acdcdb4ad2ca6af2483d3edb3603a1056447c888a0b643aa3e21ebdd387486d1f2319bdf97941a97729d42e06c3e
+  metadata.gz: c734a5177395f6981fa7733ee0a6c44c1839ca080eb18ad9c4c6e8d12f7adb2948f7710c5d5d2c13015c855cce03169b0ddf5b93254e17929173e3a81503501b
+  data.tar.gz: 3db00f88ca7dd063ace17729b41cc5c5c7e30b3b77ef37a15ccee83873cbe02caf1460bd30b397a4d28a7d3971179f57d9b0194a186ebf05b194e90a050ed650

data/.ruby-version

@@ -0,0 +1 @@
+2.7.8

data/CHANGELOG.md

@@ -1,5 +1,17 @@
 ## Change Log
 
+## 0.2.7 - 2025-10-16
+* add to_h method to list classes for Hash output
+* add ids method to list classes for array of ids output
+* add ability to over ride default page_size
+* add ruby console auto timeout set to 30 mins by default
+* add GetCatalogs endpoint caller
+* fix catalog bug related to dashboard export and import across env
+* add tag_equals param to dashboard list class
+
+## 0.2.6 - 2025-08-05
+* Bump terminal-table from 1.8.0 to 4.0.0
+
 ## 0.2.5 - 2025-05-22
 * add refresh dataset call in `Superset::Dataset::Refresh.call(id)`
 
@@ -79,6 +91,3 @@
 - add security/user endpoints
 - add security/role endpoints
 - add security/role/permission endpoints
-
-
-

data/doc/migrating_dashboards_across_environments.md

@@ -20,12 +20,12 @@ Assuming your API env for ruby is setup for your target superset environment.
 
 new_import_zip = Superset::Services::ImportDashboardAcrossEnvironments.new(
   dashboard_export_zip:      'path_to/dashboard_101_export_20241010.zip',
-  target_database_yaml_file: 'path_to/env2_db_config.yaml', 
-  target_database_schema:    'acme', 
+  target_database_yaml_file: 'path_to/env2_db_config.yaml',
+  target_database_schema:    'acme',
   ).perform
 
 # now import the adjusted zip to the target superset env
-Superset::Dashboard::Import.new(source_zip_file: new_import_file).perform
+Superset::Dashboard::Import.new(source: new_import_file).perform
 
 ```
 
@@ -170,4 +170,4 @@ It will attempt to update the same dashboard as the UUID for the dashboard has n
 
 Some helpful references relating to cross-environment workflows:
 - [Managing Content Across Workspaces](https://docs.preset.io/docs/managing-content-across-workspaces)
-- [Superset Slack AI Explanation](https://apache-superset.slack.com/archives/C072KSLBTC1/p1722382347022689)
+- [Superset Slack AI Explanation](https://apache-superset.slack.com/archives/C072KSLBTC1/p1722382347022689)

data/lib/superset/chart/list.rb

@@ -2,13 +2,13 @@ module Superset
   module Chart
     class List < Superset::Request
 
-      attr_reader :name_contains, :dashboard_id_eq, :dataset_id_eq
+      attr_reader :title_contains, :dashboard_id_eq, :dataset_id_eq
 
-      def initialize(page_num: 0, name_contains: '', dashboard_id_eq: '', dataset_id_eq: '')
-        @name_contains = name_contains
+      def initialize(title_contains: '', dashboard_id_eq: '', dataset_id_eq: '', **kwargs)
+        @title_contains = title_contains
         @dashboard_id_eq = dashboard_id_eq
         @dataset_id_eq = dataset_id_eq
-        super(page_num: page_num)
+        super(**kwargs)
       end
 
       def self.call
@@ -38,7 +38,7 @@ module Superset
       def filters
         # TODO filtering across all classes needs a refactor to support multiple options in a more flexible way
         filter_set = []
-        filter_set << "(col:slice_name,opr:ct,value:'#{name_contains}')" if name_contains.present?
+        filter_set << "(col:slice_name,opr:ct,value:'#{title_contains}')" if title_contains.present?
         filter_set << "(col:dashboards,opr:rel_m_m,value:#{dashboard_id_eq})" if dashboard_id_eq.present? # rel many to many
         filter_set << "(col:datasource_id,opr:eq,value:#{dataset_id_eq})" if dataset_id_eq.present?
 

data/lib/superset/dashboard/import.rb

@@ -1,29 +1,32 @@
-# Import the provided Dashboard zip file
+# frozen_string_literal: true
+
+# Import the provided Dashboard zip file or directory (aka source)
 # In the context of this API import process, assumption is that the database.yaml file details will match
 # an existing database in the Target Superset Environment.
 
 # Scenario 1: Export from Env1 -- Import to Env1 into the SAME Environment
-#             Will result in updating/over writing the dashboard with the contents of the zip file 
+#             Will result in updating/over writing the dashboard with the contents of the source
 
 # Scenario 2: Export from Env1 -- Import to Env2 into a DIFFERENT Environment
-#             Assumption is that the database.yaml will match a database configuration in the target env. 
-#             Initial import will result in creating a new dashboard with the contents of the zip file. 
-#             Subsequent imports will result in updating/over writing the previous imported dashboard with the contents of the zip file.
+#             Assumption is that the database.yaml will match a database configuration in the target env.
+#             Initial import will result in creating a new dashboard with the contents of the source.
+#             Subsequent imports will result in updating/over writing the previous imported dashboard with the contents of the source.
 
 # the overwrite flag will determine if the dashboard will be updated or created new
 # overwrite: false .. will result in an error if a dashboard with the same UUID already exists
 
 # Usage
-# Superset::Dashboard::Import.new(source_zip_file: '/tmp/dashboard.zip').perform
+# Superset::Dashboard::Import.new(source: '/tmp/dashboard.zip').perform
+# Superset::Dashboard::Import.new(source: '/tmp/dashboard').perform
 #
 
 module Superset
   module Dashboard
     class Import < Request
-      attr_reader :source_zip_file, :overwrite
+      attr_reader :source, :overwrite
 
-      def initialize(source_zip_file: , overwrite: true)
-        @source_zip_file = source_zip_file
+      def initialize(source:, overwrite: true)
+        @source = source
         @overwrite = overwrite
       end
 
@@ -42,16 +45,20 @@ module Superset
       private
 
       def validate_params
-        raise ArgumentError, 'source_zip_file is required' if source_zip_file.nil?
-        raise ArgumentError, 'source_zip_file does not exist' unless File.exist?(source_zip_file)
-        raise ArgumentError, 'source_zip_file is not a zip file' unless File.extname(source_zip_file) == '.zip'
-        raise ArgumentError, 'overwrite must be a boolean' unless [true, false].include?(overwrite)
-        raise ArgumentError, "zip target database does not exist: #{zip_database_config_not_found_in_superset}" if zip_database_config_not_found_in_superset.present?
+        raise ArgumentError, "source is required" if source.nil?
+        raise ArgumentError, "source does not exist" unless File.exist?(source)
+        raise ArgumentError, "source is not a zip file or directory" unless zip? || directory?
+        raise ArgumentError, "overwrite must be a boolean" unless [true, false].include?(overwrite)
+
+        return unless database_config_not_found_in_superset.present?
+
+        raise ArgumentError,
+              "target database does not exist: #{database_config_not_found_in_superset}"
       end
 
       def payload
         {
-          formData: Faraday::UploadIO.new(source_zip_file, 'application/zip'),
+          formData: Faraday::UploadIO.new(source_zip_file, "application/zip"),
           overwrite: overwrite.to_s
         }
       end
@@ -60,24 +67,66 @@ module Superset
         "dashboard/import/"
       end
 
-      def zip_database_config_not_found_in_superset
-        zip_databases_details.select {|s| !superset_database_uuids_found.include?(s[:uuid]) }
+      def zip?
+        File.extname(source) == ".zip"
       end
 
-      def superset_database_uuids_found
-        @superset_database_uuids_found ||= begin
-          zip_databases_details.map {|i| i[:uuid]}.map do |uuid|
-            uuid if Superset::Database::List.new(uuid_equals: uuid).result.present?
-          end.compact
+      def directory?
+        File.directory?(source)
+      end
+
+      def source_zip_file
+        return source if zip?
+
+        Zip::File.open(new_zip_file, Zip::File::CREATE) do |zipfile|
+          Dir[File.join(source, "**", "**")].each do |file|
+            next unless File.file?(file)
+
+            # add a base folder to the relative path: "dashboard_import_#{timestamp}"
+            zipfile.add(File.join("dashboard_import_#{timestamp}", relative_path(file)), file)
+          end
         end
+        new_zip_file
+      end
+
+      def relative_path(file)
+        Pathname.new(file).relative_path_from(Pathname.new(source)).to_s
+      end
+
+      def new_zip_file
+        File.join(source, "dashboard_import_#{timestamp}.zip")
       end
 
-      def zip_databases_details
-        zip_dashboard_config[:databases].map{|d| {uuid: d[:content][:uuid], name: d[:content][:database_name]} }
+      def timestamp
+        @timestamp ||= Time.now.strftime("%Y%m%d%H%M%S")
+      end
+
+      def database_config_not_found_in_superset
+        databases_details.reject { |s| superset_database_uuids_found.include?(s[:uuid]) }
+      end
+
+      def superset_database_uuids_found
+        @superset_database_uuids_found ||= databases_details.map { |i| i[:uuid] }.map do |uuid|
+          uuid if Superset::Database::List.new(uuid_equals: uuid).result.present?
+        end.compact
+      end
+
+      def databases_details
+        dashboard_config[:databases].map { |d| { uuid: d[:content][:uuid], name: d[:content][:database_name] } }
+      end
+
+      def dashboard_config
+        @dashboard_config ||= zip? ? zip_dashboard_config : directory_dashboard_config
       end
 
       def zip_dashboard_config
-        @zip_dashboard_config ||= Superset::Services::DashboardLoader.new(dashboard_export_zip: source_zip_file).perform
+        Superset::Services::DashboardLoader.new(dashboard_export_zip: source).perform
+      end
+
+      def directory_dashboard_config
+        Superset::Services::DashboardLoader::DashboardConfig.new(
+          dashboard_export_zip: "", tmp_uniq_dashboard_path: source
+        ).config
       end
     end
   end

data/lib/superset/dashboard/list.rb

@@ -5,15 +5,18 @@
 module Superset
   module Dashboard
     class List < Superset::Request
-      attr_reader :title_contains, :title_equals, :tags_equal, :ids_not_in, :include_filter_dataset_schemas
+      attr_reader :title_contains, :title_equals,
+                  :tags_contain, :tags_equal,
+                  :ids_not_in, :include_filter_dataset_schemas
 
-      def initialize(page_num: 0, title_contains: '', title_equals: '', tags_equal: [], ids_not_in: [], include_filter_dataset_schemas: false)
+      def initialize(title_contains: '', title_equals: '', tags_contain: [], tags_equal: [], ids_not_in: [], include_filter_dataset_schemas: false, **kwargs)
         @title_contains = title_contains
         @title_equals = title_equals
+        @tags_contain = tags_contain
         @tags_equal = tags_equal
         @ids_not_in = ids_not_in
         @include_filter_dataset_schemas = include_filter_dataset_schemas
-        super(page_num: page_num)
+        super(**kwargs)
       end
 
       def self.call
@@ -57,8 +60,16 @@ module Superset
         end
       end
 
+      def to_h
+        result.map do |d|
+          list_attributes.to_h do |la|
+            la == :url ? [la, "#{superset_host}#{d[la]}"] : [la, d[la]]
+          end
+        end
+      end
+
       def ids
-        result.map { |d| d[:id] }
+        result.is_a?(Hash) ? [result[:id]] : result.map { |d| d[:id] }
       end
 
       private
@@ -72,15 +83,30 @@ module Superset
         filter_set = []
         filter_set << "(col:dashboard_title,opr:ct,value:'#{title_contains}')" if title_contains.present?
         filter_set << "(col:dashboard_title,opr:eq,value:'#{title_equals}')" if title_equals.present?
-        filter_set << tag_filters if tags_equal.present?
+        filter_set << tags_contain_filters if tags_contain.present?
+        filter_set << tags_equal_filters if tags_equal.present?
         filter_set << ids_not_in_filters if ids_not_in.present?
+
         unless filter_set.empty?
           "filters:!(" + filter_set.join(',') + "),"
         end
       end
 
-      def tag_filters
-        tags_equal.map {|tag| "(col:tags,opr:dashboard_tags,value:'#{tag}')"}.join(',')
+      def tags_equal_filters
+        tags_equal_ids.map { |id| "(col:tags,opr:dashboard_tag_id,value:#{id})" }.join(',')
+      end
+
+      def tags_equal_ids
+        tags_equal.map do |tag_name|
+          ids = Superset::Tag::List.new(name_equals: tag_name).rows.map(&:first)
+          raise "No ID found for tag: #{tag_name}" if ids.empty?
+          raise "Multiple IDs found for tag: #{tag_name}" if ids.size > 1
+          ids.first
+        end
+      end
+
+      def tags_contain_filters
+        tags_contain.map {|tag| "(col:tags,opr:dashboard_tags,value:'#{tag}')"}.join(',')
       end
 
       def ids_not_in_filters
@@ -94,8 +120,8 @@ module Superset
       def validate_constructor_args
         raise InvalidParameterError, "title_contains must be a String type" unless title_contains.is_a?(String)
         raise InvalidParameterError, "title_equals must be a String type" unless title_equals.is_a?(String)
-        raise InvalidParameterError, "tags_equal must be an Array type" unless tags_equal.is_a?(Array)
-        raise InvalidParameterError, "tags_equal array must contain string only values" unless tags_equal.all? { |item| item.is_a?(String) }
+        raise InvalidParameterError, "tags_contain must be an Array type of String values" unless tags_contain.is_a?(Array) && tags_contain.all? { |item| item.is_a?(String) }
+        raise InvalidParameterError, "tags_equal must be an Array type of String values" unless tags_equal.is_a?(Array) && tags_equal.all? { |item| item.is_a?(String) }
         raise InvalidParameterError, "ids_not_in must be an Array type" unless ids_not_in.is_a?(Array)
       end
     end

data/lib/superset/database/get_catalogs.rb

@@ -0,0 +1,38 @@
+module Superset
+  module Database
+    class GetCatalogs < Superset::Request
+
+      attr_reader :id, :include_system_catalogs
+
+      def initialize(id, include_system_catalogs: false)
+        @id = id
+        @include_system_catalogs = include_system_catalogs
+      end
+
+      def self.call(id)
+        self.new(id).catalogs
+      end
+ 
+      def catalogs
+        return result if include_system_catalogs
+
+        remove_system_catalogs
+      end
+
+      private
+
+      def route
+        "database/#{id}/catalogs/"
+      end
+
+      # exclude system catalog values for certain databases that support them
+      def remove_system_catalogs
+        result - postgres_system_catalogs
+      end
+
+      def postgres_system_catalogs
+        %w(postgres rdsadmin template1 template0)
+      end
+    end
+  end
+end

data/lib/superset/database/list.rb

@@ -6,10 +6,10 @@ module Superset
     class List < Superset::Request
       attr_reader :title_contains, :uuid_equals
 
-      def initialize(page_num: 0, title_contains: '', uuid_equals: '')
+      def initialize(title_contains: '', uuid_equals: '', **kwargs)
         @title_contains = title_contains
         @uuid_equals = uuid_equals
-        super(page_num: page_num)
+        super(**kwargs)
       end
 
       def self.call

data/lib/superset/dataset/get.rb

@@ -18,7 +18,11 @@ module Superset
       end
 
       def rows
-        [ [title, schema, database_name, database_id] ]
+        [to_h.values]
+      end
+
+      def to_h
+        list_attributes.to_h { |a| [a, send(a)] }
       end
 
       def schema
@@ -26,7 +30,7 @@ module Superset
       end
 
       def title
-        result['name']
+        result['table_name']
       end
 
       def database_name
@@ -47,8 +51,8 @@ module Superset
         "dataset/#{id}"
       end
 
-      def display_headers
-        %w[title schema database_name, database_id]
+      def list_attributes
+        [:title, :schema, :database_name, :database_id]
       end
     end
   end

data/lib/superset/dataset/list.rb

@@ -3,12 +3,12 @@ module Superset
     class List < Superset::Request
       attr_reader :title_contains, :title_equals, :schema_equals, :database_id_eq
 
-      def initialize(page_num: 0, title_contains: '', title_equals: '', schema_equals: '', database_id_eq: '')
+      def initialize(title_contains: '', title_equals: '', schema_equals: '', database_id_eq: '', **kwargs)
         @title_contains = title_contains
         @title_equals = title_equals
         @schema_equals = schema_equals
         @database_id_eq = database_id_eq
-        super(page_num: page_num)
+        super(**kwargs)
       end
 
       def self.call

data/lib/superset/dataset/update_schema.rb

@@ -2,12 +2,13 @@ module Superset
   module Dataset
     class UpdateSchema < Superset::Request
 
-      attr_reader :source_dataset_id, :target_database_id, :target_schema, :remove_copy_suffix
+      attr_reader :source_dataset_id, :target_database_id, :target_schema, :target_catalog, :remove_copy_suffix
 
-      def initialize(source_dataset_id: , target_database_id: , target_schema: , remove_copy_suffix: false)
+      def initialize(source_dataset_id: , target_database_id: , target_schema: , target_catalog: nil,  remove_copy_suffix: false)
         @source_dataset_id = source_dataset_id
         @target_database_id = target_database_id
         @target_schema = target_schema
+        @target_catalog = target_catalog
         @remove_copy_suffix = remove_copy_suffix
       end
 
@@ -37,6 +38,7 @@ module Superset
           
           # primary database and schema changes
           new_params.merge!("database_id": target_database_id)  # add the target database id
+          new_params['catalog'] = target_catalog
           new_params['schema'] = target_schema
           new_params['owners'] = new_params['owners'].map {|o| o['id'] } # expects an array of user ids
           new_params['table_name'] = new_params['table_name'].gsub(/ \(COPY\)/, '') if remove_copy_suffix

data/lib/superset/display.rb

@@ -7,28 +7,37 @@ module Superset
     def table
       Terminal::Table.new(
         title: title,
-        headings: headings,
+        headings: list_attributes.map(&:to_s).map(&:humanize),
         rows: rows
       )
     end
 
     def rows
-      result.map do |d|
-        list_attributes.map { |la| d[la].to_s }
+      if result.is_a?(Hash)
+        list_attributes.map { |la| result[la].to_s }
+      else
+        result.map do |d|
+          list_attributes.map { |la| d[la].to_s }
+        end
       end
     end
 
-    def title
-      self.class.to_s
+    def to_h
+      if result.is_a?(Hash)
+        list_attributes.to_h { |la| [la, result[la]] }
+      else
+        result.map do |d|
+          list_attributes.to_h { |la| [la, d[la]] }
+        end
+      end
     end
 
-    def headings
-      headings = display_headers ? display_headers : list_attributes
-      headings.map(&:to_s).map(&:humanize)
+    def ids
+      result.map { |d| d[:id] }
     end
 
-    def display_headers
-      # optionally override this method to display custom headers
+    def title
+      self.class.to_s
     end
 
     def list_attributes

data/lib/superset/request.rb

@@ -5,12 +5,13 @@ module Superset
     class InvalidParameterError < StandardError; end
     class ValidationError < StandardError; end
 
-    PAGE_SIZE = 100
+    DEFAULT_PAGE_SIZE = 100
 
-    attr_accessor :page_num
+    attr_accessor :page_num, :page_size
 
-    def initialize(page_num: 0)
+    def initialize(page_num: 0, page_size: nil)
       @page_num = page_num
+      @page_size = page_size || DEFAULT_PAGE_SIZE
     end
 
     def self.call
@@ -51,7 +52,8 @@ module Superset
     end
 
     def pagination
-      "page:#{page_num},page_size:#{PAGE_SIZE}"
+      raise InvalidParameterError, "page_size max is 1000 records" if page_size.to_i > 1000
+      "page:#{page_num},page_size:#{page_size}"
     end
 
     def filters

data/lib/superset/security/permissions_resources/list.rb

@@ -3,8 +3,8 @@ module Superset
     module PermissionsResources
       class List < Superset::Request
 
-        def initialize(page_num: 0)         
-          super(page_num: page_num)
+        def initialize(**kwargs)
+          super(**kwargs)
         end
 
         private

data/lib/superset/security/user/list.rb

@@ -4,10 +4,10 @@ module Superset
       class List < Superset::Request
         attr_reader :email_contains, :username_equals
 
-        def initialize(page_num: 0, email_contains: '', username_equals: '')
+        def initialize(email_contains: '', username_equals: '', **kwargs)
           @email_contains = email_contains
           @username_equals = username_equals
-          super(page_num: page_num)
+          super(**kwargs)
         end
 
         private

data/lib/superset/services/duplicate_dashboard.rb

@@ -100,8 +100,12 @@ module Superset
             new_dataset_id = existing_datasets[0]["id"] # assuming that we do not name multiple datasets with same name in a single schema
           else
             new_dataset_id = Superset::Dataset::Duplicate.new(source_dataset_id: dataset[:id], new_dataset_name: new_dataset_name).perform
-            # update the new dataset with the target schema and target database
-            Superset::Dataset::UpdateSchema.new(source_dataset_id: new_dataset_id, target_database_id: target_database_id, target_schema: target_schema).perform
+            # update the new dataset with the target schema, database, catalog
+            Superset::Dataset::UpdateSchema.new(
+              source_dataset_id:  new_dataset_id,
+              target_database_id: target_database_id,
+              target_schema:      target_schema,
+              target_catalog:     target_database_catalog).perform
           end
           # keep track of the previous dataset and the matching new dataset_id
           dataset_duplication_tracker <<  { source_dataset_id: dataset[:id], new_dataset_id: new_dataset_id }
@@ -263,6 +267,13 @@ module Superset
         @filter_dataset_ids ||= source_dashboard.filter_configuration.map { |c| c['targets'] }.flatten.compact.map { |c| c['datasetId'] }.flatten.compact.uniq
       end
 
+      # currently does not support multiple catalogs, assumption is that 1 catalog is used per database
+      def target_database_catalog
+        catalogs = Superset::Database::GetCatalogs.new(target_database_id).catalogs
+        raise ValidationError, "Target Database #{target_database_id} has multiple catalogs" if catalogs.size > 1
+        catalogs.first
+      end
+
       # Primary Assumption is that all charts datasets on the source dashboard are pointing to the same database schema
       # An unpermitted filter will have a dataset that is pulling data from a datasource that is
       # different to the dashboard charts database schema

data/lib/superset/services/import_dashboard_across_environment.rb

@@ -56,6 +56,7 @@ module Superset
 
       def remove_source_database_config
         return if dashboard_config[:databases].blank?
+
         previous_database_name = dashboard_config[:databases]&.first[:content][:database_name]
         File.delete(dashboard_config[:databases].first[:filename])
 
@@ -78,6 +79,8 @@ module Superset
         dashboard_config[:datasets].each do |dataset|
           dataset[:content][:database_uuid] = dashboard_config[:databases].first[:content][:uuid]
           dataset[:content][:schema]        = target_database_schema
+          dataset[:content][:catalog]       = nil # reset target to use default catalog if applicable
+
           stringified_content = deep_transform_keys_to_strings(dataset[:content])
           File.open(dataset[:filename], 'w') { |f| f.write stringified_content.to_yaml }
         end

data/lib/superset/tag/list.rb

@@ -23,7 +23,7 @@ module Superset
         # TODO filtering across all list classes can be refactored to support multiple options in a more flexible way
         filter_set = []
         filter_set << "(col:name,opr:ct,value:'#{name_contains}')" if name_contains.present?
-        filter_set << "(col:name,opr:eq,value:#{name_equals})" if name_equals.present?  
+        filter_set << "(col:name,opr:eq,value:'#{name_equals}')" if name_equals.present?
         unless filter_set.empty?
           "filters:!(" + filter_set.join(',') + "),"
         end

data/lib/superset/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Superset
-  VERSION = "0.2.5"
+  VERSION = "0.2.7"
 end

data/superset.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.summary = "A Ruby Client for Apache Superset API"
   spec.homepage = "https://github.com/rdytech/superset-client"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 2.6.0"
+  spec.required_ruby_version = ">= 2.7.8"
 
   #spec.metadata["allowed_push_host"] = ""
 
@@ -37,7 +37,7 @@ Gem::Specification.new do |spec|
   # Uncomment to register a new dependency of your gem
   spec.add_dependency "dotenv", "~> 2.7"
   spec.add_dependency "json", "~> 2.6"
-  spec.add_dependency "terminal-table", "~> 1.8"
+  spec.add_dependency "terminal-table", "~> 4.0"
   spec.add_dependency "rake", "~> 13.0"
   spec.add_dependency "rollbar", "~> 3.4"
   spec.add_dependency "require_all", "~> 3.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: superset
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.2.7
 platform: ruby
 authors:
 - jbat
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-06-17 00:00:00.000000000 Z
+date: 2025-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dotenv
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.8'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -202,6 +202,7 @@ files:
 - ".buildkite/pipeline.yml"
 - ".rspec"
 - ".rubocop.yml"
+- ".ruby-version"
 - CHANGELOG.md
 - Dockerfile
 - LICENSE
@@ -248,6 +249,7 @@ files:
 - lib/superset/dashboard/warm_up_cache.rb
 - lib/superset/database/export.rb
 - lib/superset/database/get.rb
+- lib/superset/database/get_catalogs.rb
 - lib/superset/database/get_schemas.rb
 - lib/superset/database/list.rb
 - lib/superset/dataset/bulk_delete.rb
@@ -299,14 +301,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.7.8
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.1.6
 signing_key:
 specification_version: 4
 summary: A Ruby Client for Apache Superset API