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

s4 0.0.2 → 0.0.3

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: []