vagrant_cloud 1.1.0 → 3.0.0

data/lib/vagrant_cloud/box.rb

@@ -1,97 +1,136 @@
 module VagrantCloud
-  class Box
-    attr_accessor :account
-    attr_accessor :name
-    attr_accessor :data
+  class Box < Data::Mutable
+    autoload :Provider, "vagrant_cloud/box/provider"
+    autoload :Version, "vagrant_cloud/box/version"
 
-    # @param [String] account
-    # @param [String] name
-    # @param [Hash] data
-    def initialize(account, name, data = nil)
-      @account = account
-      @name = name
-      @data = data
-    end
+    attr_reader :organization
+    attr_required :name
+    attr_optional :created_at, :updated_at, :tag, :short_description,
+      :description_html, :description_markdown, :private, :downloads,
+      :current_version, :versions, :description, :username
 
-    # @return [String]
-    def description
-      data['description_markdown'].to_s
-    end
+    attr_mutable :short_description, :description, :private, :versions
 
-    # @return [String]
-    def description_short
-      data['short_description'].to_s
+    # Create a new instance
+    #
+    # @return [Box]
+    def initialize(organization:, **opts)
+      @organization = organization
+      @versions_loaded = false
+      opts[:username] = organization.username
+      super(opts)
+      if opts[:versions] && !opts[:versions].empty?
+        self.versions= Array(opts[:versions]).map do |version|
+          Box::Version.load(box: self, **version)
+        end
+      end
+      if opts[:current_version]
+        clean(data: {current_version: Box::Version.
+          load(box: self, **opts[:current_version])})
+      end
+      clean!
     end
 
-    # @return [TrueClass, FalseClass]
-    def private
-      !!data['private']
+    # Delete this box
+    #
+    # @return [nil]
+    # @note This will delete the box, and all versions
+    def delete
+      if exist?
+        organization.account.client.box_delete(username: username, name: name)
+      end
+      nil
     end
 
-    # @return [Array<Version>]
-    def versions
-      version_list = data['versions'].map { |data| VagrantCloud::Version.new(self, data['number'], data) }
-      version_list.sort_by { |version| Gem::Version.new(version.number) }
+    # Add a new version of this box
+    #
+    # @param [String] version Version number
+    # @return [Version]
+    def add_version(version)
+      if versions.any? { |v| v.version == version }
+        raise Error::BoxError::VersionExistsError,
+          "Version #{version} already exists for box #{tag}"
+      end
+      v = Version.new(box: self, version: version)
+      clean(data: {versions: versions + [v]})
+      v
     end
 
-    # @return [Hash]
-    def data
-      @data ||= account.request('get', "/box/#{account.username}/#{name}")
+    # Check if this instance is dirty
+    #
+    # @param [Boolean] deep Check nested instances
+    # @return [Boolean] instance is dirty
+    def dirty?(key=nil, deep: false)
+      if key
+        super(key)
+      else
+        d = super() || !exist?
+        if deep && !d
+          d = Array(plain_versions).any? { |v| v.dirty?(deep: true) }
+        end
+        d
+      end
     end
 
-    # @param [Hash] args
-    def update(args = {})
-      @data = account.request('put', "/box/#{account.username}/#{name}", box: args)
+    # @return [Boolean] box exists remotely
+    def exist?
+      !!created_at
     end
 
-    def delete
-      account.request('delete', "/box/#{account.username}/#{name}")
+    # @return [Array<Version>]
+    # @note This is used to allow versions information to be loaded
+    # only when requested
+    def versions_on_demand
+      if !@versions_loaded
+        r = self.organization.account.client.box_get(username: username, name: name)
+        v = Array(r[:versions]).map do |version|
+          Box::Version.load(box: self, **version)
+        end
+        clean(data: {versions: v + Array(plain_versions)})
+        @versions_loaded = true
+      end
+      plain_versions
     end
+    alias_method :plain_versions, :versions
+    alias_method :versions, :versions_on_demand
 
-    # @param [Integer] number
-    # @param [Hash] data
-    # @return [Version]
-    def get_version(number, data = nil)
-      VagrantCloud::Version.new(self, number, data)
+    # Save the box if any changes have been made
+    #
+    # @return [self]
+    def save
+      save_versions if dirty?(deep: true)
+      save_box if dirty?
+      self
     end
 
-    # @param [String] name
-    # @param [String] description
-    # @return [Version]
-    def create_version(name, description = nil)
-      params = { version: name }
-      params[:description] = description if description
-      data = account.request('post', "/box/#{account.username}/#{self.name}/versions", version: params)
-      get_version(data['number'], data)
-    end
+    protected
 
-    # @param [String] name
-    # @param [String] description
-    # @return [Version]
-    def ensure_version(name, description = nil)
-      version = versions.select { |version| version.version == name }.first
-      version = create_version(name, description) unless version
-      if description && (description != version.description)
-        version.update(description)
+    # Save the box
+    #
+    # @return [self]
+    def save_box
+      req_args = {
+        username: username,
+        name: name,
+        short_description: short_description,
+        description: description,
+        is_private: self.private
+      }
+      if exist?
+        result = organization.account.client.box_update(**req_args)
+      else
+        result = organization.account.client.box_create(**req_args)
       end
