piwigo-api 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f8aaa98dc9734ed3044e993de4bd3d2c5fc216b5fdc484e0085aff689c95021
-  data.tar.gz: b1368c6b9d0ad50c5dd7970e1b924962f263add8822a141b2e0d041a4c155dfe
+  metadata.gz: 7b631bbf1feb2e43cdc914db7f8ae0e839739951a99bbf00d1789c65f64524d1
+  data.tar.gz: 460e4d390cc2362865f0b9f168bd821f0b0451599daceaa8afaceca137ebc71e
 SHA512:
-  metadata.gz: bffedcebc720217299770d4a615e8f19b9b95a351ca63e3e0f5d49ad12ba0b31088444ca102ab935fca037ec2b1021f9800b417903104b38f3904bfebe2d810d
-  data.tar.gz: 002a39a2d6dfd7d4dd9d5baf931ed32a79f58f582935d43a385f0e15f2ac664372257f1dadd8397f68184f73fa63880bad90f20de19657f97ce3b9fc74a852d8
+  metadata.gz: 68fe0e10a5ccfc1522b8fdef5c0f964e7702ff0d676282d406aa811d5f39bf29fb4893be125a8143ce9033f077043c3277fc6d871c23374060bab506bac687b3
+  data.tar.gz: 9e42d435b2c00cd85db2ebc2d77511497f9f7ba7ec7d2deb7b1e61d08434566a31d844fa80a864a2bbe92431fb81bbc545eaa1277c4eb51518ee650b8ac83549

data/.gitignore

@@ -8,3 +8,4 @@
 /tmp/
 *.gem
 main.rb
+settings.json

data/.rubocop.yaml

@@ -0,0 +1,18 @@
+Style/Encoding:
+  Enabled: false
+
+Metrics/LineLength:
+  Max: 200
+  
+Metrics/CyclomaticComplexity:
+  Max: 15
+
+Metrics/AbcSize:
+  Max: 40
+
+Metrics/MethodLength:
+  Max: 40
+
+AllCops:
+  Exclude:
+    - 'tests/*.rb'  

data/CHANGELOG.md

@@ -4,6 +4,9 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+0.4.0 - 2019-11-20
+- Add methods to check for the existance of a specific image and to upload images
+
 0.3.1 - 2019-11-20
 - Add a codecov.yaml for coverage reports
 

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    piwigo-api (0.2.0)
+    piwigo-api (0.4.0)
       http (~> 4.2)
       logger (~> 1.4)
 
@@ -10,6 +10,11 @@ GEM
   specs:
     addressable (2.7.0)
       public_suffix (>= 2.0.2, < 5.0)
+    codecov (0.1.16)
+      json
+      simplecov
+      url
+    docile (1.3.2)
     domain_name (0.5.20190701)
       unf (>= 0.0.5, < 1.0.0)
     ffi (1.11.2-x64-mingw32)
@@ -26,13 +31,20 @@ GEM
     http-form_data (2.1.1)
     http-parser (1.2.1)
       ffi-compiler (>= 1.0, < 2.0)
+    json (2.2.0)
     logger (1.4.1)
     minitest (5.13.0)
     public_suffix (4.0.1)
     rake (10.5.0)
+    simplecov (0.17.1)
+      docile (~> 1.1)
+      json (>= 1.8, < 3)
+      simplecov-html (~> 0.10.0)
+    simplecov-html (0.10.2)
     unf (0.1.4)
       unf_ext
     unf_ext (0.0.7.6)
+    url (0.3.2)
 
 PLATFORMS
   ruby
@@ -40,6 +52,7 @@ PLATFORMS
 
 DEPENDENCIES
   bundler (~> 2.0)
+  codecov (>= 0.1.10)
   minitest (~> 5.0)
   piwigo-api!
   rake (~> 10.0)

data/README.md

@@ -1,6 +1,6 @@
 # Piwigo-API
 
