maileva 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d8ca9ba68df975a784e13aeab62b11624890aeff
+  data.tar.gz: a64e42a7244fc5a87be7d84ff8591aea06e3be83
+SHA512:
+  metadata.gz: 561e961547f2e3127c52fa467c64e17fa0d2aafe1a7ac78cc3a069bce4ca4712ce0d61ae05b1c291c38e0bf51ed395c9acc82561819b77711dfb51e44ee74c0f
+  data.tar.gz: 86a87d330a994d6465b25b34c3ddf3069546700d2e578a5c04a832cd6cd3f032a68b2c2ab47ee0a6250607d37d226ee066d56d080485d9c72777fd4d13c772c2

data/LICENSE

@@ -0,0 +1,27 @@
+Copyright © 2016, Kévin Lesénéchal <kevin.lesenechal@gmail.com>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+  1. Redistributions of source code must retain the above copyright notice, this
+     list of conditions and the following disclaimer.
+
+  2. Redistributions in binary form must reproduce the above copyright notice,
+     this list of conditions and the following disclaimer in the documentation
+     and/or other materials provided with the distribution.
+
+  3. Neither the name of the copyright holder nor the names of its contributors
+     may be used to endorse or promote products derived from this software
+     without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,33 @@
+# Maileva API #
+
+This gem allows you to send postal mails through the **Maileva** system (of La Poste).
+
+## Installation ##
+
+Put this in your `Gemfile`:
+
+    gem 'maileva'
+
+To include all the necessary classes, do:
+
+    require 'maileva'
+
+## Configuration ##
+
+Use `Maileva.config` to configure the default settings of the API like your
+Maileva credentials. Example:
+
+    Maileva.config.ftp_login = "my_login"
+
+The available configuration variables are:
+
+ * `files_root`: (`Pathname`, not `String`!) A directory where temporary PDF files
+   to send will be stored;
+ * `ftp_login`: (`String`) Your Maileva FTP login;
+ * `ftp_password`: (`String`) Your Maileva FTP password;
+ * `client_id`: (`String`) Your Maileva client ID;
+ * `confirmation_threshold`: (Integer, optional) The maximum number of files which
+   can be sent without confirmation. Default: 100.
+
+### Setting rules ###
+

data/lib/core_extensions/net/ftp/maileva.rb

@@ -0,0 +1,27 @@
+module CoreExtensions
+  module Net
+    module FTP
+      module Maileva
+        def file_exists?(path)
+          begin
+            size(path)
+            return true
+          rescue Net::FTPError => e
+            err_code = e.message[0, 3].to_i
+            raise "SIZE unimplemented on server" if err_code == 500 or err_code == 502
+            return false
+          end
+        end
+
+        def putstr(str, remote, &block)
+          f = StringIO.new(str)
+          begin
+            storlines("STOR #{remote}", f, &block)
+          ensure
+            f.close
+          end
+        end
+      end
+    end
+  end
+end

data/lib/maileva.rb

@@ -0,0 +1,67 @@
+# Copyright © 2016, Kévin Lesénéchal <kevin.lesenechal@gmail.com>.
+#
+# This library is licensed under the new BSD license. Checkout the license text
+# in the LICENSE file or online at <http://opensource.org/licenses/BSD-3-Clause>.
+
+require 'core_extensions/net/ftp/maileva'
+require 'double_bag_ftps'
+require 'ostruct'
+
+Net::FTP.include CoreExtensions::Net::FTP::Maileva
+
+module Maileva
+  @@config = OpenStruct.new({
+    files_root:   nil,
+    ftp_login:    nil,
+    ftp_password: nil,
+    client_id:    nil,
+    confirmation_threshold: 100
+  })
+
+  @@confirmation_callbacks = []
+  @@processing_callbacks = []
+  @@done_callbacks = []
+  @@failure_callbacks = []
+
+  @@rules = {}
+  @@batches_in_process = []
+
+  BATCHES_IN_PROCESS_MUTEX = Mutex.new
+
+  def self.config
+    @@config
+  end
+
+  def self.rules
+    @@rules
+  end
+
+  def self.batches_in_process
+    @@batches_in_process
+  end
+
+  def self.add_rule(name, opts)
+    raise ArgumentError, "name: expecting string" if !name.is_a?(Symbol)
+    raise ArgumentError, "Expecting option 'id'" if !opts.key?(:id)
+
+    @@rules[name] = opts
+  end
+
+  def self.on_confirmation_needed(&block)
+    @@confirmation_callbacks << block
+  end
+
+  def self.on_batch_processing(&block)
+    @@processing_callbacks << block
+  end
+
+  def self.on_batch_sent(&block)
+    @@done_callbacks << block
+  end
+
+  def self.on_batch_failure(&block)
+    @@failure_callbacks << block
+  end
+end
+
+require 'maileva/batch'

