koala 1.8.0 → 1.9.0rc1

data/spec/support/koala_test.rb

@@ -55,17 +55,12 @@ module KoalaTest
     RSpec.configure do |config|
       config.before :each do
         @token = KoalaTest.oauth_token
-        Koala::Utils.stub(:deprecate) # never fire deprecation warnings
+        allow(Koala::Utils).to receive(:deprecate) # never fire deprecation warnings
+        # Clean up Koala config
+        Koala.reset_config
       end
 
       config.after :each do
-        # Clean up Koala config
-        Koala.configure do |config|
-          Koala::HTTPService::DEFAULT_SERVERS.each_pair do |k, v|
-            config.send("#{k}=", v)
-          end
-        end
-
         # if we're working with a real user, clean up any objects posted to Facebook
         # no need to do so for test users, since they get deleted at the end
         if @temporary_object_id && KoalaTest.real_user?

data/spec/support/rest_api_shared_examples.rb

@@ -3,7 +3,7 @@ shared_examples_for "Koala RestAPI" do
   describe "when making a rest request" do
     it "uses the proper path" do
       method = double('methodName')
-      @api.should_receive(:api).with(
+      expect(@api).to receive(:api).with(
         "method/#{method}",
         anything,
         anything,
@@ -14,7 +14,7 @@ shared_examples_for "Koala RestAPI" do
     end
 
     it "always uses the rest api" do
-      @api.should_receive(:api).with(
+      expect(@api).to receive(:api).with(
         anything,
         anything,
         anything,
@@ -27,7 +27,7 @@ shared_examples_for "Koala RestAPI" do
     it "sets the read_only option to true if the method is listed in the read-only list" do
       method = Koala::Facebook::RestAPI::READ_ONLY_METHODS.first
 
-      @api.should_receive(:api).with(
+      expect(@api).to receive(:api).with(
         anything,
         anything,
         anything,
@@ -40,7 +40,7 @@ shared_examples_for "Koala RestAPI" do
     it "sets the read_only option to false if the method is not inthe read-only list" do
       method = "I'm not a read-only method"
 
-      @api.should_receive(:api).with(
+      expect(@api).to receive(:api).with(
         anything,
         anything,
         anything,
@@ -54,7 +54,7 @@ shared_examples_for "Koala RestAPI" do
     it "takes an optional hash of arguments" do
       args = {:arg1 => 'arg1'}
 
-      @api.should_receive(:api).with(
+      expect(@api).to receive(:api).with(
         anything,
         hash_including(args),
         anything,
@@ -65,7 +65,7 @@ shared_examples_for "Koala RestAPI" do
     end
 
     it "always asks for JSON" do
-      @api.should_receive(:api).with(
+      expect(@api).to receive(:api).with(
         anything,
         hash_including('format' => 'json'),
         anything,
@@ -78,7 +78,7 @@ shared_examples_for "Koala RestAPI" do
     it "passes any options provided to the API" do
       options = {:a => 2}
 
-      @api.should_receive(:api).with(
+      expect(@api).to receive(:api).with(
         anything,
         hash_including('format' => 'json'),
         anything,
@@ -89,7 +89,7 @@ shared_examples_for "Koala RestAPI" do
     end
 
     it "uses get by default" do
-      @api.should_receive(:api).with(
+      expect(@api).to receive(:api).with(
         anything,
         anything,
         "get",
@@ -101,7 +101,7 @@ shared_examples_for "Koala RestAPI" do
 
     it "allows you to specify other http methods as the last argument" do
       method = 'bar'
-      @api.should_receive(:api).with(
+      expect(@api).to receive(:api).with(
         anything,
         anything,
         method,
@@ -112,8 +112,8 @@ shared_examples_for "Koala RestAPI" do
     end
 
     it "throws an APIError if the status code >= 400" do
-      Koala.stub(:make_request).and_return(Koala::HTTPService::Response.new(500, '{"error_code": "An error occurred!"}', {}))
-      lambda { @api.rest_call(KoalaTest.user1, {}) }.should raise_exception(Koala::Facebook::APIError)
+      allow(Koala).to receive(:make_request).and_return(Koala::HTTPService::Response.new(500, '{"error_code": "An error occurred!"}', {}))
+      expect { @api.rest_call(KoalaTest.user1, {}) }.to raise_exception(Koala::Facebook::APIError)
     end
   end
 
@@ -126,29 +126,29 @@ shared_examples_for "Koala RestAPI with an access token" do
   describe "#set_app_properties" do
     it "sends Facebook the properties JSON-encoded as :properties" do
       props = {:a => 2, :c => [1, 2, "d"]}
-      @api.should_receive(:rest_call).with(anything, hash_including(:properties => MultiJson.dump(props)), anything, anything)
+      expect(@api).to receive(:rest_call).with(anything, hash_including(:properties => MultiJson.dump(props)), anything, anything)
       @api.set_app_properties(props)
     end
 
     it "calls the admin.setAppProperties method" do
-      @api.should_receive(:rest_call).with("admin.setAppProperties", anything, anything, anything)
+      expect(@api).to receive(:rest_call).with("admin.setAppProperties", anything, anything, anything)
       @api.set_app_properties({})
     end
 
     it "includes any other provided arguments" do
       args = {:c => 3, :d => "a"}
-      @api.should_receive(:rest_call).with(anything, hash_including(args), anything, anything)
+      expect(@api).to receive(:rest_call).with(anything, hash_including(args), anything, anything)
       @api.set_app_properties({:a => 2}, args)
     end
 
     it "includes any http_options provided" do
       opts = {:c => 3, :d => "a"}
-      @api.should_receive(:rest_call).with(anything, anything, opts, anything)
+      expect(@api).to receive(:rest_call).with(anything, anything, opts, anything)
       @api.set_app_properties({}, {}, opts)
     end
 
     it "makes a POST" do
-      @api.should_receive(:rest_call).with(anything, anything, anything, "post")
+      expect(@api).to receive(:rest_call).with(anything, anything, anything, "post")
       @api.set_app_properties({})
     end
 
@@ -156,14 +156,13 @@ shared_examples_for "Koala RestAPI with an access token" do
       oauth = Koala::Facebook::OAuth.new(KoalaTest.app_id, KoalaTest.secret)
       app_token = oauth.get_app_access_token
       @app_api = Koala::Facebook::API.new(app_token)
-      @app_api.set_app_properties(KoalaTest.app_properties).should be_true
+      expect(@app_api.set_app_properties(KoalaTest.app_properties)).to be_truthy
     end
   end
 end
 
-
 shared_examples_for "Koala RestAPI without an access token" do
   it "can't use set_app_properties" do
-    lambda { @api.set_app_properties(:desktop => 0) }.should raise_error(Koala::Facebook::AuthenticationError)
+    expect { @api.set_app_properties(:desktop => 0) }.to raise_error(Koala::Facebook::AuthenticationError)
   end
 end

data/spec/support/uploadable_io_shared_examples.rb

@@ -8,21 +8,21 @@ shared_examples_for "MIME::Types can't return results" do
     it "should properly get content types for #{extension} using basic analysis" do
       path = "filename.#{extension}"
       if @koala_io_params[0].is_a?(File)
-        @koala_io_params[0].stub(:path).and_return(path)
+        allow(@koala_io_params[0]).to receive(:path).and_return(path)
       else
         @koala_io_params[0] = path
       end
-      Koala::UploadableIO.new(*@koala_io_params).content_type.should == mime_type
+      expect(Koala::UploadableIO.new(*@koala_io_params).content_type).to eq(mime_type)
     end
 
     it "should get content types for #{extension} using basic analysis with file names with more than one dot" do
       path = "file.name.#{extension}"
       if @koala_io_params[0].is_a?(File)
-        @koala_io_params[0].stub(:path).and_return(path)
+        allow(@koala_io_params[0]).to receive(:path).and_return(path)
       else
         @koala_io_params[0] = path
       end
-      Koala::UploadableIO.new(*@koala_io_params).content_type.should == mime_type
+      expect(Koala::UploadableIO.new(*@koala_io_params).content_type).to eq(mime_type)
     end
   end
 
@@ -30,14 +30,14 @@ shared_examples_for "MIME::Types can't return results" do
     before :each do
       path = "badfile.badextension"
       if @koala_io_params[0].is_a?(File)
-        @koala_io_params[0].stub(:path).and_return(path)
+        allow(@koala_io_params[0]).to receive(:path).and_return(path)
       else
         @koala_io_params[0] = path
       end
     end
 
     it "should throw an exception" do
-      lambda { Koala::UploadableIO.new(*@koala_io_params) }.should raise_exception(Koala::KoalaError)
+      expect { Koala::UploadableIO.new(*@koala_io_params) }.to raise_exception(Koala::KoalaError)
     end
   end
 end
@@ -46,15 +46,15 @@ shared_examples_for "determining a mime type" do
   describe "if MIME::Types is available" do
     it "should return an UploadIO with MIME::Types-determined type if the type exists" do
       type_result = ["type"]
-      Koala::MIME::Types.stub(:type_for).and_return(type_result)
-      Koala::UploadableIO.new(*@koala_io_params).content_type.should == type_result.first
+      allow(Koala::MIME::Types).to receive(:type_for).and_return(type_result)
+      expect(Koala::UploadableIO.new(*@koala_io_params).content_type).to eq(type_result.first)
     end
   end
 
   describe "if MIME::Types is unavailable" do
     before :each do
       # fake that MIME::Types doesn't exist
-      Koala::MIME::Types.stub(:type_for).and_raise(NameError)
+      allow(Koala::MIME::Types).to receive(:type_for).and_raise(NameError)
     end
     it_should_behave_like "MIME::Types can't return results"
   end
@@ -62,7 +62,7 @@ shared_examples_for "determining a mime type" do
   describe "if MIME::Types can't find the result" do
     before :each do
       # fake that MIME::Types doesn't exist
-      Koala::MIME::Types.stub(:type_for).and_return([])
+      allow(Koala::MIME::Types).to receive(:type_for).and_return([])
     end
 
     it_should_behave_like "MIME::Types can't return results"

metadata

@@ -1,83 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: koala
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 1.9.0rc1
 platform: ruby
 authors:
 - Alex Koppel
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-23 00:00:00.000000000 Z
+date: 2014-02-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
   name: addressable
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Koala is a lightweight, flexible Ruby SDK for Facebook.  It allows read/write
@@ -92,11 +64,11 @@ extra_rdoc_files:
 - readme.md
 - changelog.md
 files:
-- .autotest
-- .gitignore
-- .rspec
-- .travis.yml
-- .yardopts
+- ".autotest"
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- ".yardopts"
 - Gemfile
 - Guardfile
 - LICENSE
@@ -148,7 +120,6 @@ files:
 - spec/support/graph_api_shared_examples.rb
 - spec/support/koala_test.rb
 - spec/support/mock_http_service.rb
-- spec/support/ordered_hash.rb
 - spec/support/rest_api_shared_examples.rb
 - spec/support/uploadable_io_shared_examples.rb
 homepage: http://github.com/arsduo/koala
@@ -156,25 +127,25 @@ licenses: []
 metadata: {}
 post_install_message: 
 rdoc_options:
-- --line-numbers
-- --inline-source
-- --title
+- "--line-numbers"
+- "--inline-source"
+- "--title"
 - Koala
 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'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.6
+rubygems_version: 2.2.1
 signing_key: 
 specification_version: 4
 summary: A lightweight, flexible library for Facebook with support for the Graph API,
@@ -204,7 +175,6 @@ test_files:
 - spec/support/graph_api_shared_examples.rb
 - spec/support/koala_test.rb
 - spec/support/mock_http_service.rb
-- spec/support/ordered_hash.rb
 - spec/support/rest_api_shared_examples.rb
 - spec/support/uploadable_io_shared_examples.rb
 has_rdoc: 

data/spec/support/ordered_hash.rb

@@ -1,201 +0,0 @@
-module KoalaTest
-  # directly taken from Rails 3.1's OrderedHash
-  # see https://github.com/rails/rails/blob/master/activesupport/lib/active_support/ordered_hash.rb
-
-  # The order of iteration over hashes in Ruby 1.8 is undefined. For example, you do not know the
-  # order in which +keys+ will return keys, or +each+ yield pairs. <tt>ActiveSupport::OrderedHash</tt>
-  # implements a hash that preserves insertion order, as in Ruby 1.9:
-  #
-  #   oh = ActiveSupport::OrderedHash.new
-  #   oh[:a] = 1
-  #   oh[:b] = 2
-  #   oh.keys # => [:a, :b], this order is guaranteed
-  #
-  # <tt>ActiveSupport::OrderedHash</tt> is namespaced to prevent conflicts with other implementations.
-  class OrderedHash < ::Hash #:nodoc:
-    def to_yaml_type
-      "!tag:yaml.org,2002:omap"
-    end
-
-    def encode_with(coder)
-      coder.represent_seq '!omap', map { |k,v| { k => v } }
-    end
-
-    def to_yaml(opts = {})
-      if YAML.const_defined?(:ENGINE) && !YAML::ENGINE.syck?
-        return super
-      end
-
-      YAML.quick_emit(self, opts) do |out|
-        out.seq(taguri) do |seq|
-          each do |k, v|
-            seq.add(k => v)
-          end
-        end
-      end
-    end
-
-    def nested_under_indifferent_access
-      self
-    end
-
-    # Hash is ordered in Ruby 1.9!
-    if RUBY_VERSION < '1.9'
-
-      # In MRI the Hash class is core and written in C. In particular, methods are
-      # programmed with explicit C function calls and polymorphism is not honored.
-      #
-      # For example, []= is crucial in this implementation to maintain the @keys
-      # array but hash.c invokes rb_hash_aset() originally. This prevents method
-      # reuse through inheritance and forces us to reimplement stuff.
-      #
-      # For instance, we cannot use the inherited #merge! because albeit the algorithm
-      # itself would work, our []= is not being called at all by the C code.
-
-      def initialize(*args, &block)
-        super
-        @keys = []
-      end
-
-      def self.[](*args)
-        ordered_hash = new
-
-        if (args.length == 1 && args.first.is_a?(Array))
-          args.first.each do |key_value_pair|
-            next unless (key_value_pair.is_a?(Array))
-            ordered_hash[key_value_pair[0]] = key_value_pair[1]
-          end
-
-          return ordered_hash
-        end
-
-        unless (args.size % 2 == 0)
-          raise ArgumentError.new("odd number of arguments for Hash")
-        end
-
-        args.each_with_index do |val, ind|
-          next if (ind % 2 != 0)
-          ordered_hash[val] = args[ind + 1]
-        end
-
-        ordered_hash
-      end
-
-      def initialize_copy(other)
-        super
-        # make a deep copy of keys
-        @keys = other.keys
-      end
-
-      def []=(key, value)
-        @keys << key unless has_key?(key)
-        super
-      end
-
-      def delete(key)
-        if has_key? key
-          index = @keys.index(key)
-          @keys.delete_at index
-        end
-        super
-      end
-
-      def delete_if
-        super
-        sync_keys!
-        self
-      end
-
-      def reject!
-        super
-        sync_keys!
-        self
-      end
-
-      def reject(&block)
-        dup.reject!(&block)
-      end
-
-      def keys
-        @keys.dup
-      end
-
-      def values
-        @keys.collect { |key| self[key] }
-      end
-
-      def to_hash
-        self
-      end
-
-      def to_a
-        @keys.map { |key| [ key, self[key] ] }
-      end
-
-      def each_key
-        return to_enum(:each_key) unless block_given?
-        @keys.each { |key| yield key }
-        self
-      end
-
-      def each_value
-        return to_enum(:each_value) unless block_given?
-        @keys.each { |key| yield self[key]}
-        self
-      end
-
-      def each
-        return to_enum(:each) unless block_given?
-        @keys.each {|key| yield [key, self[key]]}
-        self
-      end
-
-      alias_method :each_pair, :each
-
-      alias_method :select, :find_all
-
-      def clear
-        super
-        @keys.clear
-        self
-      end
-
-      def shift
-        k = @keys.first
-        v = delete(k)
-        [k, v]
-      end
-
-      def merge!(other_hash)
-        if block_given?
-          other_hash.each { |k, v| self[k] = key?(k) ? yield(k, self[k], v) : v }
-        else
-          other_hash.each { |k, v| self[k] = v }
-        end
-        self
-      end
-
-      alias_method :update, :merge!
-
-      def merge(other_hash, &block)
-        dup.merge!(other_hash, &block)
-      end
-
-      # When replacing with another hash, the initial order of our keys must come from the other hash -ordered or not.
-      def replace(other)
-        super
-        @keys = other.keys
-        self
-      end
-
-      def invert
-        OrderedHash[self.to_a.map!{|key_value_pair| key_value_pair.reverse}]
-      end
-
-      private
-        def sync_keys!
-          @keys.delete_if {|k| !has_key?(k)}
-        end
-    end
-  end
-end