tankard 0.0.1 → 0.1.0

data/lib/tankard/api/utils/page_finders.rb

@@ -0,0 +1,67 @@
+require 'tankard/api/request/get'
+
+module Tankard
+  module Api
+    module Utils
+      module PageFinders
+        include ::Enumerable
+        include Tankard::Api::Request::Get
+
+        # Loads data from brewerydb and calls supplied block with resulting data
+        #
+        # @yieldparam [Hash] hash containing individual beer information
+        def each(&block)
+          find_on_single_or_all_pages(http_request_uri, http_client, http_request_parameters, block)
+        end
+
+        private
+
+          def find_on_single_or_all_pages(uri, request, options, block)
+            if options[:p]
+              find_on_single_page(uri, request, options, block)
+            else
+              find_on_all_pages(uri, request, options, block)
+            end
+          end
+
+          def find_on_all_pages(uri, request, options, block)
+            page = 0
+
+            begin
+              page += 1
+              options[:p] = page if page > 1
+              total_pages = find_on_single_page(uri, request, options, block)
+            end while page < total_pages
+          end
+
+          def find_on_single_page(uri, request, options, block)
+            response = get_request(request, uri, options)
+            call_block_with_data(response["data"], block)
+            response["numberOfPages"].to_i
+          end
+
+          def call_block_with_data(data, block)
+            raise Tankard::Error::InvalidResponse unless data
+
+            if data.is_a?(Hash)
+              block.call(data)
+            else
+              data.each { |item| block.call(item) }
+            end
+          end
+
+          def http_request_uri
+            raise NoMethodError.new("Need to implement method")
+          end
+
+          def http_client
+            raise NoMethodError.new("Need to implement method")
+          end
+
+          def http_request_parameters
+            raise NoMethodError.new("Need to implement method")
+          end
+      end
+    end
+  end
+end

data/lib/tankard/client.rb

@@ -1,6 +1,9 @@
 require 'tankard/request'
 require 'tankard/api/beer'
 require 'tankard/api/beers'
+require 'tankard/api/search'
+require 'tankard/api/styles'
+require 'tankard/api/style'
 
 module Tankard
   class Client
@@ -20,5 +23,17 @@ module Tankard
     def beers(options={})
       Tankard::Api::Beers.new(@tankard_request, options)
     end
+
+    def search(options={})
+      Tankard::Api::Search.new(@tankard_request, options)
+    end
+
+    def styles
+      Tankard::Api::Styles.new(@tankard_request)
+    end
+
+    def style(options={})
+      Tankard::Api::Style.new(@tankard_request, options)
+    end
   end
 end

data/lib/tankard/configuration.rb

@@ -8,15 +8,10 @@ module Tankard
     def configure
       yield self
       validate_api_key!
+      reset_client
       self
     end
 
-    def reset!
-      Tankard::Configuration::KEYS.each do |key|
-        instance_variable_set(:"@{key}", nil)
-      end
-    end
-
     private
 
       def credentials
@@ -30,5 +25,9 @@ module Tankard
           raise Tankard::Error::ConfigurationError, "api_key is not a string"
         end
       end
+
+      def reset_client
+        raise Tankard::Error::ConfigurationError, "Implement reset_client"
+      end
   end
 end

data/lib/tankard/error.rb

@@ -1,7 +1,7 @@
 module Tankard
   module Error
     ConfigurationError = Class.new(::StandardError)
-    NoBeerId = Class.new(::StandardError)
+    MissingParameter = Class.new(::StandardError)
     HttpError = Class.new(::StandardError)
     LoadError = Class.new(::StandardError)
     InvalidResponse = Class.new(::StandardError)

data/lib/tankard/version.rb

@@ -1,3 +1,3 @@
 module Tankard
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/lib/tankard.rb

@@ -25,5 +25,9 @@ module Tankard
         return super unless client.respond_to?(method_name)
         client.send(method_name, *args, &block)
       end
+
+      def reset_client
+        @client.value = nil
+      end
   end
 end

data/spec/shared_examples_for_find.rb