-      version
+      clean(data: result, ignores: [:current_version, :versions])
+      self
     end
 
-    # @param [Symbol]
-    # @return [String]
-    def param_name(param)
-      # This needs to return strings, otherwise it won't match the JSON that
-      # Vagrant Cloud returns.
-      ATTR_MAP.fetch(param, param.to_s)
+    # Save the versions if any require saving
+    #
+    # @return [self]
+    def save_versions
+      versions.map(&:save)
+      self
     end
-
-    private
-
-    # Vagrant Cloud returns keys different from what you set for some params.
-    # Values in this map should be strings.
-    ATTR_MAP = {
-      is_private: 'private',
-      description: 'description_markdown'
-    }.freeze
   end
 end

data/lib/vagrant_cloud/box/provider.rb

@@ -0,0 +1,173 @@
+module VagrantCloud
+  class Box
+    class Provider < Data::Mutable
+
+      # Result for upload requests to upload directly to the
+      # storage backend.
+      #
+      # @param [String] upload_url URL for uploading file asset
+      # @param [String] callback_url URL callback to PUT after successful upload
+      DirectUpload = Struct.new(:upload_url, :callback_url, keyword_init: true)
+
+      attr_reader :version
+      attr_required :name
+      attr_optional :hosted, :created_at, :updated_at,
+        :checksum, :checksum_type, :original_url, :download_url,
+        :url
+
+      attr_mutable :url, :checksum, :checksum_type
+
+      def initialize(version:, **opts)
+        if !version.is_a?(Version)
+          raise TypeError, "Expecting type `#{Version.name}` but received `#{version.class.name}`"
+        end
+        @version = version
+        super(**opts)
+      end
+
+      # Delete this provider
+      #
+      # @return [nil]
+      def delete
+        if exist?
+          version.box.organization.account.client.box_version_provider_delete(
+            username: version.box.username,
+            name: version.box.name,
+            version: version.version,
+            provider: name
+          )
+          version.providers.delete(self)
+        end
+        nil
+      end
+
+      # Upload box file to be hosted on VagrantCloud. This
+      # method provides different behaviors based on the
+      # parameters passed. When the `direct` option is enabled
+      # the upload target will be directly to the backend
+      # storage. However, when the `direct` option is used the
+      # upload process becomes a two steps where a callback
+      # must be called after the upload is complete.
+      #
+      # If the path is provided, the file will be uploaded
+      # and the callback will be requested if the `direct`
+      # option is enabled.
+      #
+      # If a block is provided, the upload URL will be yielded
+      # to the block. If the `direct` option is set, the callback
+      # will be automatically requested after the block execution
+      # has completed.
+      #
+      # If no path or block is provided, the upload URL will
+      # be returned. If the `direct` option is set, the
+      # `DirectUpload` instance will be yielded and it is
+      # the caller's responsibility to issue the callback
+      #
+      # @param [String] path Path to asset
+      # @param [Boolean] direct Upload directly to backend storage
+      # @yieldparam [String] url URL to upload asset
+      # @return [self, Object, String, DirectUpload] self when path provided, result of yield when block provided, URL otherwise
+      # @note The callback request uses PUT request method
+      def upload(path: nil, direct: false)
+        if !exist?
+          raise Error::BoxError::ProviderNotFoundError,
+            "Provider #{name} not found for box #{version.box.tag} version #{version.version}"
+        end
+        if path && block_given?
+          raise ArgumentError,
+            "Only path or block may be provided, not both"
+        end
+        if path && !File.exist?(path)
+          raise Errno::ENOENT, path
+        end
+        req_args = {
+          username: version.box.username,
+          name: version.box.name,
+          version: version.version,
+          provider: name
+        }
+        if direct
+          r = version.box.organization.account.client.box_version_provider_upload_direct(**req_args)
+        else
+          r = version.box.organization.account.client.box_version_provider_upload(**req_args)
+        end
+        result = DirectUpload.new(
+          upload_url: r[:upload_path],
+          callback_url: r[:callback]
+        )
+        if block_given?
+          block_r = yield result.upload_url
+          Excon.put(result.callback_url) if direct
+          block_r
+        elsif path
+          File.open(path, "rb") do |file|
+            chunks = lambda { file.read(Excon.defaults[:chunk_size]).to_s }
+            # When performing a direct upload, we must POST the request
+            # to the provided upload URL. If it's just a regular upload
+            # then we just PUT to the upload URL.
+            if direct
+              Excon.post(result.upload_url, request_block: chunks)
+            else
+              Excon.put(result.upload_url, request_block: chunks)
+            end
+          end
+          Excon.put(result.callback_url) if direct
+          self
+        else
+          # When returning upload information for requester to complete,
+          # return upload URL when `direct` option is false, otherwise
+          # return the `DirectUpload` instance
+          direct ? result : result.upload_url
+        end
+      end
+
+      # @return [Boolean] provider exists remotely
+      def exist?
+        !!created_at
+      end
+
+      # Check if this instance is dirty
+      #
+      # @param [Boolean] deep Check nested instances
+      # @return [Boolean] instance is dirty
+      def dirty?(key=nil, **args)
+        if key
+          super(key)
+        else
+          super || !exist?
+        end
+      end
+
+      # Save the provider if any changes have been made
+      #
+      # @return [self]
+      def save
+        save_provider if dirty?
+        self
+      end
+
+      protected
+
+      # Save the provider
+      #
+      # @return [self]
+      def save_provider
+        req_args = {
+          username: version.box.username,
+          name: version.box.name,
+          version: version.version,
+          provider: name,
+          checksum: checksum,
+          checksum_type: checksum_type
+        }
+        if exist?
+          result = version.box.organization.account.client.box_version_provider_update(**req_args)
+        else
+          result = version.box.organization.account.client.box_version_provider_create(**req_args)
+        end
+        clean(data: result)
+        self
+      end
+    end
+  end
+end

