dtk-client 0.11.7 → 0.11.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 41bddc4ef8eb1c096ffee27ace98b4c5e1d17f4e
-  data.tar.gz: ac98dfb1857f1b916ed182072bff7278d7669901
+  metadata.gz: ce23832ed682975a0727ee818e047fd5cfd5d381
+  data.tar.gz: b9c6efe83f37a372cd2528f2adc3b7eecc2b5617
 SHA512:
-  metadata.gz: 3b379952dd59a5bb7d87ed06e5be921b23d7e0ae2e706eb5c559d4ea440ab425739524d025a49f55b83279886d2ac695829afe57aae2db169cb34cf7074d6caa
-  data.tar.gz: a0ce708ca651d169175fabf00be1d4de5a1d31b81aeed5b45f4309797fff3852b47f09420eebe94f9b1749ae40a62d188b07446d0162ffe6c149dbace15cb03b
+  metadata.gz: 82e0ddd1c3f426bb9f6220754eb82ea4923b6c71be157117b3f7b5c8aa4932dfa70130f8a73cfba955d67e61e2c7dd1a979947980edf383593b8cdccb48f88b2
+  data.tar.gz: c222153161e27520a0da7e28926c83c6ba3a37d51774944efcbcd734b3aedada908954b8940db8e5018c43b0abd12e9b23032b6d115ae4f830c98c3b9a359454

data/.gitignore

@@ -4,9 +4,9 @@ sftp-config*.json
 .remote-sync.json.bak
 .tags
 .tags1
-Gemfile.lock
 .vscode
 doc
 .yardoc
 .solargraph.yml
-dtk-dsl
+Gemfile.lock
+sftp.json

data/dtk-client.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
 
-  spec.add_dependency 'dtk-common-core','0.11.0'
+  spec.add_dependency 'dtk-common-core','0.11.1'
   spec.add_dependency 'gli', '2.13.4'
   spec.add_dependency 'highline', '1.7.8'
   spec.add_dependency 'colorize', '0.7.7'
@@ -25,5 +25,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'hirb', '0.7.3'
   spec.add_dependency 'mime-types', '~> 2.99.3'
   spec.add_dependency 'dtk-dsl', '~> 1.1.0'
-  
+  spec.add_dependency 'dtk-network-client', '~> 1.0.0'
 end

data/lib/cli/command/account/add_to_group.rb

@@ -0,0 +1,33 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Client
+  module CLI::Command
+    module Account
+      subcommand_def 'add-to-group' do |c|
+        c.arg Token::Arg.group
+        c.arg Token::Arg.user
+        command_body c, 'add-to-group', 'Add user to specific group' do |sc|
+          sc.action do |_global_options, options, args|
+            Operation::Account.add_to_group(:group => args[0], :user => args[1])
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/cli/command/account/chmod.rb

@@ -0,0 +1,33 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Client
+  module CLI::Command
+    module Account
+      subcommand_def 'chmod' do |c|
+        c.arg Token::Arg.namespace
+        c.arg Token::Arg.permissions
+        command_body c, 'chmod', 'Change permissions for specific namespace e.g. ug+rw , user and group get RW permissions' do |sc|
+          sc.action do |_global_options, options, args|
+            Operation::Account.chmod(:namespace => args[0], :permissions => args[1])
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/cli/command/account/create_namespace.rb

@@ -0,0 +1,32 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Client
+  module CLI::Command
+    module Account
+      subcommand_def 'create-namespace' do |c|
+        c.arg Token::Arg.namespace
+        command_body c, 'create-namespace', 'Create new namespace on dtk network' do |sc|
+          sc.action do |_global_options, options, args|
+            Operation::Account.create_namespace(:namespace => args[0])
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/cli/command/account/delete_namespace.rb

@@ -0,0 +1,32 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Client
+  module CLI::Command
+    module Account
+      subcommand_def 'delete-namespace' do |c|
+        c.arg Token::Arg.namespace
+        command_body c, 'delete-namespace', 'Delete namespace from dtk network' do |sc|
+          sc.action do |_global_options, options, args|
+            Operation::Account.delete_namespace(:namespace => args[0])
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/cli/command/account/list_namespaces.rb

