RubyGems - s4 - Versions diffs - 0.0.2 → 0.0.3 - Mend

s4 0.0.2 → 0.0.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

data/README.md ADDED Viewed

@@ -0,0 +1,85 @@
+S4
+==
+A Simpler API for Amazon Web Services S3.
+It does not implement the full S3 API, nor is that the intention. It just does
+the basics (managing files in a bucket) in a very simple way with a
+<del>very</del> small code footprint.
+Usage
+-----
+    $assets = S4.connect("s3://0PN5J17HBGZHT7JJ3X82:k3nL7gH3+PadhTEVn5EXAMPLE@s3.amazonaws.com/assets.mysite.com")
+    $assets.upload("puppy.jpg", "animals/puppy.jpg")
+    $assets.upload("penguin.jpg", "animals/penguin.jpg")
+    $assets.list("animals/") #=> [ "animals/puppy.jpg", "animals/penguin.jpg" ]
+    $assets.download("animals/penguin.jpg", "penguin.jpg")
+    $assets.delete("animals/penguin.jpg")
+    $assets.list("animals/") #=> [ "animals/puppy.jpg" ]
+    $assets.upload("ufo.jpg")
+    $assets.list #=> [ "ufo.jpg", "animals/puppy.jpg" ]
+Low-level access:
+    $assets.get("animals/gigantic_penguin_movie.mp4") do |response|
+      File.open("gigantic_penguin_movie.mp4", "wb") do |io|
+        response.read_body do |chunk|
+          io.write(chunk)
+          puts "."
+        end
+      end
+    end
+    $assets.put(StringIO.new("My Novel -- By Ben Alavi...", "r"), "novel.txt", "text/plain")
+Create a bucket (returns the bucket if it already exists and is accessible):
+    $musics = S4.create("s3://0PN5J17HBGZHT7JJ3X82:k3nL7gH3+PadhTEVn5EXAMPLE@s3.amazonaws.com/musics.mysite.com")
+Make a bucket into a static website:
+    $site = S4.connect("s3://0PN5J17HBGZHT7JJ3X82:k3nL7gH3+PadhTEVn5EXAMPLE@s3.amazonaws.com/website.mysite.com")
+    $site.website!
+    $site.put(StringIO.new("<!DOCTYPE html><html><head><title>My Website</title></head><body><h1><blink><font color="yellow">HELLO! WELCOME TO MY WEBSITE</font></blink></h1></body></html>", "r"), "index.html")
+    Net::HTTP.get("http://#{$site.website}/") #=> ...HELLO! WELCOME TO MY WEBSITE...
+Plus a handful of other miscellaneous things...
+Acknowledgements
+----------------
+* Michel Martens
+* Chris Schneider
+* Damian Janowski
+* Cyril David
+License
+-------
+Copyright (c) 2011 Ben Alavi
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/lib/s4.rb CHANGED Viewed

@@ -2,21 +2,43 @@ require "net/http/persistent"
 require "rexml/document"
 require "base64"
 require "time"
+require "json"
 # Simpler AWS S3 library
 class S4
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
   # sub-resource names which may appear in the query string and also must be
   # signed against.
   SubResources = %w( acl location logging notification partNumber policy requestPayment torrent uploadId uploads versionId versioning versions website )
   # Header over-rides which may appear in the query string and also must be
-  # signed against.
+  # signed against (in addition those which begin w/ 'x-amz-')
   HeaderValues = %w( response-content-type response-content-language response-expires reponse-cache-control response-content-disposition response-content-encoding )
+  # List of available ACLs on buckets, first is used as default
+  # http://docs.amazonwebservices.com/AmazonS3/latest/API/index.html?RESTBucketPUT.html
+  BucketACLs = %w( private public-read public-read-write authenticated-read bucket-owner-read bucket-owner-full-control )
+  # Named policies
+  Policy = {
+    public_read: %Q{\{
+      "Version": "2008-10-17",
+      "Statement": [{
+        "Sid": "AllowPublicRead",
+        "Effect": "Allow",
+        "Principal": {"AWS": "*"},
+        "Action": ["s3:GetObject"],
+        "Resource": ["arn:aws:s3:::%s/*"]
+      }]
+    \}}
+  }.freeze
   attr_reader :connection, :access_key_id, :secret_access_key, :bucket, :host