@@ -0,0 +1,30 @@
+shared_examples "the find method" do
+
+   context "when looking up a valid item" do
+
+     it "returns data on the item" do
+       expect(context.find(valid_items.first)).to eql(valid_responses.first)
+     end
+   end
+
+   context "when looking up an invalid item" do
+
+     it "returns nil when not found" do
+       expect(context.find(invalid_items.first)).to eql(nil)
+     end
+   end
+
+   context "when looking up multiple valid items" do
+
+     it "returns an array of data with each item" do
+       expect(context.find(valid_items)).to eql(valid_responses)
+     end
+   end
+
+   context "when looking up multiple items and one is invalid" do
+
+     it "returns an array with only the valid items" do
+       expect(context.find(valid_invalid_items)).to eql(valid_responses)
+     end
+   end
+end

data/spec/spec_helper.rb

@@ -12,6 +12,7 @@ end
 require 'tankard'
 require 'rspec'
 require 'webmock/rspec'
+require 'shared_examples_for_find'
 
 WebMock.disable_net_connect!(allow: 'coveralls.io')
 

data/spec/tankard/api/beer_spec.rb

@@ -11,41 +11,18 @@ describe Tankard::Api::Beer do
   describe "#find" do
 
     before do
-      @valid_beers = ["valid1", "valid2"]
-      @invalid_beers = ["invalid1", "invalid2"]
       @request.stub(:get).with("beer/valid1", {}).and_return({ "data" => "valid1_found"})
       @request.stub(:get).with("beer/valid2", {}).and_return({ "data" => "valid2_found"})
       @request.stub(:get).with("beer/invalid1", {}).and_raise(Tankard::Error::HttpError)
       @request.stub(:get).with("beer/invalid2", {}).and_raise(Tankard::Error::HttpError)
     end
 
-    context "when looking up a valid beer" do
-
-      it "returns data on that specific beer" do
-        expect(beer.find(@valid_beers.first)).to eql("valid1_found")
-      end
-    end
-
-    context "when looking up an invalid beer" do
-
-      it "returns nil when not found" do
-        expect(beer.find(@invalid_beers.first)).to eql(nil)
-      end
-    end
-
-    context "when looking up multiple valid beers" do
-
-      it "returns an array of data with each beer" do
-        expect(beer.find(@valid_beers)).to eql(["valid1_found", "valid2_found"])
-      end
-    end
-
-    context "when looking up multiple beers and one is invalid" do
-
-      it "returns an array with only the valid beers" do
-        beer_request = @valid_beers + @invalid_beers
-        expect(beer.find(beer_request)).to eql(["valid1_found", "valid2_found"])
-      end
+    it_should_behave_like "the find method" do
+      let(:context) { beer }
+      let(:valid_items) { ["valid1", "valid2"] }
+      let(:valid_responses) { ["valid1_found", "valid2_found"] }
+      let(:invalid_items) { ["invalid1", "invalid2"] }
+      let(:valid_invalid_items) { valid_items + invalid_items }
     end
   end
 
@@ -116,7 +93,7 @@ describe Tankard::Api::Beer do
 
   describe "#variations" do
 
-    it "sets teh options[:endpoint] to variations" do
+    it "sets the options[:endpoint] to variations" do
       beer.variations
       beer_options = beer.instance_variable_get(:"@options")
       expect(beer_options[:endpoint]).to eql("variations")
@@ -127,57 +104,104 @@ describe Tankard::Api::Beer do
     end
   end
 
-  describe "when making a request" do
+  describe "#params" do
+
+    it "sets parameters" do
+      beer.params(withSocialAccounts: "y", withGuilds: "n")
+      beer_options = beer.instance_variable_get(:"@options")
+      expect(beer_options[:withSocialAccounts]).to eql("y")
+      expect(beer_options[:withGuilds]).to eql("n")
+    end
 
-    context "the id for a beer is not set" do
+    it "merges data when called multiple times" do
+      beer.params(test: "n")
+      beer.params(test: "y")
+      beer_options = beer.instance_variable_get(:"@options")
+      expect(beer_options[:test]).to eql("y")
+    end
 
