s3mpi 0.0.8.1 → 0.1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 15963407068406352b0c91e2305bf5ef1c97d487
-  data.tar.gz: b1107fa62e9bc82a5278585c76427fb395cdda50
+  metadata.gz: 731d6db40c690f6acfbccc15328e39c16367d7d3
+  data.tar.gz: 02bfc423b1e53b87af1675bccfa6cc2141ac283a
 SHA512:
-  metadata.gz: 548cd924ed23bb7e9dd0a4723182c0b0706bc195ae6b66316965d79990219acc92050a28e92557c44af3e56b8820dd2240e1737c24536993c7561bbd86c7851e
-  data.tar.gz: 00206b142dd05916ee9b138250d87ff416e68ad343142e19f7d595457f8e951d9872aa9b8a14ef8acc4c45d2c8e973ab2f0d4f8bc3ccc7404baa61267d9d8f61
+  metadata.gz: 76e4335229d0b998df64da0c80fe006b76c18bfdd841079d8897baae10202f5ee8cf4f12684a673c42da174c222d507bd43227727810d2f93ca9b13d08ad3a9f
+  data.tar.gz: 3eda26cf66c847cd1264cc5f969af053514ac0ddb26963924d3806ae43bbc69bbefb7e0e85ce755efa0b601bc1c2f181cbec1178f2a24b6039e1f610f0014a3e

data/.travis.yml

@@ -1,4 +1,3 @@
 language: ruby
 rvm:
-  - 1.9.3
-# env: CODECLIMATE_REPO_TOKEN=540a9a9dd5d7371276ffd320c85d936726dd362b6b2c0333017c13ff5e133a7d 
+  - 2.2

data/README.md