+  # Cannot call #new explicitly (no reason to), use #connect instead
+  private_class_method :new
   class << self
     # Connect to an S3 bucket.
     #
@@ -27,14 +49,14 @@ class S4
     #
     # i.e.
     #   bucket = S4.connect #=> Connects to ENV["S3_URL"]
-    #   bucket = S4.connect("s3://0PN5J17HBGZHT7JJ3X82:k3nL7gH3+PadhTEVn5EXAMPLE@s3.amazonaws.com/bucket")
-    def connect(s3_url=ENV["S3_URL"])
-      new(s3_url).tap do |s4|
+    #   bucket = S4.connect(url: "s3://0PN5J17HBGZHT7JJ3X82:k3nL7gH3+PadhTEVn5EXAMPLE@s3.amazonaws.com/bucket")
+    def connect(options={})
+      init(options) do |s4|
         s4.connect
       end
     end
-    # Create an S3 bucket.
+    # Create a new S3 bucket.
     #
     # See #connect for S3_URL parameters.
     #
@@ -43,14 +65,21 @@ class S4
     #
     # i.e.
     #   bucket = S4.create
-    def create(s3_url=ENV["S3_URL"])
-      new(s3_url).tap do |s4|
-        s4.create
+    def create(options={})
+      init(options) do |s4|
+        s4.create(options[:acl] || BucketACLs.first)
+      end
+    end
+    private
+    def init(options={}, &block)
+      new(options.has_key?(:url) ? options[:url] : ENV["S3_URL"]).tap do |s4|
+        yield(s4) if block_given?
       end
     end
   end
-  # Initialize a new S3 bucket connection.
   def initialize(s3_url=ENV["S3_URL"])
     raise ArgumentError, "No S3 URL provided. You can set ENV['S3_URL'], too." if s3_url.nil? || s3_url.empty?
@@ -72,13 +101,26 @@ class S4
   # Since S3 doesn't really require a persistent connection this really just
   # makes sure that it *can* connect (i.e. the bucket exists and you own it).
   def connect
-    raise NoSuchBucket.new(bucket) if request(uri("/", query: "location")).nil?
-  end
+    location
+  end
   # Create the S3 bucket.
-  def create
-    uri = URI::HTTP.build(host: host, path: "/#{bucket}")
-    request uri, Net::HTTP::Put.new(uri.request_uri)
+  #
+  # If the bucket exists and you own it will not do anything, if it exists and
+  # you don't own it will raise an error.
+  #
+  # Optionally pass an ACL for the new bucket, see BucketACLs for valid ACLs.
+  #
+  # Default ACL is "private"
+  def create(acl=BucketACLs.first)
+    raise ArgumentError.new("Invalid ACL '#{acl}' for bucket. Available ACLs are: #{BucketACLs.join(", ")}.") unless BucketACLs.include?(acl)
+    uri = uri("/")
+    req = Net::HTTP::Put.new(uri.request_uri)
+    req.add_field "x-amz-acl", acl
+    request uri, req
   end
   # Lower level object get which just yields the successful S3 response to the
@@ -120,15 +162,26 @@ class S4
     put File.open(name, "rb"), destination || File.basename(name)
   end
-  def put(io, name)
+  # Write an IO stream to a file in this bucket.
+  #
+  # Will write file with content_type if given, otherwise will attempt to
+  # determine content type by shelling out to POSIX `file` command (if IO
+  # stream responds to #path). If no content_type could be determined, will
+  # default to application/x-www-form-urlencoded.
+  #
+  # i.e.
+  #   bucket.put(StringIO.new("Awesome!"), "awesome.txt", "text/plain")
+  def put(io, name, content_type=nil)
     uri = uri(name)
     req = Net::HTTP::Put.new(uri.request_uri)
-    req.body_stream = io
+    content_type = `file -ib #{io.path}`.chomp if !content_type && io.respond_to?(:path)
+    req.add_field "Content-Type", content_type
     req.add_field "Content-Length", io.size