data/lib/vagrant_cloud/box/version.rb

@@ -0,0 +1,161 @@
+module VagrantCloud
+  class Box
+    class Version < Data::Mutable
+      attr_reader :box
+      attr_required :version
+      attr_optional :status, :description_html, :description_markdown,
+        :created_at, :updated_at, :number, :providers, :description
+
+      attr_mutable :description
+
+      def initialize(box:, **opts)
+        if !box.is_a?(Box)
+          raise TypeError, "Expecting type `#{Box.name}` but received `#{box.class.name}`"
+        end
+        @box = box
+        opts[:providers] = Array(opts[:providers]).map do |provider|
+          if provider.is_a?(Provider)
+            provider
+          else
+            Provider.load(version: self, **provider)
+          end
+        end
+        super(opts)
+        clean!
+      end
+
+      # Delete this version
+      #
+      # @return [nil]
+      # @note This will delete the version, and all providers
+      def delete
+        if exist?
+          box.organization.account.client.box_version_delete(
+            username: box.username,
+            name: box.name,
+            version: version
+          )
+          # Remove self from box
+          box.versions.delete(self)
+        end
+        nil
+      end
+
+      # Release this version
+      #
+      # @return [self]
+      def release
+        if released?
+          raise Error::BoxError::VersionStatusChangeError,
+            "Version #{version} is already released for box #{box.tag}"
+        end
+        if !exist?
+          raise Error::BoxError::VersionStatusChangeError,
+            "Version #{version} for box #{box.tag} must be saved before release"
+        end
+        result = box.organization.account.client.box_version_release(
+          username: box.username,
+          name: box.name,
+          version: version
+        )
+        clean(data: result, only: :status)
+        self
+      end
+
+      # Revoke this version
+      #
+      # @return [self]
+      def revoke
+        if !released?
+          raise Error::BoxError::VersionStatusChangeError,
+            "Version #{version} is not yet released for box #{box.tag}"
+        end
+        result = box.organization.account.client.box_version_revoke(
+          username: box.username,
+          name: box.name,
+          version: version
+        )
+        clean(data: result, only: :status)
+        self
+      end
+
+      # @return [Boolean]
+      def released?
+        status == "active"
+      end
+
+      # Add a new provider for this version
+      #
+      # @param [String] pname Name of provider
+      # @return [Provider]
+      def add_provider(pname)
+        if providers.any? { |p| p.name == pname }
+          raise Error::BoxError::VersionProviderExistsError,
+            "Provider #{pname} already exists for box #{box.tag} version #{version}"
+        end
+        pv = Provider.new(version: self, name: pname)
+        clean(data: {providers: providers + [pv]})
+        pv
+      end
+
+      # Check if this instance is dirty
+      #
+      # @param [Boolean] deep Check nested instances
+      # @return [Boolean] instance is dirty
+      def dirty?(key=nil, deep: false)
+        if key
+          super(key)
+        else
+          d = super() || !exist?
+          if deep && !d
+            d = providers.any? { |p| p.dirty?(deep: true) }
+          end
+          d
+        end
+      end
+
+      # @return [Boolean] version exists remotely
+      def exist?
+        !!created_at
+      end
+
+      # Save the version if any changes have been made
+      #
+      # @return [self]
+      def save
+        save_version if dirty?
+        save_providers if dirty?(deep: true)
+        self
+      end
+
+      protected
+
+      # Save the version
+      #
+      # @return [self]
+      def save_version
+        params = {
+          username: box.username,
+          name: box.name,
+          version: version,
+          description: description
+        }
+        if exist?
+          result = box.organization.account.client.box_version_update(**params)
+        else
+          result = box.organization.account.client.box_version_create(**params)
+        end
+        clean(data: result, ignores: :providers)
+        self
+      end
+
+      # Save the providers if any require saving
+      #
+      # @return [self]
+      def save_providers
+        Array(providers).map(&:save)
+        self
+      end
+    end
+  end
+end