@@ -1,4 +1,4 @@
-S3 uploads of Ruby objects [![Build Status](https://travis-ci.org/robertzk/s3mpi.svg?branch=master)](https://travis-ci.org/robertzk/s3mpi) [![Code Climate](https://codeclimate.com/github/robertzk/s3mpi.png)](https://codeclimate.com/github/robertzk/s3mpi)
+S3 uploads of Ruby objects [![Build Status](https://travis-ci.org/robertzk/s3mpi-ruby.svg?branch=master)](https://travis-ci.org/robertzk/s3mpi-ruby)
 ===========
 
 Upload and download Ruby objects to S3 using a very convenient API.
@@ -22,5 +22,3 @@ we can store and read Ruby objects:
 MPI.store({ some: "ruby", object: 5 }, "some_object")
 MPI.read('some_object')
 ```
-
-

data/lib/s3mpi.rb

@@ -1,5 +1,4 @@
 require 's3mpi/version'
-require 's3mpi/converters'
 require 's3mpi/interface'
 
 module S3MPI

data/lib/s3mpi/converters.rb

@@ -1,6 +1,21 @@
 require 's3mpi/converters/csv'
+require 's3mpi/converters/json'
+require 's3mpi/converters/identity'
 
 module S3MPI
   module Converters
+
+    class UnknownConverterError < StandardError; end
+
+    def converter(as)
+      case as
+      when :json then Converters::JSON
+      when :csv  then Converters::CSV
+      when :string, :identity then Converters::Identity
+      else
+        raise UnknownConverterError, "#{as.inspect} is not a known converter!"
+      end
+    end
+
   end
-end
+end

data/lib/s3mpi/converters/csv.rb

@@ -5,17 +5,7 @@ module S3MPI
     module CSV
       extend self
 
-      # Read a CSV file and convert it to an array of hashes
-      #
-      # @param [String] csv_file_path
-      #    Path to the CSV file.
-      #
-      # @param [Hash] options
-      #    Passed to CSV.parse
-      def file_to_obj(csv_file_path, options = Hash.new)
-        csv_data = File.read(csv_file_path)
-        string_to_obj(csv_data, options)
-      end
+      class HeaderError < StandardError; end
 
       # Convert CSV string data to an array of hashes
       #
@@ -24,14 +14,46 @@ module S3MPI
       #
       # @param [Hash] options
       #    Passed to CSV.parse
-      def string_to_obj(csv_data, options = Hash.new)
+      #
+      # @return [Array]
+      def parse(csv_data, options = Hash.new)
         options = options.merge({
                                   headers:    true,
                                   converters: :all
-
                                 })
         ::CSV.parse(csv_data, options).map(&:to_hash)
       end
+
+      # Convert an array of hashes to CSV string data
+      #
+      # @param [Array] array_of_hashes
+      #    An Array of Hashes
+      #
+      # @param [Hash] options
+      #    Passed to CSV.generate
+      #
+      # @return [String]
+      def generate(array_of_hashes, options = Hash.new)
+        return "" if array_of_hashes.empty?
+        headers = inspect_headers(array_of_hashes)
+        ::CSV.generate(options) do |csv|
+          csv << headers
+          array_of_hashes.each do |hash|
+            csv << hash.values_at(*headers)
+          end
+        end
+      end
+
+      private
+
+      def inspect_headers(data)
+        data.first.keys.tap do |headers|
+          sorted = headers.sort
+          error  = data.any?{ |hash| hash.keys.sort != sorted }
+          raise HeaderError, "the rows have inconsistent headers!" if error
+        end
+      end
+
     end
   end
-end
+end

data/lib/s3mpi/converters/identity.rb

@@ -0,0 +1,16 @@
+module S3MPI
+  module Converters
+    module Identity
+      extend self
+
+      def parse(data, options = nil)
+        data
+      end
+
+      def generate(data)
+        data
+      end
+
+    end
+  end
+end

data/lib/s3mpi/converters/json.rb

@@ -0,0 +1,19 @@
+require 'json'
+
+module S3MPI
+  module Converters
+    module JSON
+      extend self
+
+      def parse(json_string, options = Hash.new)
+        opts = { quirks_mode: true }.merge(options)
+        ::JSON.parse(json_string || 'null', **opts)
+      end
+
+      def generate(object, options = Hash.new)
+        object.to_json(options)
+      end
+
+    end
+  end
+end

data/lib/s3mpi/interface.rb

@@ -1,12 +1,12 @@
-require 'json'
-require 's3mpi/format'
 require 's3mpi/s3'
 require 's3mpi/converters'
 
 module S3MPI
   class Interface
-    include Format
     include S3
+    include Converters
+
+    UUID = Object.new.freeze
 
     # Return S3 bucket under use.
     #
@@ -18,96 +18,69 @@ module S3MPI
     # @return [String]
     attr_reader :path
 
+    # Return the default converter for store & read.
+    #
+    # @return [String]
+    attr_reader :default_converter
+
     # Create a new S3MPI object that responds to #read and #store.
     #
     # @return [S3MPI::Interface]
     #
     # @api public
-    def initialize _bucket, path = ''
-      @bucket = _bucket
-      @path   = path
+    def initialize bucket, path = '', default_converter = :json
+      @bucket = parse_bucket(bucket)
+      @path   = path.freeze
+      converter(default_converter) # verify it is valid
+      @default_converter = default_converter
     end
 
     # Store a Ruby object in an S3 bucket.
-    # 
+    #
     # @param [Object] obj
-    #    Any JSON-serializable Ruby object (usually a hash or array).
+    #    Any convertable Ruby object (usually a hash or array).
     # @param [String] key
     #    The key under which to save the object in the S3 bucket.
-    # @param [Integer] try
+    # @param [Symbol] :as
+    #    Which converter to use e.g. :json, :csv, :string
+    # @param [Integer] tries
     #    The number of times to attempt to store the object.
-    def store(obj, key = SecureRandom.uuid, try = 1)
-      s3_object(key).write(obj.to_json)
-    rescue # This should really rescue specific errors
-      (try -= 1) > 0 ? retry : raise
+    def store(obj, key = UUID, as: default_converter, tries: 1)
+      key = SecureRandom.uuid if key.equal?(UUID)
+      s3_object(key).write(converter(as).generate(obj))
+    rescue AWS::Errors::Base
+      (tries -= 1) > 0 ? retry : raise
     end
 
+    def store_csv(obj, key = UUID); store(obj, key, as: :csv); end
+    def store_json(obj, key = UUID); store(obj, key, as: :json); end
+    def store_string(obj, key = UUID); store(obj, key, as: :string); end
 
-    # Load a CSV file, and store the contents in S3
-    # Proxies to store
-    #
-    # @param [String] csv_file_path
-    #     Path to the CSV file.
+    # Read and de-serialize an object from an S3 bucket.
     #
-    # @param [Hash] options Options hash.
-    #    Passed to CSV.parse
-    def store_csv(csv_file_path, options = Hash.new)
-      store(Converters::CSV.file_to_obj(csv_file_path, options))
-    end
-
-    # Store a raw object
-    # @param [Object] obj
-    #    The object to store.
-    # @param [String] key
-    #    The key under which the object is saved in the S3 bucket.
-    def store_raw(obj, key)
-      s3_object(key).write(obj)
-    end
-
-    # Read a JSON-serialized Ruby object from an S3 bucket.
-    # 
     # @param [String] key
     #    The key under which to save the object in the S3 bucket.
-    def read key = nil
-      parse_json_allowing_quirks_mode s3_object(key).read
+    # @param [Symbol] :as
+    #    Which converter to use e.g. :json, :csv, :string
+    def read(key = nil, as: default_converter)
+      converter(as).parse(s3_object(key).read)
     rescue AWS::S3::Errors::NoSuchKey
       nil
     end
 
-    # Read a CSV file from an S3 bucket. Return as array of hashes.
-    #
-    # @param [String] key
-    #    The key under which the file is saved in the S3 bucket.
-    def read_csv(key=nil)
-      Converters::CSV.string_to_obj(s3_object(key).read)
-    rescue AWS::S3::Errors::NoSuchKey
-      nil
-    end
+    def read_csv(key = nil); read(key, as: :csv); end
+    def read_json(key = nil); read(key, as: :json); end
+    def read_string(key = nil); read(key, as: :string); end
 
     # Check whether a key exists for this MPI interface.
-    # 
+    #
     # @param [String] key
     #    The key under which to save the object in the S3 bucket.
-    #    
+    #
     # @return [TrueClass,FalseClass]
     def exists?(key)
       s3_object(key).exists?
     end
 
-    # Fetch the S3 object as an AWS::S3::S3Object.
-    # 
-    # @param [String] name
-    #    The key under which to save the object in the S3 bucket.
-    #    
-    # @return [AWS::S3::S3Object]
-    def object(key)
-      AWS::S3::S3Object.new(bucket, "#{@path}#{key}")
-    end
-
-    def bucket
-      @_bucket ||= parse_bucket @bucket
-    end
   end
 end
-
-    

data/lib/s3mpi/s3.rb

@@ -3,12 +3,24 @@ require 'aws-sdk-v1'
 module S3MPI
   module S3
 
-    def parse_bucket(bucket) 
+    def s3_object(name)
+      bucket.objects[full_object_key(name)]
+    end
+
+    private
+
+    def parse_bucket(bucket)
       AWS::S3.new.buckets[bucket]
     end
 
-    def s3_object name
-      bucket.objects[[path, name].join('/')]
+    def full_object_key(name)
+      [path, name].flatten.reject{ |x| blank?(x) }.join('/')
+    end
+
+    def blank?(x)
+      return true if !x
+      return true if x.is_a?(String) && x.strip == ""
+      false
     end
 
   end

data/lib/s3mpi/version.rb

@@ -1,9 +1,9 @@
 module S3MPI
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 0
-    PATCH = 8
-    BUILD = 1
+    MINOR = 1
+    PATCH = 0
+    BUILD = 2
 
     STRING = [MAJOR, MINOR, PATCH, BUILD].compact.join('.');
   end

data/s3mpi.gemspec

@@ -26,7 +26,7 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency 'rake', '~> 10.1.0'
   s.add_development_dependency 'rspec', '~> 3.4'
+  s.add_development_dependency 'pry', '~> 0.10.4'
 
   s.extra_rdoc_files = ['README.md', 'LICENSE']
 end
-

data/spec/s3mpi/converters/csv_spec.rb

@@ -1,25 +1,46 @@
 require 'spec_helper'
-require_relative 'parsed_csv_shared_examples'
 
-module S3MPI
-  module Converters
-    describe CSV do
+describe S3MPI::Converters::CSV do
+  let(:csv_file_path) { 'spec/support/test.csv' }
+  let(:csv_data_string) { File.read csv_file_path }
 
-      let(:csv_file_path) { 'spec/support/test.csv' }
-      let(:csv_data_string) { File.read csv_file_path }
+  let(:csv_as_array_of_hashes) {
+    [
+      {'integer' => 1, 'string' => 'user1@test.com', 'float' => 1.11},
+      {'integer' => 2, 'string' => 'user2@test.com', 'float' => 2.22},
+      {'integer' => 3, 'string' => 'user3@test.com', 'float' => 3.33},
+    ]
+  }
 
-      describe '#convert_to_obj' do
-        subject { described_class.string_to_obj csv_data_string }
+  describe '#parse' do
+    subject { described_class.parse csv_data_string }
 
-        it_behaves_like 'a parsed CSV'
-      end
+    it 'converts CSV data to an array of hashes' do
+      expect(subject).to be_kind_of Array
 
-      describe '#file_to_obj' do
-        subject { described_class.file_to_obj csv_file_path }
+      subject.each do |row|
+        expect(row).to be_kind_of Hash
+      end
+    end
 
-        it_behaves_like 'a parsed CSV'
+    it 'preserves integers' do
+      subject.each do |row|
+        expect(row['integer']).to eq(row['integer'].to_s.to_i)
+      end
+    end
 
+    it 'preserves floats' do
+      subject.each do |row|
+        expect(row['float']).to eq(row['float'].to_s.to_f)
       end
     end
+
+    it { is_expected.to eql csv_as_array_of_hashes }
+  end
+
+  describe '#generate' do
+    subject { described_class.generate csv_as_array_of_hashes }
+
+    it { is_expected.to eql csv_data_string }
   end
 end

data/spec/s3mpi/converters/identity_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe S3MPI::Converters::Identity do
+
+  describe '#parse' do
+    let(:data){ "any\nrandom\nstring" }
+
+    it 'returns the input data' do
+      expect(described_class.parse(data)).to equal data
+    end
+  end
+
+  describe '#generate' do
+    let(:data){ "any\nrandom\nstring" }
+
+    it 'returns the input data' do
+      expect(described_class.generate(data)).to equal data
+    end
+  end
+
+end

data/spec/s3mpi/converters/json_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe S3MPI::Converters::JSON do
+
+  describe '#parse' do
+    it 'loads a JSON hash' do
+      expect(described_class.parse('{ "a": 1, "b": "test" }')
+                           ).to eql({ "a" => 1, "b" => "test"})
+    end
+
+    it 'loads a JSON array' do
+      expect(described_class.parse('["a", 1, "b", 2]')
+                           ).to eql(["a", 1, "b", 2])
+    end
+
+    it 'loads a JSON array of hashes' do
+      expect(described_class.parse('[{ "a": "one" }, {"b": "two" }]')
+                           ).to eql([{ "a" => "one" }, {"b" => "two"}])
+    end
+
+    it 'loads a single JSON element' do
+      expect(described_class.parse('"hello world"')
+                           ).to eql("hello world")
+    end
+
+    it 'loads the JSON null as nil' do
+      expect(described_class.parse('null')).to be_nil
+    end
+  end
+
+  describe '#generate' do
+    it 'dumps a Hash' do
+      expect(described_class.generate({ "a" => 1, "b" => "test"})
+                           ).to eql('{"a":1,"b":"test"}')
+    end
+
+    it 'dumps an Array' do
+      expect(described_class.generate(["a", 1, "b", 2])
+                           ).to eql('["a",1,"b",2]')
+    end
+
+    it 'dumps an Array of Hashes' do
+      expect(described_class.generate([{ "a" => "one" }, {"b" => "two"}])
+                           ).to eql('[{"a":"one"},{"b":"two"}]')
+    end
+
+    it 'dumps a String' do
+      expect(described_class.generate("hello world")
+                           ).to eql('"hello world"')
+    end
+
+    it 'dumps nil as the JSON null' do
+      expect(described_class.generate(nil)).to eql 'null'
+    end
+  end
+
+end

data/spec/s3mpi/interface_spec.rb

@@ -1,41 +1,186 @@
 require 'spec_helper'
-require 's3mpi/interface'
-require 's3mpi/converters/csv'
-require_relative '../s3mpi/converters/parsed_csv_shared_examples'
 
-module S3MPI
+describe S3MPI::Interface do
+  let(:bucket) { 'some_bucket' }
+  let(:path)   { 'some_folder' }
 
-  describe Interface do
+  let(:interface) { described_class.new(bucket, path) }
 
-    let(:bucket) { 'some_bucket' }
-    let(:path) { 'some_folder' }
-    let(:csv_file_path) { 'spec/support/test.csv' }
-    let(:csv_data_string) { File.read csv_file_path }
-    let(:csv_as_array_of_hashes) {
-      [
-        {'integer' => 1, 'string' => 'user1@test.com', 'float' => 1.11},
-        {'integer' => 2, 'string' => 'user2@test.com', 'float' => 2.22},
-        {'integer' => 3, 'string' => 'user3@test.com', 'float' => 3.33},
-      ]
-    }
+  describe '#bucket' do
+    subject{ interface.bucket }
+    it { is_expected.to be_a AWS::S3::Bucket }
+    it { is_expected.to have_attributes(name: bucket) }
+  end
+
+  describe '#path' do
+    subject{ interface.path }
+    it { is_expected.to eql path }
+  end
+
+  describe '#default_converter' do
+    subject{ interface.default_converter }
+
+    context 'default' do
+      it { is_expected.to eql :json }
+    end
+
+    context 'set on initialization to :csv' do
+      let(:interface) { described_class.new(bucket, path, :csv) }
+      it { is_expected.to eql :csv }
+    end
+
+    it "initialization fails if it is invalid" do
+      expect{ described_class.new(bucket, path, :foo) }.to raise_error \
+        S3MPI::Converters::UnknownConverterError
+    end
+  end
+
+  describe '#converter' do
+    def expect_converter(key, klass)
+      expect(interface.converter(key)).to eql klass
+    end
+
+    it('json'){ expect_converter :json, S3MPI::Converters::JSON }
+    it('csv') { expect_converter :csv,  S3MPI::Converters::CSV  }
+    it('string'){ expect_converter :string, S3MPI::Converters::Identity }
+    it('identity'){ expect_converter :identity, S3MPI::Converters::Identity }
+
+    it "raises for unknown keys" do
+      err = S3MPI::Converters::UnknownConverterError
+      msg = ":foo is not a known converter!"
+      expect{ interface.converter(:foo) }.to raise_error(err, msg)
+    end
+  end
+
+  describe '#s3_object' do
+    subject { interface.s3_object(name) }
+
+    let(:name) { 'foo/bar/baz' }
+
+    it { is_expected.to be_a AWS::S3::S3Object }
+    it { is_expected.to have_attributes(bucket: interface.bucket) }
+    it { is_expected.to have_attributes(key: "#{path}/#{name}") }
+
+    { 'empty' => '', 'whitespace' => '  ', 'nil' => nil }.each do |desc, value|
+      context "#{desc} path" do
+        let(:path) { value }
+        it { is_expected.to have_attributes(key: name) }
+      end
+
+      context "#{desc} name" do
+        let(:name) { value }
+        it { is_expected.to have_attributes(key: path) }
+      end
+    end
+  end
+
+  context "with a pinned s3_object" do
+    def pin_s3_objects!
+      s3_objects_to_pin.each do |key, s3_obj|
+        allow(interface).to receive(:s3_object).with(key).and_return(s3_obj)
+      end
+    end
 
-    let(:interface) { described_class.new(bucket: bucket, path: path) }
-    subject { interface }
+    def s3_objects_to_pin(*keys)
+      (@to_pin ||= {}).tap do |h|
+        keys.each { |k| h[k] = interface.s3_object(k) }
+      end
+    end
 
-    describe '.store_csv' do
-      it 'sends the CSV as a row of hashes to .store' do
-        expect(subject).to receive(:store).with(csv_as_array_of_hashes)
+    let(:name) { 'name' }
 
-        subject.store_csv csv_file_path
+    before  { s3_objects_to_pin(name) && AWS.stub! }
+    subject { pin_s3_objects! && s3_objects_to_pin[name] }
+
+    describe '#exists?' do
+      it 'calls .exists? on the s3 object' do
+        expect(subject).to receive(:exists?).and_return(retval = double)
+        expect(interface.exists?(name)).to equal retval
       end
     end
 
-    describe '.read_csv' do
+    let(:as_json) { '{"a":1,"b":"two","c":[3,3,3]}' }
+    let(:as_hash) { { "a" => 1, "b" => "two", "c" => [3,3,3] } }
+
+    let(:as_csv)  { "x,y,z\n1,2,3\n4,5,6\n7,8,9\n" }
+    let(:as_list) { [{"x" => 1, "y" => 2, "z" => 3},
+                     {"x" => 4, "y" => 5, "z" => 6},
+                     {"x" => 7, "y" => 8, "z" => 9}] }
+
+    let(:random_str) { 10.times.map{ SecureRandom.uuid}.join("\n") }
 
-      before { allow(interface).to receive(:s3_object) { double(read: csv_data_string) } }
-      subject { interface.read_csv csv_file_path }
-      it_behaves_like 'a parsed CSV'
+    describe '#read' do
+      it 'can parse the raw string with the json converter' do
+        expect(subject).to receive(:read).and_return(as_json).twice
+        expect(interface.read(name, as: :json)).to eql(as_hash)
+        expect(interface.read_json(name)).to eql(as_hash)
+      end
+
+      it 'can parse the raw string with the csv converter' do
+        expect(subject).to receive(:read).and_return(as_csv).twice
+        expect(interface.read(name, as: :csv)).to eql(as_list)
+        expect(interface.read_csv(name)).to eql(as_list)
+      end
 
+      it 'can parse the raw string with the identity converter' do
+        expect(subject).to receive(:read).and_return(random_str).twice
+        expect(interface.read(name, as: :identity)).to eql(random_str)
+        expect(interface.read_string(name)).to eql(random_str)
+      end
+
+      it 'defaults to the default_converter' do
+        allow(interface).to receive(:default_converter).and_return(:foo)
+        expect(subject).to receive(:read).and_return(as_json)
+        expect(interface).to receive(:converter
+                        ).with(:foo).and_return(S3MPI::Converters::Identity)
+        expect(interface.read(name)).to eql as_json
+      end
+    end
+
+    describe '#store' do
+      it 'can generate json and write it to s3' do
+        expect(subject).to receive(:write).with(as_json).twice
+        interface.store(as_hash, name, as: :json)
+        interface.store_json(as_hash, name)
+      end
+
+      it 'can generate csv and write it to s3' do
+        expect(subject).to receive(:write).with(as_csv).twice
+        interface.store(as_list, name, as: :csv)
+        interface.store_csv(as_list, name)
+      end
+
+      it 'can write the raw string to s3' do
+        expect(subject).to receive(:write).with(random_str).twice
+        interface.store(random_str, name, as: :identity)
+        interface.store_string(random_str, name)
+      end
+
+      it 'uses a UUID if the key is not explicitly passed' do
+        s3_objects_to_pin('some_uuid')
+        expect(subject).not_to receive(:write)
+        expect(SecureRandom).to receive(:uuid).and_return('some_uuid')
+        expect(s3_objects_to_pin['some_uuid']).to receive(:write).with(as_json)
+        interface.store(as_hash)
+      end
+
+      it 'defaults to the default_converter' do
+        expect(subject).to receive(:write).with(random_str)
+        allow(interface).to receive(:default_converter).and_return(:foo)
+        expect(interface).to receive(:converter
+                        ).with(:foo).and_return(S3MPI::Converters::Identity)
+        interface.store(random_str, name)
+      end
+
+      it 'retries on AWS::Errors::ServerError' do
+        error = AWS::S3::Errors::RequestTimeout
+        expect(subject).to receive(:write).and_raise(error).twice
+        expect(subject).to receive(:write).and_return("SUCCESS")
+        generator = S3MPI::Converters::JSON
+        expect(generator).to receive(:generate).with(as_hash).exactly(3).times
+        expect(interface.store(as_hash, name, tries: 3)).to eql "SUCCESS"
+      end
     end
   end
+
 end

data/spec/spec_helper.rb

@@ -1,9 +1,6 @@
 # encoding: utf-8
 require 's3mpi'
 
-Dir["#{File.dirname(__FILE__)}/{support,shared}/**/*.rb"].each { |f| require f }
-
 RSpec.configure do |config|
   # Nothing yet...
 end
-

data/spec/support/test.csv

@@ -1,4 +1,4 @@
 integer,string,float
 1,user1@test.com,1.11
 2,user2@test.com,2.22
-3,user3@test.com,3.33
+3,user3@test.com,3.33

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: s3mpi
 version: !ruby/object:Gem::Version
-  version: 0.0.8.1
+  version: 0.1.0.2
 platform: ruby
 authors:
 - Robert Krzyzanowski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-07 00:00:00.000000000 Z
+date: 2017-02-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-v1
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.4
 description: Passing objects between Ruby consoles can be cumbersome if the user has
   performed some serialization and deserialization procedure. S3MPI aims to enable
   simple reading and writing to S3 buckets without the typical overhead of the AWS
@@ -72,15 +86,16 @@ files:
 - lib/s3mpi.rb
 - lib/s3mpi/converters.rb
 - lib/s3mpi/converters/csv.rb
-- lib/s3mpi/format.rb
+- lib/s3mpi/converters/identity.rb
+- lib/s3mpi/converters/json.rb
 - lib/s3mpi/interface.rb
 - lib/s3mpi/s3.rb
 - lib/s3mpi/version.rb
 - s3mpi.gemspec
 - spec/s3mpi/converters/csv_spec.rb
-- spec/s3mpi/converters/parsed_csv_shared_examples.rb
+- spec/s3mpi/converters/identity_spec.rb
+- spec/s3mpi/converters/json_spec.rb
 - spec/s3mpi/interface_spec.rb
-- spec/s3mpi/s3_spec.rb
 - spec/spec_helper.rb
 - spec/support/test.csv
 homepage: https://github.com/robertzk/s3mpi-ruby
@@ -103,14 +118,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Upload and download files to S3 using a very convenient API.
 test_files:
 - spec/s3mpi/converters/csv_spec.rb
-- spec/s3mpi/converters/parsed_csv_shared_examples.rb
+- spec/s3mpi/converters/identity_spec.rb
+- spec/s3mpi/converters/json_spec.rb
 - spec/s3mpi/interface_spec.rb
-- spec/s3mpi/s3_spec.rb
 - spec/spec_helper.rb
 - spec/support/test.csv

data/lib/s3mpi/format.rb

@@ -1,14 +0,0 @@
-require 'json'
-
-module S3MPI
-  module Format
-
-    def parse_json_allowing_quirks_mode obj
-      JSON.parse(obj || 'null')
-    rescue JSON::ParserError => e
-      JSON.parse(obj || 'null', quirks_mode: true)
-    end
-
-  end
-end
-

data/spec/s3mpi/converters/parsed_csv_shared_examples.rb

@@ -1,21 +0,0 @@
-RSpec.shared_examples 'a parsed CSV' do
-  it 'converts CSV data to an array of hashes' do
-    expect(subject).to be_kind_of Array
-
-    subject.each do |row|
-      expect(row).to be_kind_of Hash
-    end
-  end
-
-  it 'preserves integers' do
-    subject.each do |row|
-      expect(row['integer']).to eq(row['integer'].to_s.to_i)
-    end
-  end
-
-  it 'preserves floats' do
-    subject.each do |row|
-      expect(row['float']).to eq(row['float'].to_s.to_f)
-    end
-  end
-end

data/spec/s3mpi/s3_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-module S3MPI
-
-  describe Format do
-    let(:format_mixin) {
-      klass = Class.new
-      klass.send :include, Format
-      klass.new
-    }
-
-    it 'expects #parse_json_allowing_quirks_mode to parse JSON' do
-      obj = {"a" => 1, "b" => "test"}
-      expect(format_mixin.parse_json_allowing_quirks_mode(obj.to_json)).to eql(obj)
-    end
-
-  end
-
-end