data/lib/maileva/batch.rb

@@ -0,0 +1,138 @@
+# Copyright © 2016, Kévin Lesénéchal <kevin.lesenechal@gmail.com>.
+#
+# This library is licensed under the new BSD license. Checkout the license text
+# in the LICENSE file or online at <http://opensource.org/licenses/BSD-3-Clause>.
+
+require 'double_bag_ftps'
+
+class Maileva::Batch
+  attr_accessor :type, :name
+  attr_reader   :files, :rule
+
+  PART_SIZE = 30
+
+  def initialize(type, name)
+    raise ArgumentError, "Invalid Maileva batch type '#{type}'" unless type.is_a?(Symbol) and Maileva.rules.key?(type)
+
+    @type  = type
+    @name  = name
+    @rule  = Maileva.rules[@type]
+    @files = []
+  end
+
+  def append_file(*files)
+    files.each do |file|
+      if file.is_a? Array
+        file.each{|f| append_file(f)}
+        return
+      end
+
+      raise ArgumentError, "Expecting string for 'file'" unless file.is_a?(String)
+      raise "#{file}: no such file for batch '#{@name}' (#{@type})" unless File.file?(file)
+      raise "#{file}: expecting .pdf" unless File.extname(file) == ".pdf"
+
+      @files << file
+    end
+  end
+  alias << append_file
+
+  def tmp_dir
+    return Maileva.config.files_root + @type.to_s + @name
+  end
+
+  def uploaded_count
+    return @uploaded_remote_names.size
+  end
+
+  def send
+    if @files.size < Maileva.config.confirmation_threshold
+      send!
+    else
+      FileUtils.mkdir_p tmp_dir unless File.directory?(tmp_dir)
+      @files.each do |file|
+        FileUtils.cp file, tmp_dir + File.basename(file) unless file.start_with? tmp_dir.to_s
+      end
+
+      Maileva.class_variable_get(:@@confirmation_callbacks).each{|proc| proc.call(self)}
+    end
+  end
+
+  def send!(in_db: false)
+    raise "Cannot send empty batch" if @files.size == 0
+
+    Maileva.class_variable_get(:@@processing_callbacks).each{|proc| proc.call(self, in_db)}
+
+    @uploaded_remote_names = []
+    @uploaded_part_names   = []
+
+    Maileva::BATCHES_IN_PROCESS_MUTEX.synchronize{ Maileva.batches_in_process << self }
+
+    ftp = nil
+    begin
+      ftp = DoubleBagFTPS.new
+      ftp.passive = true
+      ftp.connect("ftps.maileva.com", 21)
+      ftp.login(Maileva.config.ftp_login, Maileva.config.ftp_password)
+
+      begin
+        part_no = 1
+        @files.each_slice(PART_SIZE) do |part|
+          send_part(ftp, part, part_no)
+          part_no += 1
+        end
+
+        @uploaded_part_names.each do |part|
+          ftp.rename part + ".tmp", part + ".flw"
+        end
+      rescue Exception => e
+        rollback!(ftp)
+        raise e
+      end
+
+      Maileva.class_variable_get(:@@done_callbacks).each{|proc| proc.call(self)}
+    rescue Exception => e
+      Maileva.class_variable_get(:@@failure_callbacks).each{|proc| proc.call(self)}
+      raise e
+    ensure
+      Maileva::BATCHES_IN_PROCESS_MUTEX.synchronize{ Maileva.batches_in_process.delete(self) }
+      begin; ftp.close unless ftp.nil? or ftp.closed? rescue Exception; end
+    end
+  end
+
+private
+
+  def send_part(ftp, part, part_no)
+    part_name = sprintf "%s_%s_%d", @type, @name, part_no
+    cmd_file_name = part_name + ".tmp"
+    cmd_file = "CLIENT_ID=#{Maileva.config.client_id}\n" +
+               "NB_FILE=#{part.size}\n" +
+               "GATEWAY=FLOW\n" +
+               "FLOW_RULE=#{@rule[:id]}\n"
+    raise "Command file '#{cmd_file_name}' already exists on server" if ftp.file_exists?(cmd_file_name)
+    ftp.putstr "", cmd_file_name
+    @uploaded_part_names << part_name
+
+    file_no = 1
+    part.each do |file|
+      file_name = sprintf "%s.%03d", part_name, file_no
+      cmd_file += "FILE_NAME_#{file_no}=#{file_name}\n" +
+                  "FILE_SIZE_#{file_no}=#{File.size(file)}\n"
+      ftp.put file, file_name
+      Maileva::BATCHES_IN_PROCESS_MUTEX.synchronize{ @uploaded_remote_names << file_name }
+      file_no += 1
+    end
+    ftp.putstr cmd_file, cmd_file_name
+  end
+
+  def rollback!(ftp)
+    @uploaded_part_names.each do |part|
+      begin; ftp.delete part + ".flw" rescue Exception; end
+    end
+    @uploaded_part_names.each do |part|
+      begin; ftp.delete part + ".tmp" rescue Exception; end
+    end
+    @uploaded_remote_names.each do |file|
+      begin; ftp.delete file rescue Exception; end
+    end
+  end
+end