-      it "raises a Tankard::Error::NoBeerId error" do
-        expect { beer.each { |b| p b } }.to raise_error(Tankard::Error::NoBeerId)
-      end
+    it "returns itself" do
+      expect(beer.object_id).to eql(beer.params.object_id)
     end
+  end
 
-    context "the id for a beer is set" do
+  describe "private methods" do
 
-      before do
-        @request.stub(:get).with("beer/valid1", {}).and_return({ "data" => { "valid1_found" => "beer", "valid1_found_more" => "more_details" }})
-      end
+    describe "#raise_if_no_id_in_options" do
+
+      context "when an ID is not set" do
 
-      it "uses the beer id in the uri" do
-        expect(beer.id("valid1").collect { |x| x }).to eql([{"valid1_found" => "beer", "valid1_found_more" => "more_details" }])
+        it "raises Tankard::Error::MissingParameter" do
+          expect { beer.send(:raise_if_no_id_in_options) }.to raise_error(Tankard::Error::MissingParameter, "No Beer ID is set")
+        end
       end
-    end
 
-    context "the endpoint is set" do
+      context "when an ID is set" do
 
-      before do
-        @request.stub(:get).with("beer/valid1/breweries", {}).and_return({ "data" => ["valid1_found"]})
+        before do
+          beer.instance_variable_get(:"@options")[:id] = "test"
+        end
+
+        it "returns the id from options" do
+          expect(beer.send(:raise_if_no_id_in_options)).to eql("test")
+        end
+
+        it "removes the id from options" do
+          beer.send(:raise_if_no_id_in_options)
+          expect(beer.instance_variable_get(:"@options")[:id]).to be_nil
+        end
       end
+    end
 
-      it "adds the endpoint to the request" do
-        expect(beer.id("valid1").breweries.collect { |x| x }).to eql(["valid1_found"])
+    describe "#route" do
+
+      it "returns the route for the api request" do
+        expect(beer.send(:route)).to eql("beer")
       end
     end
 
-    context "additional options are set" do
+    describe "#http_request_uri" do
 
       before do
-        @beer_with_options = Tankard::Api::Beer.new(@request, test: "123", id: "valid1")
-        @request.stub(:get).with("beer/valid1", Hashie::Mash.new(test: "123")).and_return({ "data" => ["valid1_found"]})
+        beer.stub!(:route).and_return("beer")
+        beer.stub!(:raise_if_no_id_in_options).and_return("123")
       end
 
-      it "passes them to the request" do
-        expect(@beer_with_options.collect { |x| x }).to eql(["valid1_found"])
+      context "no endpoint is set" do
+
+        it "returns the route with the id" do
+          expect(beer.send(:http_request_uri)).to eql("beer/123")
+        end
+      end
+
+      context "endpoint is set" do
+
+        before do
+          beer.instance_variable_get(:"@options")[:endpoint] = "events"
+        end
+
+        it "returns the route with the id and endpoint" do
+          expect(beer.send(:http_request_uri)).to eql("beer/123/events")
+        end
+
+        it "removes the endpoint from options" do
+          beer.send(:http_request_uri)
+          expect(beer.instance_variable_get(:"@options")[:endpoint]).to be_nil
+        end
       end
     end
 
-    context "no data is returned" do
+    describe "#http_client" do
 
-      before do
-        @request.stub(:get).with("beer/valid1", {}).and_return({})
+      it "returns the request variable that is passed when the class is created" do
+        expect(beer.send(:http_client).object_id).to eql(@request.object_id)
       end
+    end
+
+    describe "#http_request_parameters" do
 
-      it "gracefully fails" do
-        expect { beer.id("valid1").collect { |x| x} }.to raise_error(Tankard::Error::InvalidResponse)
+      it "returns the options for the request" do
+        expect(beer.send(:http_request_parameters).object_id).to eql(beer.instance_variable_get(:"@options").object_id)
       end
     end
   end

data/spec/tankard/api/beers_spec.rb

@@ -33,83 +33,47 @@ describe Tankard::Api::Beers do
     end
   end
 
-  describe "when making a request" do
+  describe "#params" do
 