-    req.add_field "Content-Type", "application/x-www-form-urlencoded"
+    req.body_stream = io
-    request(URI::HTTP.build(host: host, path: "/#{bucket}/#{name}"), req)
+    request uri("/#{name}"), req
   end
   # List bucket contents.
@@ -141,6 +194,82 @@ class S4
     REXML::Document.new(request(uri("", query: "prefix=#{prefix}"))).elements.collect("//Key", &:text)
   end
+  # Turns this bucket into a S3 static website bucket.
+  #
+  # IMPORTANT: by default a policy will be applied to the bucket allowing read
+  # access to all files contained in the bucket.
+  #
+  # i.e.
+  #   site = S4.connect(url: "s3://0PN5J17HBGZHT7JJ3X82:k3nL7gH3+PadhTEVn5EXAMPLE@s3.amazonaws.com/mywebsite")
+  #   site.website!
+  #   site.put(StringIO.new("<!DOCTYPE html><html><head><title>Robots!</title></head><body><h1>So many robots!!!</h1></body></html>", "r"), "index.html")
+  #   Net::HTTP.get(URI.parse("http://mywebsite.s3.amazonaws.com/")) #=> ...<h1>So many robots!!!</h1>...
+  def website!
+    self.policy = Policy[:public_read] % bucket
+    uri = uri("/", query: "website")
+    req = Net::HTTP::Put.new(uri.request_uri)
+    req.body = <<-XML
+    <WebsiteConfiguration xmlns="http://s3.amazonaws.com/doc/2006-03-01/">
+      <IndexDocument>
+        <Suffix>index.html</Suffix>
+      </IndexDocument>
+      <ErrorDocument>
+        <Key>404.html</Key>
+      </ErrorDocument>
+    </WebsiteConfiguration>
+    XML
+    request uri, req
+  end
+  # The URL of the bucket for use as a website.
+  def website
+    "#{bucket}.s3-website-#{location}.amazonaws.com"
+  end
+  # Sets the given policy on the bucket.
+  #
+  # Policy can be given as a string which will be applied as given, a hash
+  # which will be converted to json, or the name of a pre-defined policy as a
+  # symbol.
+  #
+  # See S4::Policy for pre-defined policies.
+  #
+  # i.e.
+  #   $s4 = S4.connect
+  #   $s4.policy = :public_read #=> apply named policy
+  #   $s4.policy = {"Statement" => "..."} #=> apply policy as hash
+  #   $s4.policy = "{\"Statement\": \"...\"}" #=> apply policy as string
+  def policy=(policy)
+    policy = Policy[policy] % bucket if policy.is_a?(Symbol)
+    uri = uri("/", query: "policy")
+    req = Net::HTTP::Put.new(uri.request_uri)
+    req.body = policy.is_a?(String) ? policy : policy.to_json
+    request uri, req
+  end
+  # Gets the policy on the bucket.
+  def policy
+    request uri("/", query: "policy")
+  end
+  # Gets information about the buckets location.
+  def location
+    response = request uri("/", query: "location")
+    location = REXML::Document.new(response).elements["LocationConstraint"].text
+    location || "us-east-1"
+  end
+  def inspect
+    "#<S4: bucket='#{bucket}'>"
+  end
   private
   def connection
@@ -164,7 +293,7 @@ class S4
           return response.body
         end
       else
-        raise Error.from_response(response)
+        raise Error.new(response)
       end
     end
   end
@@ -173,19 +302,22 @@ class S4
     date = Time.now.utc.rfc822
     request.add_field "Date", date
-    request.add_field "Authorization", "AWS #{access_key_id}:#{signature(uri, request)}"
+    request.add_field "Content-Type", "application/x-www-form-urlencoded" if request.is_a?(Net::HTTP::Put) && !request["Content-Type"]
+    request.add_field "Authorization", "AWS #{access_key_id}:#{signature(uri, request)}"
     request
   end
   def signature(uri, request)
     query = signed_params(uri.query) if uri.query