data/spec/batch_spec.rb

@@ -0,0 +1,175 @@
+# Copyright © 2016, Kévin Lesénéchal <kevin.lesenechal@gmail.com>.
+#
+# This library is licensed under the new BSD license. Checkout the license text
+# in the LICENSE file or online at <http://opensource.org/licenses/BSD-3-Clause>.
+
+require 'spec_helper'
+require 'maileva'
+require 'double_bag_ftps'
+require 'fileutils'
+require 'pathname'
+
+RSpec.describe Maileva::Batch do
+  before do
+    Maileva.class_variable_set(:@@rules, {})
+    Maileva.add_rule :grids, id: "bar", name: "baz"
+  end
+
+  it "adds files" do
+    expect(File).to receive(:file?).at_least(:once).and_return(true)
+
+    batch = Maileva::Batch.new(:grids, "my_batch")
+    expect {
+      batch.append_file "lorem.pdf"
+      batch.append_file "ipsum.pdf", "dolor.pdf"
+      batch << "sit.pdf"
+      batch << %w(amet.pdf consectetur.pdf adipiscing.pdf)
+    }.to change{ batch.files }.from([]).to(%w(lorem.pdf ipsum.pdf dolor.pdf sit.pdf amet.pdf consectetur.pdf adipiscing.pdf))
+  end
+
+  it "has a temp directory" do
+    Maileva.config.files_root = Pathname.new("/my/maileva/files")
+    batch = Maileva::Batch.new(:grids, "my_batch")
+    expect(batch.tmp_dir).to eq Pathname.new("/my/maileva/files/grids/my_batch")
+  end
+
+  it "rejects non-existing files" do
+    expect(File).to receive(:file?).with("non_existing.pdf").and_return(false)
+
+    batch = Maileva::Batch.new(:grids, "my_batch")
+    expect {
+      batch << "non_existing.pdf"
+    }.to raise_error("non_existing.pdf: no such file for batch 'my_batch' (grids)")
+  end
+
+  it "rejects non-PDF files" do
+    expect(File).to receive(:file?).with("invalid_file.png").and_return(true)
+
+    batch = Maileva::Batch.new(:grids, "my_batch")
+    expect {
+      batch << "invalid_file.png"
+    }.to raise_error("invalid_file.png: expecting .pdf")
+  end
+
+  it "sends batches if under threshold" do
+    expect(File).to receive(:file?).at_least(:once).and_return(true)
+
+    Maileva.config.confirmation_threshold = 100
+    batch = Maileva::Batch.new(:grids, "my_batch")
+    batch << "hello.pdf" << "world.pdf"
+    expect(batch).to receive(:send!)
+    batch.send
+  end
+
+  it "asks confirmation if above threshold" do
+    expect(File).to receive(:file?).at_least(:once).and_return(true)
+
+    Maileva.config.confirmation_threshold = 2
+    batch = Maileva::Batch.new(:grids, "my_batch")
+    batch << 5.times.map{|i| "file#{i + 1}.pdf"}.each do |file|
+      expect(FileUtils).to receive(:cp).with(file, batch.tmp_dir + file)
+    end
+    confirm_cb = proc{}
+    Maileva.on_confirmation_needed &confirm_cb
+
+    expect(batch.files.size).to eq 5
+    expect(File).to receive(:directory?).with(batch.tmp_dir).and_return(false)
+    expect(FileUtils).to receive(:mkdir_p).with(batch.tmp_dir)
+    expect(confirm_cb).to receive(:call).with(batch)
+    batch.send
+  end
+
+  it "sends files to Maileva" do
+    command_files = {}
+    confirmed_cmds = []
+    uploaded_files = []
+
+    Maileva.config.ftp_login    = "my_login"
+    Maileva.config.ftp_password = "my_pass"
+    Maileva.config.client_id    = "my_client_id"
+
+    expect(File).to receive(:file?).at_least(34).times.and_return(true)
+    expect(File).to receive(:size).at_least(34).times.and_return(14556)
+    expect_any_instance_of(DoubleBagFTPS).to receive(:putstr).at_least(:once) do |ftp, str, remote|
+      command_files[remote] = str
+    end
+    expect_any_instance_of(DoubleBagFTPS).to receive(:put).at_least(:once) do |ftp, local, remote|
+      uploaded_files << remote
+    end
+    expect_any_instance_of(DoubleBagFTPS).to receive(:rename).at_least(:once) do |ftp, from, to|
+      confirmed_cmds << from
+    end
+    expect_any_instance_of(DoubleBagFTPS).to receive(:file_exists?).twice.and_return(false)
+    expect_any_instance_of(DoubleBagFTPS).to receive(:connect).with("ftps.maileva.com", 21)
+    expect_any_instance_of(DoubleBagFTPS).to receive(:login).with("my_login", "my_pass")
+
+    batch = Maileva::Batch.new(:grids, "my_batch")
+    batch << ("a".."z").map{|s| s * 8 + ".pdf" }
+    batch << %w(lorem ipsum dolor sit amet foo bar baz).map{|s| s + ".pdf"}
+
+    processing_cb = proc{}
+    done_cb = proc{}
+    Maileva.on_batch_processing &processing_cb
+    Maileva.on_batch_sent &done_cb
+    expect(processing_cb).to receive(:call).with(batch)
+    expect(done_cb).to receive(:call).with(batch)
+
+    batch.send!
+
+    expect(uploaded_files.size).to eq 34
+    expect(command_files.keys).to eq(["grids_my_batch_1.tmp", "grids_my_batch_2.tmp"])
+    i = 0
+    command_files.values.each do |cmd|
+      expect(cmd).to include "CLIENT_ID=my_client_id\n"
+      expect(cmd).to include "NB_FILE=#{i == 0 ? 30 : 4}\n"
+      expect(cmd).to include "GATEWAY=FLOW\n"
+      expect(cmd).to include "FLOW_RULE=bar\n"
+      j = 1
+      (i == 0 ? uploaded_files[0, 30] : uploaded_files[30..-1]).each do |file|
+        expect(cmd).to include "FILE_NAME_#{j}=#{file}\n"
+        expect(cmd).to include "FILE_SIZE_#{j}=14556\n"
+        j += 1
+      end
+      i += 1
+    end
+    expect(confirmed_cmds).to eq command_files.keys
+  end
+
+  it "rollbacks in case of an error" do
+    Maileva.config.ftp_login    = "my_login"
+    Maileva.config.ftp_password = "my_pass"
+    Maileva.config.client_id    = "my_client_id"
+
+    expect(File).to receive(:file?).at_least(34).times.and_return(true)
+    expect(File).to receive(:size).at_least(34).times.and_return(14556)
+
+    batch = Maileva::Batch.new(:grids, "my_batch")
+    batch << ("a".."z").map{|s| s * 8 + ".pdf" }
+    batch << %w(lorem ipsum dolor sit amet foo bar baz).map{|s| s + ".pdf"}
+
+    expect(batch).to receive(:rollback!).and_call_original
+    expect_any_instance_of(DoubleBagFTPS).to receive(:rename) { raise "Dummy exception" }
+    expect_any_instance_of(DoubleBagFTPS).to receive(:putstr).at_least(:once)
+    expect_any_instance_of(DoubleBagFTPS).to receive(:put).at_least(:once)
+    expect_any_instance_of(DoubleBagFTPS).to receive(:file_exists?).twice.and_return(false)
+    expect_any_instance_of(DoubleBagFTPS).to receive(:connect).with("ftps.maileva.com", 21)
+    expect_any_instance_of(DoubleBagFTPS).to receive(:login).with("my_login", "my_pass")
+    ["grids_my_batch_1", "grids_my_batch_2"].each do |f|
+      expect_any_instance_of(DoubleBagFTPS).to receive(:delete).with(f + ".tmp")
+      expect_any_instance_of(DoubleBagFTPS).to receive(:delete).with(f + ".flw")
+      files = f == "grids_my_batch_1" ? batch.files[0, 30] : batch.files[30..-1]
+      files.each_index do |i|
+        expect_any_instance_of(DoubleBagFTPS).to receive(:delete).with(sprintf "%s.%03d", f, i + 1)
+      end
+    end
+
+    processing_cb = proc{}
+    failure_cb = proc{}
+    Maileva.on_batch_processing &processing_cb
+    Maileva.on_batch_failure &failure_cb
+    expect(processing_cb).to receive(:call).with(batch)
+    expect(failure_cb).to receive(:call).with(batch)
+
+    expect{ batch.send! }.to raise_error("Dummy exception")
+  end
+end

data/spec/maileva_spec.rb

@@ -0,0 +1,17 @@
+# Copyright © 2016, Kévin Lesénéchal <kevin.lesenechal@gmail.com>.
+#
+# This library is licensed under the new BSD license. Checkout the license text
+# in the LICENSE file or online at <http://opensource.org/licenses/BSD-3-Clause>.
+
+require 'spec_helper'
+require 'maileva'
+require 'double_bag_ftps'
+
+RSpec.describe Maileva do
+  it "should add rules" do
+    Maileva.class_variable_set(:@@rules, {})
+    expect {
+      Maileva.add_rule :grids, id: "bar", name: "baz"
+    }.to change{ Maileva.rules }.from({}).to({grids: {id: "bar", name: "baz"}})
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,96 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: maileva
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kévin Lesénéchal
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: double-bag-ftps
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 
+email: kevin.lesenechal@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/core_extensions/net/ftp/maileva.rb
+- lib/maileva.rb
+- lib/maileva/batch.rb
+- spec/batch_spec.rb
+- spec/maileva_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/kevin-lesenechal/paybox_direct
+licenses:
+- BSD-3-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Send mails through Maileva FTP deposit
+test_files: []