@@ -0,0 +1,30 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Client
+  module CLI::Command
+    module Account
+      subcommand_def 'list-namespaces' do |c|
+        command_body c, 'list-namespaces', 'List namespaces' do |sc|
+          sc.action do |_global_options, options, args|
+            Operation::Account.list_namespaces
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cli/command/account/remove_from_group.rb

@@ -0,0 +1,33 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Client
+  module CLI::Command
+    module Account
+      subcommand_def 'remove-from-group' do |c|
+        c.arg Token::Arg.group
+        c.arg Token::Arg.user
+        command_body c, 'remove-from-group', 'Remove user from specific group' do |sc|
+          sc.action do |_global_options, options, args|
+            Operation::Account.remove_from_group(:group => args[0], :user => args[1])
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/cli/command/account.rb

@@ -21,7 +21,20 @@ module DTK::Client
       module Account 
         include Command::Mixin
 
-        ALL_SUBCOMMANDS = ['list-ssh-keys', 'delete-ssh-key', 'add-ssh-key', 'set-password', 'set-catalog-credentials', 'register-catalog-user']
+        ALL_SUBCOMMANDS = [
+          'list-ssh-keys',
+          'delete-ssh-key',
+          'add-ssh-key',
+          'set-password',
+          'set-catalog-credentials',
+          'register-catalog-user',
+          'add-to-group',
+          'remove-from-group',
+          'create-namespace',
+          'chmod',
+          'delete-namespace',
+          'list-namespaces'
+        ]
         command_def :desc => 'Subcommands for interacting with current Account'
         ALL_SUBCOMMANDS.each { |subcommand| require_relative("account/#{subcommand.gsub(/-/,'_')}") } 
       end

data/lib/cli/command/module/delete_from_remote.rb

@@ -21,12 +21,14 @@ module DTK::Client
       subcommand_def 'delete-from-remote' do |c|
         c.arg Token::Arg.module_name
         command_body c, 'delete-from-dtkn', 'Delete module from the DTK remote catalog (DTKN)' do |sc|
-          sc.flag Token.version
+          # sc.flag Token.version
+          raise Error::Usage, "Version option is not supported for this command" if ARGV.include?('delete-from-dtkn') && ARGV.include?('-v')
+
           sc.switch Token.skip_prompt
           sc.switch Token.force, :desc => 'Force delete'
-          
+
           sc.action do |_global_options, options, args|