+    string_to_sign = "#{request.class::METHOD}\n\n#{request["Content-Type"]}\n#{request["Date"]}\n#{canonicalized_headers(request)}" + "#{uri.path}" + (query ? "?#{query}"  : "")
     Base64.encode64(
       OpenSSL::HMAC.digest(
         OpenSSL::Digest::Digest.new("sha1"),
         secret_access_key,
-        "#{request.class::METHOD}\n\n#{request["Content-Type"]}\n#{request.fetch("Date")}\n" + uri.path + (query ? "?#{query}"  : "")
+        string_to_sign
       )
     ).chomp
   end
@@ -198,28 +330,33 @@ class S4
       collect{ |param| param.split("=") }.
       reject{ |pair| !SubResources.include?(pair[0]) }.
       collect{ |pair| pair.join("=") }.
+      sort.
       join("&")
     signed unless signed.empty?
   end
+  def canonicalized_headers(request)
+    headers = request.to_hash.
+      reject{ |k, v| k !~ /x-amz-/ && !HeaderValues.include?(k) }.
+      collect{ |k, v| "#{k}:#{v.join(",")}" }.
+      sort.
+      join("\n")
+    "#{headers}\n" unless headers.empty?
+  end
   # Base class of all S3 Errors
   class Error < ::RuntimeError
-    attr_reader :code, :status
-    def self.from_response(response)
-      doc = REXML::Document.new(response.body).elements["//Error"]
-      code = doc.elements["Code"].text
-      message = doc.elements["Message"].text
-      new response.code, code, message
-    end
-    def initialize(status, code, message)
-      @status = status
-      @code = code
+    attr_reader :code, :status, :response
+    def initialize(response)
+      @response = REXML::Document.new(response.body).elements["//Error"]
+      @status = response.code
+      @code = @response.elements["Code"].text
-      super "#{@code}: #{message}"
+      super "#{@status}: #{@code} -- " + @response.elements["Message"].text
     end
   end
 end

data/{Rakefile → rakefile} RENAMED Viewed

File without changes

data/s4.gemspec CHANGED Viewed

@@ -10,15 +10,14 @@ Gem::Specification.new do |s|
   s.homepage = "http://github.com/benalavi/s4"
   s.files = Dir[
-    "LICENSE",
-    "README.markdown",
-    "Rakefile",
+    "README.md",
+    "rakefile",
+    "s4.gemspec",
     "lib/**/*.rb",
-    "*.gemspec",
     "test/**/*.rb"
   ]
-  s.add_dependency "net-http-persistent", "~> 1.7"
+  s.add_dependency "net-http-persistent", ">= 1.7"
   s.add_development_dependency "cutest"
   s.add_development_dependency "timecop", "~> 0.3"

data/test/s4_test.rb CHANGED Viewed

@@ -1,6 +1,10 @@
+raise "You need to have ENV[\"S3_URL\"] set for the tests to connect to your testing bucket on S3. Format is: 's3://<access key id>:<secret access key>@s3.amazonaws.com/<s4 test bucket>'." unless ENV["S3_URL"]
+raise "You need to have ENV[\"S4_NEW_BUCKET\"], which will be dynamically created and destroyed for testing bucket creation. i.e.: 's4-test-bucketthatdoesntexist'." unless ENV["S3_URL"]
 require "contest"
 require "timecop"
 require "fileutils"
+require "open-uri"
 begin
   require "ruby-debug"
@@ -9,18 +13,24 @@ end
 require File.expand_path("../lib/s4", File.dirname(__FILE__))
-def fixture(filename="")
-  File.join(File.dirname(__FILE__), "fixtures", filename)
-end
+TestBucket = S4.connect.bucket
+NewBucket = ENV["S4_NEW_BUCKET"]
-def output(filename="")
-  File.join(File.dirname(__FILE__), "output", filename)
-end
+class S4Test < Test::Unit::TestCase
+  def fixture(filename="")
+    File.join(File.dirname(__FILE__), "fixtures", filename)
+  end
-NewBucket = "s4-bucketthatdoesntexist"
-TestBucket = "s4-test-bucket"
+  def output(filename="")
+    File.join(File.dirname(__FILE__), "output", filename)
+  end
-class S4Test < Test::Unit::TestCase
+  def delete_test_bucket
+    `s3cmd del 's3://#{TestBucket}/abc/*' 2>&1`
+    `s3cmd del 's3://#{TestBucket}/*' 2>&1`
+    `s3cmd rb 's3://#{TestBucket}' 2>&1`
+  end
   setup do
     FileUtils.rm_rf(output)
     FileUtils.mkdir_p(output)