-![](https://github.com/kkdad/piwigo-api/workflows/Ruby/badge.svg) ![](https://github.com/kkdad/piwigo-api/workflows/Ruby%20Gem/badge.svg) [![Gem Version](https://badge.fury.io/rb/piwigo-api.svg)](https://badge.fury.io/rb/piwigo-api)
+![](https://github.com/kkdad/piwigo-api/workflows/Ruby/badge.svg)  [![codecov](https://codecov.io/gh/KKDad/piwigo-api/branch/master/graph/badge.svg)](https://codecov.io/gh/KKDad/piwigo-api)  ![](https://github.com/kkdad/piwigo-api/workflows/Ruby%20Gem/badge.svg) [![Gem Version](https://badge.fury.io/rb/piwigo-api.svg)](https://badge.fury.io/rb/piwigo-api)  
 
 [Piwigo](https://piwigo.org/) is open source web application to manage your collection of photos, and other medias. Piwigo provides an API for interacting with it. 
 
@@ -24,9 +24,9 @@ Or install it yourself as:
 
 ## Usage
 
-Just include 'piwigo/session' and the related classes, then querying Piwigo is fairly quick and straightforward.
+Just include 'piwigo/session' and the related classes, then querying Piwigo is fairly quick and straightforward. The latest RubyDocs for [piwigo-api](https://rubydoc.info/github/KKDad/piwigo-api) can be loacated on [rubydoc.info](https://rubydoc.info).
 
-# Get the second album and all of it's children
+### Get the second album and all of it's children
 
 ```ruby
 require 'piwigo/session'
@@ -39,7 +39,7 @@ unless session.nil?
 end
 ```
 
-# Add a new album
+### Add a new album
 ```ruby
 require 'piwigo/session'
 require 'piwigo/albums'
@@ -52,7 +52,7 @@ unless session.nil?
 end
 ```
 
-# List the Contents of an Album
+### List the Contents of an Album
 
 ```ruby
 require 'piwigo/session'
@@ -61,7 +61,6 @@ require 'piwigo/images'
 session = Piwigo::Session.login('mypiwigo.fqdn', 'Adrian', 'mypassword', https: false) 
 unless session.nil? 
     results = Piwigo::Images.getImages(session, album_id: 4)
-   
     results[:images].each { |image| p "#{image.id}, #{image.name} - #{image.element_url}" }
 end
 ```

data/Rakefile

@@ -1,10 +1,10 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
+require 'bundler/gem_tasks'
+require 'rake/testtask'
 
 Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
 end
 
-task :default => :test
+task default: :test

data/bin/console

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
-require "bundler/setup"
-require "piwigo"
+require 'bundler/setup'
+require 'piwigo'
 
 # 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.
@@ -10,5 +10,5 @@ require "piwigo"
 # require "pry"
 # Pry.start
 
-require "irb"
+require 'irb'
 IRB.start(__FILE__)

data/lib/piwigo/albums.rb

@@ -6,180 +6,171 @@ require 'logger'
 # Piwigo organizes images by albums. The album tree has unlimted depth and each photo can belong to multiple albums. The Piwigo API
 # refers to a Album as a Category.
 module Piwigo
-    class Albums
-        class Album
-            # @return [Number] Album ID
-            attr_accessor :id
+  class Albums
+    class Album
+      # @return [Number] Album ID
+      attr_accessor :id
 
-            # @return [String] Name of the Album
-            attr_accessor :name
+      # @return [String] Name of the Album
+      attr_accessor :name
 
-            # @return [String] Album Description
-            attr_accessor :comment
+      # @return [String] Album Description
+      attr_accessor :comment
 
-            # ???
-            attr_accessor :permalink
+      # ???
+      attr_accessor :permalink
 
-            # @return [String] public or private
-            attr_accessor :status
+      # @return [String] public or private
+      attr_accessor :status
 
-            # ???
-            attr_accessor :uppercats
+      # ???
+      attr_accessor :uppercats
 
-            # The rank of an album
-            attr_accessor :global_rank
+      # The rank of an album
+      attr_accessor :global_rank
 
-            # @return [Number] ID of the parent album, nil of this is a top-level album (Aka ParentID)
-            attr_accessor :id_uppercat
+      # @return [Number] ID of the parent album, nil of this is a top-level album (Aka ParentID)
+      attr_accessor :id_uppercat
 
-            # @return [Number] Number of the Newest photos, excluding child albums
-            attr_accessor :nb_images
+      # @return [Number] Number of the Newest photos, excluding child albums
+      attr_accessor :nb_images
 
-            # @return [Number] Number of the Newest photos, including child albums
-            attr_accessor :total_nb_images
+      # @return [Number] Number of the Newest photos, including child albums
+      attr_accessor :total_nb_images
 
-            # ID of the representative photo for an album. This photo doesn't have to belong to the album.
-            attr_accessor :representative_picture_id
+      # ID of the representative photo for an album. This photo doesn't have to belong to the album.
+      attr_accessor :representative_picture_id
 
-            # @return [DateTime] Date of the Newest photos, excluding child albums
-            attr_accessor :date_last
+      # @return [DateTime] Date of the Newest photos, excluding child albums
+      attr_accessor :date_last
 
-            # @return [DateTime] Date of the Newest photos, including child albums
-            attr_accessor :max_date_last
+      # @return [DateTime] Date of the Newest photos, including child albums
+      attr_accessor :max_date_last
 
-            # @return [Number] Number of child albums inside this album
-            attr_accessor :nb_categories
+      # @return [Number] Number of child albums inside this album
+      attr_accessor :nb_categories
 
-            # @return [Atring] Album URL
-            attr_accessor :url
+      # @return [Atring] Album URL
+      attr_accessor :url
 
-            # @return [String] Thumbnail URL
-            attr_accessor :tn_url  
+      # @return [String] Thumbnail URL
+      attr_accessor :tn_url
 
-            def initialize(hash: nil)                
-                hash.each { |key, value| send("#{key}=", value) } unless hash.nil?
-            end
+      def initialize(hash: nil)
+        hash&.each { |key, value| send("#{key}=", value) }
+      end
+    end
+
+    # Returns a list of albums
+    #
+    # @param [Session] session - Session
+    # @param [Number] album_id - Album to fetch, Optional
+    # @param [Boolean] recursive - Include subalbums, Optional
+    # @param [Boolean] public - Only include public albums, Optional
+    # @param [Boolean] fullname - ???, Optional
+    # @param [String] thumbnail_size - Size of thumbname to return, One of: square, thumb, 2small, xsmall, small, medium, large, xlarge, xxlarge. Optional
+    # @param [Logger] logger logger to output debug messages to (Optional)
+    #
+    # @return [Array<Album>] All albums that match the criteria, or nil there were no matches
+    def self.list(session, album_id: nil, recursive: false, public: false, fullname: false, thumbnail_size: 'thumb', logger: nil)
+      raise 'Invalid session' if session.uri.nil?
+
+      logger ||= Logger.new(STDOUT)
+
+      begin
+        http = Net::HTTP.new(session.uri.host, session.uri.port)
+        request = Net::HTTP::Post.new(session.uri.request_uri)
+        request.body = "method=pwg.categories.getList&cat_id=#{album_id}&recursive=#{recursive}&public=#{public}&fullname=#{fullname}&thumbnail_size=#{thumbnail_size}"
+        request['Cookie'] = [session.id]
+
+        # Send the request
+        response = http.request(request)
+        if response.code == '200'
+          data = JSON.parse(response.body)
+          albums = data['result']['categories'].map { |hash| Album.new(hash: hash) }
+          logger.info "Album List succeeded: #{albums.size} albums retrieved."
+          albums
         end
-           
-        
-        # Returns a list of albums
-        #
-        # @param [Session] session - Session
-        # @param [Number] album_id - Album to fetch, Optional
-        # @param [Boolean] recursive - Include subalbums, Optional
-        # @param [Boolean] public - Only include public albums, Optional 
-        # @param [Boolean] fullname - ???, Optional
-        # @param [String] thumbnail_size - Size of thumbname to return, One of: square, thumb, 2small, xsmall, small, medium, large, xlarge, xxlarge. Optional
-        # @param [Logger] logger logger to output debug messages to (Optional)        
-        #
-        # @return [Array<Album>] All albums that match the criteria, or nil there were no matches
-        #
-        def self.list(session, album_id: nil, recursive: false, public: false, fullname: false, thumbnail_size: 'thumb', logger: nil)
-            raise "Invalid session" if session.uri.nil?
-            logger = logger || Logger.new(STDOUT)     
-
-
-            begin
-                http = Net::HTTP.new(session.uri.host, session.uri.port)
-                request = Net::HTTP::Post.new(session.uri.request_uri)
-                request.body = "method=pwg.categories.getList&cat_id=#{album_id}&recursive=#{recursive}&public=#{public}&fullname=#{fullname}&thumbnail_size=#{thumbnail_size}"                
-                request['Cookie'] = [session.id]
-                
-                # Send the request
-                response = http.request(request) 
-                if response.code == '200'
-                    data = JSON.parse(response.body)
-                    albums = data['result']['categories'].map{ |hash| Album.new(hash: hash) }
-                    logger.info "Album List succeeded: #{albums.size} albums retrieved."
-                    albums
-                else                
-                    nil
-                end                      
-            rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
-                logger.error "Album List failed: #{e.messages}"
-                nil
-            end            
+      rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
+        logger.error "Album List failed: #{e.messages}"
+        nil
+      end
+    end
+
+    # Adds an album.
+    #
+    # @param [Session] session to interact with Piwigo
+    # @param [Album] album album to create
+    # @param [Logger] logger logger to output debug messages to (Optional)
+    #
+    # @return [Album] newly created album
+    def self.add(session, album, logger: nil)
+      raise 'Invalid session' if session.uri.nil?
+      raise 'Invalid album' if album.nil?
+
+      logger ||= Logger.new(STDOUT)
+
+      begin
+        http = Net::HTTP.new(session.uri.host, session.uri.port)
+        request = Net::HTTP::Post.new(session.uri.request_uri)
+        request.body = "method=pwg.categories.add&name=#{album.name}"
+        request.body.concat "&parent=#{album.id_uppercat}" unless album.id_uppercat.nil?
+        request.body.concat "&comment=#{album.comment}" unless album.comment.nil?
+        request.body.concat "&status=#{album.status}" unless album.status.nil?
+        request['Cookie'] = [session.id]
+
+        # Send the request
+        response = http.request(request)
+        if response.code == '200'
+          data = JSON.parse(response.body)
+          album.id = data['result']['id']
+          logger.info "Album Add succeeded: #{album.id} created."
+          album
         end
+      rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
+        logger.error "Album Add failed: #{e.messages}"
+        nil
+      end
+    end
 
+    # Deletes album(s).
+    #
+    # @param [Session] piwigo session
+    # @param [Number] id of the album to remove
+    # @param [String] photo_deletion_mode can be "no_delete" (may create orphan photos), "delete_orphans" (default mode, only deletes photos linked to no other album)
+    #                 or "force_delete" (delete all photos, even those linked to other albums)
+    # @param [Logger] logger logger to output debug messages to (Optional)
+    #
+    # @return [Boolean] true if album was deleted
+    def self.delete(session, id, photo_deletion_mode: nil, logger: nil)
+      raise 'Invalid session' if session.uri.nil?
+
+      logger ||= Logger.new(STDOUT)
+
+      begin
+        http = Net::HTTP.new(session.uri.host, session.uri.port)
+        request = Net::HTTP::Post.new(session.uri.request_uri)
+        request.body = "method=pwg.categories.delete&category_id=#{id}"        
+        request.body.concat "&photo_deletion_mode=#{photo_deletion_mode}" unless photo_deletion_mode.nil?
+        request.body.concat "&pwg_token=#{session.pwg_token}"
+        request['Cookie'] = [session.id]
+
+        # Send the request
+        response = http.request(request)
+        if response.code == '200'
+          data = JSON.parse(response.body)
+          logger.info "Album Delete succeeded: #{data}"
+          true
+        else
+          p response.code
+          p response.body
+          false
 
-        # Adds an album.
-        #
-        # @param [Session] session to interact with Piwigo
-        # @param [Album] album album to create
-        # @param [Logger] logger logger to output debug messages to (Optional)        
-        #
-        # @return [Album] newly created album
-        def self.add(session, album, logger: nil)
-            raise "Invalid session" if session.uri.nil?
-            raise "Invalid album" if album.nil?
-
-            logger = logger || Logger.new(STDOUT)     
-
-            begin
-                http = Net::HTTP.new(session.uri.host, session.uri.port)
-                request = Net::HTTP::Post.new(session.uri.request_uri)
-                request.body = "method=pwg.categories.add&name=#{album.name}"                
-                request.body.concat "&parent=#{album.id_uppercat}" unless album.id_uppercat.nil?
-                request.body.concat "&comment=#{album.comment}" unless album.comment.nil?
-                request.body.concat "&status=#{album.status}" unless album.status.nil?
-                request['Cookie'] = [session.id]
-                
-                # Send the request
-                response = http.request(request) 
-                if response.code == '200'
-                    data = JSON.parse(response.body)
-                    album.id = albums = data['result']['id']
-                    logger.info "Album Add succeeded: #{album.id} created."
-                    album
-                else                
-                    nil
-
-                end                      
-            rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
-                logger.error "Album Add failed: #{e.messages}"
-                nil
-            end            
-        end   
-        
-        
-        # Deletes album(s).
-        #
-        # @param [Session] piwigo session 
-        # @param [Number] id of the album to remove
-        # @param [String] photo_deletion_mode can be "no_delete" (may create orphan photos), "delete_orphans" (default mode, only deletes photos linked to no other album) 
-        #                 or "force_delete" (delete all photos, even those linked to other albums)
-        # @param [Logger] logger logger to output debug messages to (Optional)        
-        #
-        # @return [Boolean] true if album was deleted        
-        def self.delete(session, id, photo_deletion_mode: nil, logger: nil)
-            raise "Invalid session" if session.uri.nil?
-
-            logger = logger || Logger.new(STDOUT)     
-
-            begin
-                http = Net::HTTP.new(session.uri.host, session.uri.port)
-                request = Net::HTTP::Post.new(session.uri.request_uri)
-                request.body = "method=pwg.categories.delete&category_id=#{id}"                
-                request.body.concat "&photo_deletion_mode=#{photo_deletion_mode}" unless photo_deletion_mode.nil?
-                request.body.concat "&pwg_token=#{session.pwg_token}"
-                request['Cookie'] = [session.id]
-                
-                # Send the request
-                response = http.request(request) 
-                if response.code == '200'
-                    data = JSON.parse(response.body)
-                    logger.info "Album Delete succeeded."
-                    true
-                else 
-                    p response.code               
-                    p response.body               
-                    false
-
-                end                      
-            rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
-                logger.error "Album delete: #{e.messages}"
-                false
-            end            
-        end        
+        end
+      rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
+        logger.error "Album delete: #{e.messages}"
+        false
+      end
     end
-end    
+  end
+end

data/lib/piwigo/image_uploader.rb

@@ -0,0 +1,142 @@
+require 'net/http'
+require 'uri'
+require 'json'
+require 'logger'
+require 'digest'
+require 'base64'
+
+# Add a photo.
+#
+# To avoid limitations on HTTP POST maximum size, the piwigo requires the image to be splitted into several calls to pwg.images.addChunk 
+# and then a single call to pwg.images.add.
+#
+# Reference: https://piwigo.org/doc/doku.php?id=dev:webapi:pwg.images.add
+module Piwigo
+  class Images
+    class ImageUploader
+      MEGABYTE = 1024 * 1024
+
+      # Create a new ImageUploader
+      #
+      # @param [Session] session - session to a piwigo instance
+      def initialize(logger: nil)
+        @logger = logger || Logger.new(STDOUT)
+      end
+
+      # Add a photo to Piwigo
+      #
+      # @param [<Type>] session
+      # @param [<Type>] filename of the file to upload
+      # @param [<Type>] name of the image
+      #
+      # @return [Boolean] True if successful
+      def Upload(session, filename, name)
+        @session = session
+        raise 'Invalid session' if @session.uri.nil?
+
+        unless File.exist? filename
+          @Logger.error "No such file: #{filename}"
+          return false
+        end
+        chunk_num = 0
+        image_content = File.binread(filename)
+        original_sum = Digest::MD5.hexdigest(image_content)
+        encoded_content = Base64.encode64(image_content)
+        io = StringIO.new(encoded_content)
+        until io.eof?
+          chunk = io.read(MEGABYTE)
+          addChunk(chunk, original_sum, chunk_num)
+          chunk_num += 1
+        end
+        add(original_sum, filename, name)
+      end
+
+      private
+
+      # Add a chunk of a file.
+      #
+      # @param [String] data - substring of the base64 encoded binary file
+      # @param [String] original_sum - md5sum of the original photo, used as a unique identifier, not to check the chunk upload
+      # @param [Number] position -  the numeric position of the chunk among all chunks of the given file
+      #
+      # @return [Boolean] true if successful
+      def addChunk(data, original_sum, position)
+        http = Net::HTTP.new(@session.uri.host, @session.uri.port)
+        request = Net::HTTP::Post.new(@session.uri.request_uri)
+        form = {
+          method: 'pwg.images.addChunk',
+          original_sum: original_sum,
+          position: position,
+          data: data
+        }
+        request.set_form_data(form)
+        request['Cookie'] = [@session.id]
+
+        response = http.request(request)
+        if response.code == '200'
+          data = JSON.parse(response.body)
+          @logger.info "Image AddChunk ##{position} succeeded: #{data}"
+          true
+        else
+          false
+        end
+      rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
+        @logger.error "Image AddChunk failed: #{e.messages}"
+        false
+      end
+
+      # Add an image. Pwg.images.addChunk must have been called before (maybe several times).
+      #
+      # @param [<Type>] original_sum - md5sum that makes the photo unique
+      # @param [<Type>] original_filename
+      # @param [<Type>] name
+      # @param [<Type>] author
+      # @param [Number] level - 0 (—-), 1 (Contacts), 2 (Friends), 4 (Family), 8 (Admins)
+      # @param [String] date_creation - formatted as 2009-03-26
+      # @param [<Type>] comment -
+      # @param [<Type>] categories - list of category identifiers where you want the photo to be shown. Optionaly, you can set a rank inside the each category.
+      #                              Example : '19,3;16,0;134' will associate the photo to category 19 at rank 3, to category 16 at rank 0 (first position) and
+      #                                        to category 134 with an automatic rank (last position).
+      # @param [<Type>] image_id - give an image_id if you want to update an existing photo
+      #
+      # @return [Boolean] True if successful
+      def add(original_sum, original_filename, name, author: nil, level: nil, date_creation: nil, comment: nil, categories: nil, image_id: nil)
+
+        http = Net::HTTP.new(@session.uri.host, @session.uri.port)
+        request = Net::HTTP::Post.new(@session.uri.request_uri)
+        form = {
+          method: 'pwg.images.add',
+          original_sum: original_sum,
+          original_filename: original_filename,
+          name: name
+        }
+
+        form[:author] = author unless author.nil?
+        form[:level] = level unless level.nil?
+        form[:date_creation] = date_creation unless date_creation.nil?
+        form[:comment] = comment unless comment.nil?
+        form[:categories] = categories unless categories.nil?
+        form[:image_id] = image_id unless image_id.nil?
+        request.set_form_data(form)
+
+        request['Cookie'] = [@session.id]
+
+        response = http.request(request)
+        if response.code == '500'
+          @logger.error "Image Add failed: #{response.messages}"
+          false
+        elsif response.code == '200'
+          data = JSON.parse(response.body)
+          p data
+          @logger.info 'Image Add succeeded.'
+          true
+        else
+          false
+        end
+      rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
+        @logger.error "Image Add failed: #{e.messages}"
+        false
+      end
+    end
+  end
+end

data/lib/piwigo/images.rb

@@ -1,117 +1,170 @@
+require 'base64'
 require 'net/http'
 require 'uri'
 require 'json'
 require 'logger'
+require 'digest'
+require_relative 'image_uploader'
 
 # Piwigo organizes images by albums. The album tree has unlimted depth and each photo can belong to multiple albums. The Piwigo API
 # refers to a Album as a Category.
 module Piwigo
-    class Images
-        class Image
-            # @return [Number] Unique ID idenifying this ie
-            attr_accessor :id
+  class Images
+    class Image
+      # @return [Number] Unique ID idenifying this ie
+      attr_accessor :id
 
-            # @return [Number] Width of the image in pixels
-            attr_accessor :width
+      # @return [Number] Width of the image in pixels
+      attr_accessor :width
 
-            # @return [Number] Height of the image in pixels
-            attr_accessor :height
+      # @return [Number] Height of the image in pixels
+      attr_accessor :height
 
-            # @return [Number] Number of times the image has been viewed
-            attr_accessor :hit
+      # @return [Number] Number of times the image has been viewed
+      attr_accessor :hit
 
-            # @return [String] Filename for the image
-            attr_accessor :file
+      # @return [String] Filename for the image
+      attr_accessor :file
 
-            # @return [String] Name of the image
-            attr_accessor :name
+      # @return [String] Name of the image
+      attr_accessor :name
 
-            # @return [String] Comments about the image
-            attr_accessor :comment
+      # @return [String] Comments about the image
+      attr_accessor :comment
 
-            # @return [DateTime] DateTime when the image was taken
-            attr_accessor :date_creation
+      # @return [DateTime] DateTime when the image was taken
+      attr_accessor :date_creation
 
-            # @return [DateTime] DateTime when the image was uploaded to Piwigo
-            attr_accessor :date_available
+      # @return [DateTime] DateTime when the image was uploaded to Piwigo
+      attr_accessor :date_available
 
-            # @return [String] URL to the image page
-            attr_accessor :page_url
+      # @return [String] URL to the image page
+      attr_accessor :page_url
 
-            # @return [String] URL to the image itself
-            attr_accessor :element_url
+      # @return [String] URL to the image itself
+      attr_accessor :element_url
 
-            # @return [Array<String>] Links to different sizes of the image
-            attr_accessor :derivatives
+      # @return [Array<String>] Links to different sizes of the image
+      attr_accessor :derivatives
 
-            # @return [<Type>] List of all of the Albums this image is in
-            attr_accessor :categories
+      # @return [<Type>] List of all of the Albums this image is in
+      attr_accessor :categories
 
-            def initialize(hash: nil)                
-                hash.each { |key, value| send("#{key}=", value) } unless hash.nil?
-            end            
-        end
+      def initialize(hash: nil)
+        hash&.each { |key, value| send("#{key}=", value) }
+      end
+    end
+
+    class Paging # rubocop:todo Style/Documentation
+      # @return [Number] Page number of the results
+      attr_accessor :page
 
-        class Paging
-            # @return [Number] Page number of the results
-            attr_accessor :page
+      # @return [Number] Number of images requesed per page
+      attr_accessor :per_page
 
-            # @return [Number] Number of images requesed per page
-            attr_accessor :per_page
+      # @return [Number] Number of Images on this page. When this is less then the number per page, then there are no more results.
+      attr_accessor :count
 
-            # @return [Number] Number of Images on this page. When this is less then the number per page, then there are no more results.
-            attr_accessor :count
-            
-            # @return [Number] Total number of images across all pages
-            attr_accessor :total_count 
+      # @return [Number] Total number of images across all pages
+      attr_accessor :total_count
+
+      def initialize(hash: nil)
+        hash&.each { |key, value| send("#{key}=", value) }
+      end
+    end
 
-            def initialize(hash: nil)                
-                hash.each { |key, value| send("#{key}=", value) } unless hash.nil?
-            end                     
+    # Returns elements for the corresponding categories.
+    # order comma separated fields for sorting
+    #
+    # @param [Session] session
+    # @param [Number] album_id - Can be empty if recursive is true.
+    # @param [Boolean] recursive - Include images from child albums
+    # @param [Number] per_page - Number of items to include per page
+    # @param [Number] page - Page to retrieve
+    # @param [String] order - One or more of id, file, name, hit, rating_score, date_creation, date_available or random
+    # @param [Logger] logger logger to output debug messages to (Optional)
+    #
+    # @return [Hash] <description>
+    def self.getImages(session, album_id: nil, recursive: nil, per_page: 100, page: 0, order: nil, logger: nil)
+      raise 'Invalid session' if session.uri.nil?
+
+      logger ||= Logger.new(STDOUT)
+
+      begin
+        http = Net::HTTP.new(session.uri.host, session.uri.port)
+        request = Net::HTTP::Post.new(session.uri.request_uri)
+        form = {
+          method: 'pwg.categories.getImages'
+        }
+        form[:cat_id] = album_id unless album_id.nil?
+        form[:recursive] = recursive unless recursive.nil?
+        form[:per_page] = per_page unless per_page.nil?
+        form[:order] = order unless order.nil?
+        request.set_form_data(form)
+        request['Cookie'] = [session.id]
+
+        # Send the request
+        response = http.request(request)
+        if response.code == '200'
+          data = JSON.parse(response.body)
+          paging = Paging.new hash: data['result']['paging']
+          images = data['result']['images'].map { |hash| Image.new(hash: hash) }
+          logger.info "Image List succeeded: #{images.size} images retrieved."
+          { paging: paging, images: images }
         end
-        
-        # Returns elements for the corresponding categories.
-        # order comma separated fields for sorting
-        #
-        # @param [Session] session 
-        # @param [Number] album_id - Can be empty if recursive is true.
-        # @param [Boolean] recursive - Include images from child albums
-        # @param [Number] per_page - Number of items to include per page
-        # @param [Number] page - Page to retrieve
-        # @param [String] order - One or more of id, file, name, hit, rating_score, date_creation, date_available or random
-        # @param [Logger] logger logger to output debug messages to (Optional)        
-        #
-        # @return [Hash] <description>
-        def self.getImages(session, album_id: nil, recursive: nil, per_page: 100, page: 0, order: nil, logger: nil)
-            raise "Invalid session" if session.uri.nil?
-            logger = logger || Logger.new(STDOUT)     
-
-            begin
-                http = Net::HTTP.new(session.uri.host, session.uri.port)
-                request = Net::HTTP::Post.new(session.uri.request_uri)
-                request.body = "method=pwg.categories.getImages"
-                request.body.concat "&cat_id=#{album_id}" unless album_id.nil?
-                request.body.concat "&recursive=#{recursive}" unless recursive.nil?
-                request.body.concat "&per_page=#{per_page}" unless album_id.nil?
-                request.body.concat "&order=#{order}" unless order.nil?
-                request['Cookie'] = [session.id]
-                
-                # Send the request
-                response = http.request(request) 
-                if response.code == '200'
-                    data = JSON.parse(response.body)
-                    paging = Paging.new hash: data['result']['paging']
-                    images = data['result']['images'].map{ |hash| Image.new(hash: hash) }
-                    logger.info "Image List succeeded: #{images.size} images retrieved."
-                    { :paging => paging, :images => images }
-                else                
-                    nil
-                end                      
-            rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
-                logger.error "Image List failed: #{e.messages}"
-                nil
-            end            
-        end          
+      rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
+        logger.error "Image List failed: #{e.messages}"
+        nil
+      end
+    end
+
+    # Add a photo to Piwigo
+    #
+    # @param [<Type>] session
+    # @param [<Type>] filename of the file to upload
+    # @param [<Type>] name of the image
+    #
+    # @return [Boolean] True if successful
+    def self.Upload(session, file, name)
+      ImageUploader.new(session, file, name).Upload
+    end
 
+    # Checks existence of images
+    #
+    # @param [Session] session
+    # @param [String] file to check
+    # @param [Logger] logger
+    #
+    # @return [Number] Piwigo image_id if matched, nil if not present
+    def self.Lookup(session, file, logger: nil)
+      raise 'Invalid session' if session.uri.nil?
+
+      logger ||= Logger.new(STDOUT)
+      image_content = File.binread(file)
+      file_sum = Digest::MD5.hexdigest(image_content)
+
+      begin
+        http = Net::HTTP.new(session.uri.host, session.uri.port)
+        request = Net::HTTP::Post.new(session.uri.request_uri)
+        form = {
+          method: 'pwg.images.exist',
+          md5sum_list: file_sum,
+          filename_list: file
+        }
+        request.set_form_data(form)
+        request['Cookie'] = [session.id]
+
+        # Send the request
+        response = http.request(request)
+        if response.code == '200'
+          data = JSON.parse(response.body)
+          logger.info "Image Lookup succeeded: #{data['result']}"
+          data['result'][file_sum]
+        end
+      rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
+        logger.error "Image Lookup failed: #{e.messages}"
+        nil
+      end
     end
-end
+  end
+end

data/lib/piwigo/session.rb

@@ -4,115 +4,116 @@ require 'json'
 require 'logger'
 
 module Piwigo
-    # Class to hold the Piwigo session the rest of the API needs to pass in order to access the API
-    class Session
-        
-        # @return [String] Piwigo session cookie
-        attr_accessor :id
+  # Class to hold the Piwigo session the rest of the API needs to pass in order to access the API
+  class Session
+    # @return [String] Piwigo session cookie
+    attr_accessor :id
 
-        # @return [URI::HTTP] Piwigo host associated with this session
-        attr_accessor :uri
+    # @return [URI::HTTP] Piwigo host associated with this session
+    attr_accessor :uri
 
-        # @return [String] token required for admin methods
-        attr_accessor :pwg_token
+    # @return [String] token required for admin methods
+    attr_accessor :pwg_token
 
-        # @return [String] token required for admin methods
-        attr_accessor :username
+    # @return [String] token required for admin methods
+    attr_accessor :username
 
+    def initialize(id, uri)
+      self.id = id
+      self.uri = uri
 
-        def initialize(id, uri)
-            self.id = id
-            self.uri = uri
+      status
+    end
 
-            status            
-        end
-          
-        # Gets information about the current session. Also provides a token useable with admin methods.
-        # {"stat":"ok","result":{"username":"Adrian","status":"webmaster","theme":"modus","language":"en_GB","pwg_token":"9edde6a1ae535934cca6a2423f9bcbe7","charset":"utf-8","current_datetime":"2019-11-17 21:57:58","version":"2.10.1","available_sizes":["square","thumb","2small","xsmall","small","medium","large","xlarge","xxlarge"],"upload_file_types":"jpg,jpeg,png,gif","upload_form_chunk_size":500}}
-        # @return [<Type>] <description>
-        def status
-            logger = logger || Logger.new(STDOUT)     
-
-            begin                       
-                # Create the HTTP objects
-                http = Net::HTTP.new(uri.host, uri.port)
-                request = Net::HTTP::Post.new(uri.request_uri)
-                request.body = "method=pwg.session.getStatus"
-                request['Cookie'] = self.id
-                
-                # Send the request
-                response = http.request(request)    
-            
-                if response.code == '200'
-                    logger.info "Status succeeded"
-                    data = JSON.parse(response.body)
-                    self.pwg_token = data['result']['pwg_token']
-                    self.username = data['result']['username']
-                end
-
-            rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
-                    logger.error "Unexpected failed: #{e.messages}"
-            end
-            nil              
-            
+    # Gets information about the current session. Also provides a token useable with admin methods.
+    # @return [<Type>] <description>
+    def status
+      logger ||= Logger.new(STDOUT)
+
+      begin
+        # Create the HTTP objects
+        http = Net::HTTP.new(uri.host, uri.port)
+        request = Net::HTTP::Post.new(uri.request_uri)
+        form = {
+          method: 'pwg.session.getStatus'
+        }
+        request.set_form_data(form)
+        request['Cookie'] = id
+
+        # Send the request
+        response = http.request(request)
+
+        if response.code == '200'
+          logger.info 'Status succeeded'
+          data = JSON.parse(response.body)
+          self.pwg_token = data['result']['pwg_token']
+          self.username = data['result']['username']
         end
-           
-        # Logout of the current session
-        # @param [Logger] logger logger to output debug messages to (Optional)        
-        def logout(logger: nil)            
-            raise "This session has already been logged out" if uri.nil?
-            logger = logger || Logger.new(STDOUT)     
-
-            # Create the HTTP objects
-            http = Net::HTTP.new(self.uri.host, self.uri.port)
-            request = Net::HTTP::Get.new(self.uri.request_uri + "&method=pwg.session.logout")
-            request['Cookie'] = self.id
-            
-            # Send the request
-            response = http.request(request)               
-            logger.info "Logout succeeded: #{response.body}" if response.code == '200'    
-            self.id = nil
-            self.uri = nil
+      rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
+        logger.error "Unexpected failed: #{e.messages}"
+      end
+      nil
+    end
+
+    # Logout of the current session
+    # @param [Logger] logger logger to output debug messages to (Optional)
+    def logout(logger: nil)
+      raise 'This session has already been logged out' if uri.nil?
+
+      logger ||= Logger.new(STDOUT)
+
+      # Create the HTTP objects
+      http = Net::HTTP.new(uri.host, uri.port)
+      request = Net::HTTP::Get.new(uri.request_uri + '&method=pwg.session.logout')
+      request['Cookie'] = id
+
+      # Send the request
+      response = http.request(request)
+      logger.info "Logout succeeded: #{response.body}" if response.code == '200'
+      self.id = nil
+      self.uri = nil
+    end
+
+    # Log into the piwigo API and grab the session id for subsequent calls.
+    # @param [string] piwigo - host to connect to. Can be fqdn or ip.
+    # @param [string] username - user to connect as
+    # @param [string] password - password for user
+    # @param [boolean] https - Use HTTPS?
+    # @param [Logger] logger logger to output debug messages to (Optional)
+    def self.login(host, username, password, https: true, logger: nil)
+      raise 'host should not be nil' if host.nil?
+      raise 'username should not be nil' if username.nil?
+
+      logger ||= Logger.new(STDOUT)
+
+      begin
+        uri = https ? URI::HTTPS.build(host: host, path: '/ws.php', query: 'format=json') :
+                      URI::HTTP.build(host: host, path: '/ws.php', query: 'format=json')
+
+        # Create the HTTP objects
+        http = Net::HTTP.new(uri.host, uri.port)
+        request = Net::HTTP::Post.new(uri.request_uri)
+        form = {
+          method: 'pwg.session.login',
+          username: username,
+          password: password
+        }
+        request.set_form_data(form)
+
+        # Send the request
+        response = http.request(request)
+
+        if response.code == '200'
+          logger.info "Login succeeded: #{response.body}"
+          pwg_id = response.response['set-cookie'].split(';').select { |i| i.strip.start_with? 'pwg_id' }.first
+          return Session.new(pwg_id, uri)
+        else
+          logger.error "Login failed: #{response.body}"
         end
-        
-        
-        # Log into the piwigo API and grab the session id for subsequent calls.
-        # @param [string] piwigo - host to connect to. Can be fqdn or ip. 
-        # @param [string] username - user to connect as
-        # @param [string] password - password for user
-        # @param [boolean] https - Use HTTPS?
-        # @param [Logger] logger logger to output debug messages to (Optional)        
-        def self.login(host, username, password, https: true, logger: nil)
-
-            raise "host should not be nil" if host.nil?
-            raise "username should not be nil" if username.nil?
-            logger = logger || Logger.new(STDOUT)     
-
-            begin
-            
-                uri = https ? URI::HTTPS.build(host: host, path: "/ws.php", query: "format=json") :
-                                   URI::HTTP.build(host: host, path: "/ws.php", query: "format=json")                 
-            
-                # Create the HTTP objects
-                http = Net::HTTP.new(uri.host, uri.port)
-                request = Net::HTTP::Post.new(uri.request_uri)
-                request.body = "method=pwg.session.login&username=#{username}&password=#{password}"
-                
-                # Send the request
-                response = http.request(request)    
-            
-                if response.code == '200'
-                    logger.info "Login succeeded: #{response.body}"
-                    pwg_id = response.response['set-cookie'].split(';').select { |i| i.strip.start_with? "pwg_id" }.first
-                    return Session.new(pwg_id, uri)
-                else
-                    logger.error "Login failed: #{response.body}"
-                end
-
-            rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
-                    logger.error "Login failed: #{e.messages}"
-            end
-            nil                
-        end       
+      rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError, Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
+        logger.error "Login failed: #{e.messages}"
+      end
+      nil
     end
-end
+  end
+end

data/lib/piwigo/version.rb

@@ -1,3 +1,3 @@
 module Piwigo
-  VERSION = "0.3.1"
+  VERSION = '0.4.0'
 end

data/lib/piwigo.rb

@@ -1,4 +1,4 @@
-require "piwigo/version"
+require 'piwigo/version'
 
 module Piwigo
   class Error < StandardError; end

data/piwigo-api.gemspec

@@ -1,36 +1,37 @@
-lib = File.expand_path("lib", __dir__)
+lib = File.expand_path('lib', __dir__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "piwigo/version"
+require 'piwigo/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "piwigo-api"
+  spec.name          = 'piwigo-api'
   spec.version       = Piwigo::VERSION
-  spec.authors       = ["Adrian Gilbert"]
-  spec.email         = ["adrian@gilbert.ca"]
+  spec.authors       = ['Adrian Gilbert']
+  spec.email         = ['adrian@gilbert.ca']
 
-  spec.summary       = %q{Gem to interact with the Piwigo API}
-  spec.description   = %q{Piwigo is open source web application to manage your collection of photos, and other medias. Piwigo provides an API for interacting with it. This is a ruby-based client for interacting with a Piwigo instance using the Piwigo API.}
-  spec.homepage      = "https://github.com/kkdad/piwigo-api"
-  spec.license       = "MIT"
+  spec.summary       = 'Gem to interact with the Piwigo API'
+  spec.description   = 'Piwigo is open source web application to manage your collection of photos, and other medias. Piwigo provides an API for interacting with it. This is a ruby-based client for interacting with a Piwigo instance using the Piwigo API.'
+  spec.homepage      = 'https://github.com/kkdad/piwigo-api'
+  spec.license       = 'MIT'
 
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/kkdad/piwigo-api"
-  spec.metadata["changelog_uri"] = "https://github.com/kkdad/piwigo-api/CHANGELOG.md"
-  spec.metadata["documentation_uri"] = "https://rubydoc.info/github/KKDad/piwigo-api/master"
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/kkdad/piwigo-api'
+  spec.metadata['changelog_uri'] = 'https://github.com/kkdad/piwigo-api/CHANGELOG.md'
+  spec.metadata['documentation_uri'] = 'https://rubydoc.info/github/KKDad/piwigo-api/master'
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
-  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
-  spec.bindir        = "exe"
+  spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 2.0"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency 'bundler', '~> 2.0'
+  spec.add_development_dependency 'codecov', '>= 0.1.10'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'rake', '~> 10.0'
 
-  spec.add_runtime_dependency "logger", "~>1.4"
-  spec.add_runtime_dependency "http", "~>4.2"
+  spec.add_runtime_dependency 'http', '~>4.2'
+  spec.add_runtime_dependency 'logger', '~>1.4'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: piwigo-api
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Adrian Gilbert
@@ -25,19 +25,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: codecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 0.1.10
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: 0.1.10
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -53,19 +53,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '5.0'
 - !ruby/object:Gem::Dependency
-  name: logger
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
-  type: :runtime
+        version: '10.0'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.4'
+        version: '10.0'
 - !ruby/object:Gem::Dependency
   name: http
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
 description: Piwigo is open source web application to manage your collection of photos,
   and other medias. Piwigo provides an API for interacting with it. This is a ruby-based
   client for interacting with a Piwigo instance using the Piwigo API.
@@ -92,6 +106,7 @@ files:
 - ".github/workflows/gempush.yml"
 - ".github/workflows/ruby.yml"
 - ".gitignore"
+- ".rubocop.yaml"
 - ".travis.yml"
 - ".vscode/launch.json"
 - CHANGELOG.md
@@ -105,6 +120,7 @@ files:
 - codecov.yml
 - lib/piwigo.rb
 - lib/piwigo/albums.rb
+- lib/piwigo/image_uploader.rb
 - lib/piwigo/images.rb
 - lib/piwigo/session.rb
 - lib/piwigo/version.rb