-    context "and a page is set" do
-
-      it "only queries a single page" do
-        beers.should_receive(:find_on_single_page)
-        beers.page(1).each { |x| x }
-      end
-    end
-
-    context "and a page is not set" do
-
-      it "queries multiple pages" do
-        beers.should_receive(:find_on_all_pages)
-        beers.each { |x| x }
-      end
+    it "sets parameters" do
+      beers.params(withSocialAccounts: "y", withGuilds: "n")
+      beers_options = beers.instance_variable_get(:"@options")
+      expect(beers_options[:withSocialAccounts]).to eql("y")
+      expect(beers_options[:withGuilds]).to eql("n")
     end
 
-    context "and additional options are set without a page" do
-
-      before do
-        @beers_with_options = Tankard::Api::Beers.new(@request, test: "123")
-        @request.stub(:get).with("beers", Hashie::Mash.new(test: "123", p: 1)).and_return({ "data" => ["beers"]})
-      end
-
-      it "passes them to the request" do
-        expect(@beers_with_options.collect { |x| x }).to eql(["beers"])
-      end
+    it "merges params when called multiple times" do
+      beers.params(test: "n")
+      beers.params(test: "y")
+      beers_options = beers.instance_variable_get(:"@options")
+      expect(beers_options[:test]).to eql("y")
     end
 
-    context "and additional options are set with a page" do
-
-      before do
-        @beers_with_options = Tankard::Api::Beers.new(@request, test: "123", p: 2)
-        @request.stub(:get).with("beers", Hashie::Mash.new(test: "123", p: 2)).and_return({ "data" => ["beers"]})
-      end
-
-      it "passes them to the request" do
-        expect(@beers_with_options.collect { |x| x }).to eql(["beers"])
-      end
+    it "returns itself" do
+      expect(beers.object_id).to eql(beers.params.object_id)
     end
+  end
 
-    context "and no data is returned on a single page request" do
+  describe "private methods" do
 
-      before do
-        @beers = Tankard::Api::Beers.new(@request, p: 1)
-        @request.stub(:get).with("beers", Hashie::Mash.new(p: 1)).and_return({})
-      end
+    describe "#http_request_uri" do
 
-      it "raises a Tankard::Error::InvalidResponse error" do
-        expect { @beers.collect { |x| x} }.to raise_error(Tankard::Error::InvalidResponse)
+      it "returns the string beers" do
+        expect(beers.send(:http_request_uri)).to eql("beers")
       end
     end
 
-    context "and no data is returned on a page in a multi page request" do
-
-      before do
-        @beers = Tankard::Api::Beers.new(@request)
-        @request.stub(:get).with("beers", Hashie::Mash.new(p: 1)).and_return({"numberOfPages" => 2, "data" => ["test1", "test2"]})
-        @request.stub(:get).with("beers", Hashie::Mash.new(p: 2)).and_return({})
-      end
+    describe "#http_client" do
 
-      it "raises a Tankard::Error::InvalidResponse error" do
-        expect { @beers.collect { |x| x} }.to raise_error(Tankard::Error::InvalidResponse)
+      it "returns the request variable that is passed in when the class is initialized" do
+        expect(beers.send(:http_client).object_id).to eql(@request.object_id)
       end
     end
 
-    context "and a page is not specified" do
-
-      before do
-        @beers = Tankard::Api::Beers.new(@request)
-        @request.stub(:get).with("beers", Hashie::Mash.new(p: 1)).and_return({"numberOfPages" => 2, "data" => ["test1", "test2"]})
-        @request.stub(:get).with("beers", Hashie::Mash.new(p: 2)).and_return({"numberOfPages" => 2, "data" => ["test3", "test4"]})
-      end
+    describe "#http_request_parameters" do
 
-      it "runs through all of the pages returned by brewerydb" do
-        expect(@beers.collect { |x| x}).to eql(["test1", "test2", "test3", "test4"])
+      it "returns the options for the request" do
+        expect(beers.send(:http_request_parameters).object_id).to eql(beers.instance_variable_get(:"@options").object_id)
       end
     end
   end