@@ -29,52 +39,152 @@ class S4Test < Test::Unit::TestCase
   context "connecting to S3" do
     should "return connected bucket if can connect" do
       s4 = S4.connect
+      assert s4
+    end
+    should "bark when no URL is provided" do
+      assert_raise(ArgumentError) { S4.connect(url: "") }
+      assert_raise(ArgumentError) { S4.connect(url: nil) }
+      assert_raise(URI::InvalidURIError) { S4.connect(url: "s3://foo:bar/baz") }
     end
     should "raise error if cannot connect" do
+      `s3cmd del 's3://#{NewBucket}/*' 2>&1`
       `s3cmd rb 's3://#{NewBucket}' 2>&1`
       assert_raise(S4::Error) do
-        S4.connect ENV["S3_URL"].sub(TestBucket, NewBucket)
+        S4.connect url: ENV["S3_URL"].sub(TestBucket, NewBucket)
       end
     end
   end
   context "when S3 errors occur" do
     # foo is taken bucket, will cause 409 Conflict on create
     should "raise on S3 errors" do
       assert_raise(S4::Error) do
-        S4.create(ENV["S3_URL"].sub(TestBucket, "foo"))
+        S4.create url: ENV["S3_URL"].sub(TestBucket, "foo")
       end
     end
     should "capture code of S3 error" do
       begin
-        S4.create(ENV["S3_URL"].sub(TestBucket, "foo"))
+        S4.create url: ENV["S3_URL"].sub(TestBucket, "foo")
       rescue S4::Error => e
-        assert_equal "409", e.status
+        assert_equal "409", e.status, "Expected 409 got #{e.message}"
       end
     end
   end
   context "creating a bucket" do
     setup do
+      `s3cmd del 's3://#{NewBucket}/*' 2>&1`
       `s3cmd rb 's3://#{NewBucket}' 2>&1`
     end
     should "create a bucket" do
       assert_equal "ERROR: Bucket '#{NewBucket}' does not exist", `s3cmd ls 's3://#{NewBucket}' 2>&1`.chomp
-      s4 = S4.create ENV["S3_URL"].sub(TestBucket, NewBucket)
+      S4.create url: ENV["S3_URL"].sub(TestBucket, NewBucket)
       assert_equal "", `s3cmd ls 's3://#{NewBucket}' 2>&1`.chomp
     end
+    should "create bucket with public-read ACL" do
+      # TODO...
+    end
+    should "raise if bucket creation failed" do
+      assert_raise(S4::Error) do
+        S4.create url: ENV["S3_URL"].sub(TestBucket, "foo")
+      end
+    end
+    should "raise if given invalid ACL" do
+      begin
+        S4.create url: ENV["S3_URL"], acl: "foo"
+      rescue ArgumentError => e
+        assert_match /foo/, e.message
+      end
+    end
   end