-            module_ref = module_ref_object_from_options_or_context?(:module_ref => args[0], :version => options[:version])
+            module_ref = module_ref_object_from_options_or_context?(:module_ref => args[0])
             operation_args = {
               :module_ref  => module_ref,
               :skip_prompt => options[:skip_prompt],

data/lib/cli/command/module/install.rb

@@ -26,134 +26,274 @@ module DTK::Client
           # Add '-d' flag if development mode is active
           if Config[:development_mode]
             sc.flag Token.directory_path, :desc => 'Absolute or relative path to directory containing content to install'
+            sc.switch Token.skip_server
           end
           sc.switch Token.update_deps
-
+          sc.switch Token.update_lock
+          
           sc.action do |_global_options, options, args|
-            directory_path  = args[1] || options[:directory_path]
-            version         = options[:version]
-            update_deps     = options[:update_deps]
-            has_remote_repo = false
-            is_clone        = false
-
-            if module_name = args[0]
-              # reached if installing from dtkn
-              # installs content from dtkn (later probably from other remote catalogs) onto client machine
-              # in so doing installes depedent modules onto teh dtk server; this step though does not install main module onto
-              # server (the later step Operation::Module.install does this)
-              has_remote_repo    = true
-              module_ref         = module_ref_object_from_options_or_context?(:module_ref => module_name, :version => version)
-              remote_module_info = nil
-
-              unless version
-                if remote_module_info = get_remote_module_info(module_ref)
-                  version            = remote_module_info.required(:version)
-                  module_ref.version = version
-                end
-              end
+            module_name         = args[0]
+            directory_path      = args[1] || options[:directory_path]
+            has_directory_param = !options['d'].nil?
+
+            opts_hash = {
+              module_name: module_name,
+              directory_path: directory_path,
+              version: options[:version],
+              update_deps: options[:update_deps],
+              has_directory_param: has_directory_param,
+              update_lock_file: options['update-lock']
+            }
+            Install.execute(self, opts_hash)
+            nil
+          end
+        end
 
-              if Operation::Module.module_version_exists?(module_ref, :type => :common_module)
-                clone_module(module_ref, directory_path, version)
-                is_clone = true
+        # TODO: 3070: in sprint 7 should move a lot of this logic into the install operation directoty and use commands/moduel/install just to get params
+        class Install
+          def initialize(context, opts = {})
+            @context             = context
+            @module_name         = opts[:module_name]
+            @explicit_version    = opts[:version]
+            @update_deps         = opts[:update_deps]
+            @directory_path      = opts[:directory_path]
+            @has_directory_param = opts[:has_directory_param]
+            @update_lock_file    = opts[:update_lock_file]
+          end
+          
+          def self.execute(context, opts = {})
+            new(context, opts).execute
+          end
+          
+          def execute
+            if @module_name
+              if Operation::Module.module_version_exists?(self.module_ref)
+                clone_module
               else
-                target_repo_dir = Operation::Module.install_from_catalog(:module_ref => module_ref, :version => version, :directory_path => directory_path, :remote_module_info => remote_module_info)
+                install_from_catalog
               end
+            else
+              install_from_directory
+            end
+          end
+          
+          protected
+          
+          attr_reader :context
+
+          def module_ref
+            @module_ref ||= ret_module_ref
+          end
+
+          def version
+            @version ||= self.module_ref.version
+          end
+
+          def base_dsl_file_obj
+            @base_dsl_file_obj ||= self.context.base_dsl_file_obj
+          end
+
+          OPTIONAL_vars = [:module_name, :explicit_version, :update_deps, :directory_path, :has_directory_param]
+          OPTIONAL_vars.each { |var| class_eval("def #{var}?; @#{var}; end") }
+          
+          private
+
+          def install_from_catalog
+            # installs content from dtkn (later probably from other remote catalogs) onto client machine
+            # in so doing installes dependent modules onto teh dtk server; this step though does not install main module onto
+            # server (the later step Operation::Module.install does this)
+            
+            # TODO: 3070: handle sitution where response is not ok
+            install_response = Operation::Module.install_from_catalog(module_ref: self.module_ref, version: self.version, directory_path: self.directory_path?)
+
+            if client_installed_modules = (install_response && install_response.data[:installed_modules])
+              opts_server_install = {
+                has_directory_param: self.has_directory_param?,
+                has_remote_repo: true,
+                update_deps: self.update_deps?,
+                install_from: :remote
+              }
+              install_on_server(client_installed_modules, opts_server_install)
             end
+          end
+        
+          def install_from_directory
+            operation_args = {
+              :module_ref          => self.module_ref,
+              :base_dsl_file_obj   => self.base_dsl_file_obj,
+              :has_directory_param => self.has_directory_param?,
+              :has_remote_repo     => false,
+              :update_deps         => self.update_deps?
+            }
+            get_and_install_dependencies
+            Operation::Module.install(operation_args)
+          end
 
-            unless is_clone
-              raise Error::Usage, "You can use version only with 'namespace/name' provided" if version && module_name.nil?
+          def get_and_install_dependencies
+            file_obj = nil
+            if self.has_directory_param?
+              file_obj = self.base_dsl_file_obj.raise_error_if_no_content_flag(:module_ref)
+            else
+              file_obj = self.base_dsl_file_obj.raise_error_if_no_content
+            end
 
-              if target_repo_dir
-                directory_path ||= target_repo_dir.data[:target_repo_dir]
+            module_info = {
+              name:      self.module_ref.module_name,
+              namespace: self.module_ref.namespace,
+              version:   self.module_ref.version,
+              repo_dir:  file_obj.parent_dir
+            }
+            parsed_module   = file_obj.parse_content(:common_module_summary)
+            dependency_tree = Operation::DtkNetworkDependencyTree.get_or_create(module_info, { format: :hash, parsed_module: parsed_module, save_to_file: true, update_lock_file: @update_lock_file })
+
+            dependency_tree.each do |dependency|
+              dep_module_ref = module_ref_object_from_options_or_context(module_ref: "#{dependency[:namespace]}/#{dependency[:name]}", version: dependency[:version])
+              if Operation::Module.module_version_exists?(dep_module_ref)
+                p_helper = Operation::Module::Install::PrintHelper.new(:module_ref => dep_module_ref, :source => :local)
+                p_helper.print_using_installed_dependent_module
+              else
+                client_installed_modules = nil
+
+                if dependency[:source]
+                  client_installed_modules = [dependency]
+                else
+                  install_response = Operation::Module.install_from_catalog(module_ref: dep_module_ref, version: dep_module_ref.version, type: :dependency)
+                  client_installed_modules = (install_response && install_response.data[:installed_modules])
+                end
+
+                if client_installed_modules# = (install_response && install_response.data[:installed_modules])
+                  install_from = dependency[:source] ? :local : :remote
+                  opts_server_install = {
+                    has_directory_param: false,
+                    has_remote_repo: true,
+                    update_deps: self.update_deps?,
+                    install_from: install_from
+                  }
+                  install_on_server(client_installed_modules, opts_server_install)
+                end
               end
+            end
+          end
+          
+          # opts can have keys:
+          #   :has_directory_param,
+          #   :has_remote_repo
+          #   :update_dep
+          def install_on_server(client_installed_modules, opts = {})
+            client_installed_modules.each do |installed_module|
+              directory_path = installed_module[:location] || installed_module[:source]
+              module_ref     = module_ref_object_from_options_or_context(directory_path: directory_path, version: installed_module[:version])
+              use_or_install_on_server(module_ref, directory_path, opts)
+            end
+          end
 
-              install_opts = directory_path ? { :directory_path => directory_path, :version => (version || 'master') } : options
-              module_ref   = module_ref_object_from_options_or_context?(install_opts)
+          def use_or_install_on_server(module_ref, directory_path, opts = {})
+            if Operation::Module.module_version_exists?(module_ref)
+              p_helper = Operation::Module::Install::PrintHelper.new(:module_ref => module_ref, :source => :local)
+              p_helper.print_using_installed_dependent_module
+            else
+              base_dsl_file_obj = CLI::Context.base_dsl_file_obj(dir_path: directory_path)
               operation_args = {
                 :module_ref          => module_ref,
-                :base_dsl_file_obj   => @base_dsl_file_obj,
-                :has_directory_param => !options["d"].nil?,
-                :has_remote_repo     => has_remote_repo,
-                :update_deps         => update_deps
+                :base_dsl_file_obj   => base_dsl_file_obj,
+                :has_directory_param => opts[:has_directory_param],
+                :has_remote_repo     => opts[:has_remote_repo],
+                :update_deps         => opts[:update_dep],
+                :install_from        => opts[:install_from]
               }
               Operation::Module.install(operation_args)
             end
           end
-        end
-      end
 
-      def clone_module(module_ref, directory_path, version)
-        arg = {
-          :module_ref => module_ref,
-          :target_directory => Operation::ClientModuleDir.create_module_dir_from_path(directory_path || OsUtil.current_dir)
-        }
+          def clone_module
+            # clone module into current directory + module name; same as when installing base module from dtk-network
+            target_directory_path = self.directory_path? || "#{OsUtil.current_dir}/#{self.module_ref.module_name}"
+            arg = {
+              :module_ref => self.module_ref,
+              :target_directory => Operation::ClientModuleDir.create_module_dir_from_path(target_directory_path)
+            }
+            repo_dir_info = Operation::Module.clone_module(arg).data
+            OsUtil.print_info("DTK module '#{self.module_ref.pretty_print}' has been successfully cloned from server into '#{repo_dir_info[:target_repo_dir]}'")
+          end
+          
+          def should_install_from_catalog?
+            !!@module_name
+          end
 
-        unless version
-          if server_version = get_last_version_from_server(module_ref)
-            version = server_version
-            module_ref.version = version
+          def ret_module_ref
+            if should_install_from_catalog?
+              module_ref_version_unset = module_ref_object_from_options_or_context(module_ref: self.module_name?, version: @explicit_version)
+              fill_in_version_from_server_or_remote!(module_ref_version_unset) unless @explicit_version
+              module_ref_version_unset
+            else
+              module_ref_object_from_options_or_context(directory_path: self.directory_path?)
+            end
           end
-        end
 
-        repo_dir_info = Operation::Module.clone_module(arg).data
-        repo_dir      = repo_dir_info[:target_repo_dir]
-
-        # DTK-3088 - need this to pull service info for dependency module on clone
-        if repo_dir_info[:pull_service_info]# && (version.nil? || version.eql?('master'))
-          repo_dir = repo_dir_info[:target_repo_dir]
-          module_ref = module_ref_object_from_options_or_context(:directory_path => repo_dir)
-
-          operation_args = {
-            :module_ref          => module_ref,
-            :base_dsl_file_obj   => @base_dsl_file_obj,
-            :has_directory_param => true,
-            :directory_path      => repo_dir,
-            :update_deps         => false,
-            :do_not_print        => true,
-            :force               => true,
-            :allow_version       => true
-          }
-
-          Operation::Module.pull_dtkn(operation_args)
-          Operation::Module.push(operation_args.merge(:method => "pulled"))
-        end
+          # opts can have keys
+          #   :module_ref
+          #   :version
+          #   :directory_path
+          def module_ref_object_from_options_or_context(opts = {})
+            self.context.module_ref_object_from_options_or_context(opts)
+          end
 
-        OsUtil.print_info("DTK module '#{module_ref.pretty_print}' has been successfully cloned from server into '#{repo_dir}'")
-      end
+          def fill_in_version_from_server_or_remote!(module_ref_version_unset)
+            module_ref = module_ref_version_unset
 
-      private
-
-      def get_remote_module_info(module_ref)
-        query_string_hash = QueryStringHash.new(
-          :module_name => module_ref.module_name,
-          :namespace   => module_ref.namespace,
-          :rsa_pub_key => SSHUtil.rsa_pub_key_content,
-          :version?    => nil
-        )
-        begin
-          Operation::Module.rest_get("#{Operation::Module::BaseRoute}/remote_module_info", query_string_hash)
-        rescue Error::ServerNotOkResponse => e
-          # do not raise if version not specified and module does not exist on repoman but exist on server; clone module from server instead
-          return
-        end
-      end
+            module_info = {
+              name: module_ref.module_name,
+              namespace: module_ref.namespace,
+            }
 
-      def get_last_version_from_server(module_ref)
-        query_string_hash = QueryStringHash.new(
-          :module_name => module_ref.module_name,
-          :namespace   => module_ref.namespace
-        )
-        response = Operation::Module.rest_get("#{Operation::Module::BaseRoute}/versions", query_string_hash)
-        versions = response.required(:versions)
-
-        if versions.size > 1
-          versions.delete('master')
-          versions.sort.last.strip
-        else
-          versions.first.strip
+            begin
+              versions = Operation::Module::DtkNetworkClient::Info.run(module_info, about: :versions)
+            rescue Exception => e
+              # if does not exist on repoman try getting version from server
+              versions = get_versions_from_server(module_ref)
+            end
+
+            if versions.empty?
+              raise Error::Usage, "Module '#{module_term(module_ref)}' does not exist." 
+            elsif version = self.explicit_version?
+              if versions.include?(version)
+                module_ref.version = version
+              else
+                legal_versions = versions.join(', ')
+                raise Error::Usage, "Module '#{module_term(module_ref)}' does not have specified version '#{version}'; legal versions are: #{legal_versions}"
+              end
+            else
+              # use latest version
+              module_ref.version = find_latest_version(versions)
+            end
+            module_ref
+          end
+
+          def module_term(module_ref)
+            "#{module_ref.namespace}:#{module_ref.module_name}"
+          end
+
+          def find_latest_version(versions)
+            if versions.size > 1
+              versions.delete('master')
+              versions.sort.last
+            else
+              versions.first
+            end
+          end
+
+          def get_versions_from_server(module_ref)
+            query_string_hash = QueryStringHash.new(
+              :module_name => module_ref.module_name,
+              :namespace   => module_ref.namespace
+            )
+            response = Operation::Module.rest_get("#{Operation::Module::BaseRoute}/versions", query_string_hash)
+            versions = response.data(:versions) || []
+
+            versions
+          end
         end
       end
     end
   end
 end
-