+  context "making a website" do
+    setup do
+      delete_test_bucket
+    end
+    should "make bucket a website" do
+      s4 = S4.create
+      begin
+        open("http://#{s4.website}/")
+      rescue OpenURI::HTTPError => e
+        assert_match /NoSuchWebsiteConfiguration/, e.io.read
+      end
+      s4.put(StringIO.new("<!DOCTYPE html><html><head><title>Robot Page</title></head><body><h1>Robots!</h1></body></html>", "r"), "index.html", "text/html")
+      s4.put(StringIO.new("<!DOCTYPE html><html><head><title>404!</title></head><body><h1>Oh No 404!!!</h1></body></html>", "r"), "404.html", "text/html")
+      s4.website!
+      assert_match /Robots!/, open("http://#{s4.website}/").read
+      begin
+        open("http://#{s4.website}/foo.html")
+      rescue OpenURI::HTTPError => e
+        raise e unless e.message =~ /404/
+        assert_match /Oh No 404!!!/, e.io.read
+      end
+    end
+  end
+  context "setting policy on a bucket" do
+    setup do
+      delete_test_bucket
+      @s4 = S4.create
+    end
+    should "make all objects public by policy" do
+      @s4.upload(fixture("foo.txt"))
+      begin
+        open("http://s3.amazonaws.com/#{TestBucket}/foo.txt")
+      rescue OpenURI::HTTPError => e
+        assert_match /403 Forbidden/, e.message
+      end
+      @s4.policy = :public_read
+      assert_equal "abc123", open("http://s3.amazonaws.com/#{TestBucket}/foo.txt").read
+    end
+  end
+  context "uploading to bucket" do
+    setup do
+      delete_test_bucket
+      @s4 = S4.create
+      @s4.policy = :public_read
+    end
+    should "upload foo.txt" do
+      @s4.upload(fixture("foo.txt"))
+      foo = open("http://s3.amazonaws.com/#{TestBucket}/foo.txt")
+      assert_equal "abc123", foo.read
+      assert_equal "text/plain", foo.content_type
+    end
+    should "use given content_type" do
+      @s4.put(StringIO.new("abcdef", "r"), "bar.txt", "text/foobar")
+      assert_equal "text/foobar", open("http://s3.amazonaws.com/#{TestBucket}/bar.txt").content_type
+    end
+  end
   context "when connected" do
     setup do
       @s4 = S4.connect
     end
     should "download foo.txt" do
       `s3cmd put #{fixture("foo.txt")} s3://#{@s4.bucket}/foo.txt`
       @s4.download("foo.txt", output("foo.txt"))
@@ -111,9 +221,9 @@ class S4Test < Test::Unit::TestCase
     end
     should "return list of items in bucket" do
+      `s3cmd del 's3://#{@s4.bucket}/*'`
       `s3cmd del 's3://#{@s4.bucket}/abc/*'`
-      `s3cmd del 's3://#{@s4.bucket}/boom.txt'`
-      `s3cmd del 's3://#{@s4.bucket}/foo\ bar+baz.txt'`
       `s3cmd put #{fixture("foo.txt")} s3://#{@s4.bucket}/foo.txt`
       `s3cmd put #{fixture("foo.txt")} s3://#{@s4.bucket}/bar.txt`
       `s3cmd put #{fixture("foo.txt")} s3://#{@s4.bucket}/baz.txt`
@@ -134,18 +244,5 @@ class S4Test < Test::Unit::TestCase
       @s4.get("foo bar+baz.txt") { |response| assert_equal "abc123", response.body }
     end
-    should "upload foo.txt" do
-      `s3cmd del 's3://#{@s4.bucket}/foo.txt'`
-      @s4.upload(fixture("foo.txt"))
-      @s4.get("foo.txt") { |response| assert_equal "abc123", response.body }
-    end
-    should "bark when no URL is provided" do
-      assert_raise(ArgumentError) { S4.connect("") }
-      assert_raise(ArgumentError) { S4.connect(nil) }
-      assert_raise(URI::InvalidURIError) { S4.connect("s3://foo:bar/baz") }
-    end
   end
 end

metadata CHANGED Viewed

@@ -2,7 +2,7 @@
 name: s4
 version: !ruby/object:Gem::Version
   prerelease:
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Ben Alavi
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
-date: 2011-09-01 00:00:00 Z
+date: 2011-09-04 00:00:00 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: net-http-persistent
@@ -18,7 +18,7 @@ dependencies:
   requirement: &id001 !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
         version: "1.7"
   type: :runtime
@@ -55,9 +55,10 @@ extensions: []
 extra_rdoc_files: []
 files:
-- Rakefile
-- lib/s4.rb
+- README.md
+- rakefile
 - s4.gemspec
+- lib/s4.rb
 - test/s4_test.rb
 homepage: http://github.com/benalavi/s4
 licenses: []