magnum-pi 0.1.0

data/lib/magnum-pi/gem_ext.rb

@@ -0,0 +1 @@
+require "magnum-pi/gem_ext/mechanize"

data/lib/magnum-pi/gem_ext/mechanize.rb

@@ -0,0 +1 @@
+require "magnum-pi/gem_ext/mechanize/http"

data/lib/magnum-pi/gem_ext/mechanize/http.rb

@@ -0,0 +1 @@
+require "magnum-pi/gem_ext/mechanize/http/agent"

data/lib/magnum-pi/gem_ext/mechanize/http/agent.rb

@@ -0,0 +1,60 @@
+# Taken from: http://scottwb.com/blog/2013/11/09/defeating-the-infamous-mechanize-too-many-connection-resets-bug/
+
+class Mechanize
+  class HTTP
+    class Agent
+      MAX_RESET_RETRIES = 10
+
+      # We need to replace the core Mechanize HTTP method:
+      #
+      #   Mechanize::HTTP::Agent#fetch
+      #
+      # with a wrapper that handles the infamous "too many connection resets"
+      # Mechanize bug that is described here:
+      #
+      #   https://github.com/sparklemotion/mechanize/issues/123
+      #
+      # The wrapper shuts down the persistent HTTP connection when it fails with
+      # this error, and simply tries again. In practice, this only ever needs to
+      # be retried once, but I am going to let it retry a few times
+      # (MAX_RESET_RETRIES), just in case.
+      #
+      def fetch_with_retry(
+        uri,
+        method    = :get,
+        headers   = {},
+        params    = [],
+        referer   = current_page,
+        redirects = 0
+      )
+        action      = "#{method.to_s.upcase} #{uri.to_s}"
+        retry_count = 0
+
+        begin
+          fetch_without_retry(uri, method, headers, params, referer, redirects)
+        rescue Net::HTTP::Persistent::Error => e
+          # Pass on any other type of error.
+          raise unless e.message =~ /too many connection resets/
+
+          # Pass on the error if we've tried too many times.
+          if retry_count >= MAX_RESET_RETRIES
+            puts "**** WARN: Mechanize retried connection reset #{MAX_RESET_RETRIES} times and never succeeded: #{action}"
+            raise
+          end
+
+          # Otherwise, shutdown the persistent HTTP connection and try again.
+          puts "**** WARN: Mechanize retrying connection reset error: #{action}"
+          retry_count += 1
+          self.http.shutdown
+          retry
+        end
+      end
+
+      # Alias so #fetch actually uses our new #fetch_with_retry to wrap the
+      # old one aliased as #fetch_without_retry.
+      alias_method :fetch_without_retry, :fetch
+      alias_method :fetch, :fetch_with_retry
+
+    end
+  end
+end

data/lib/magnum-pi/version.rb

@@ -0,0 +1,7 @@
+module MagnumPI
+  MAJOR = 0
+  MINOR = 1
+  TINY  = 0
+
+  VERSION = [MAJOR, MINOR, TINY].join(".")
+end

data/magnum-pi.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/magnum-pi/version", __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Paul Engel"]
+  gem.email         = ["pm_engel@icloud.com"]
+  gem.summary       = %q{Create an easy interface to talk with APIs}
+  gem.description   = %q{Create an easy interface to talk with APIs}
+  gem.homepage      = "https://github.com/archan937/magnum-pi"
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "magnum-pi"
+  gem.require_paths = ["lib"]
+  gem.version       = MagnumPI::VERSION
+
+  gem.add_dependency "mechanize"
+  gem.add_dependency "oj"
+  gem.add_dependency "xml-simple"
+
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "pry"
+  gem.add_development_dependency "simplecov"
+  gem.add_development_dependency "minitest"
+  gem.add_development_dependency "mocha"
+end

data/script/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require "bundler"
+Bundler.require :default, :development
+
+Dir[File.expand_path("../../examples/*.rb", __FILE__)].each do |example|
+  require example
+end
+
+puts "Loading MagnumPI development environment (#{MagnumPI::VERSION})"
+Pry.start

data/test/test_helper.rb

@@ -0,0 +1,11 @@
+require_relative "test_helper/coverage"
+
+require "minitest/autorun"
+require "mocha/setup"
+
+def path(path)
+  File.expand_path "../../#{path}", __FILE__
+end
+
+require "bundler"
+Bundler.require :default, :development, :test

data/test/test_helper/coverage.rb

@@ -0,0 +1,11 @@
+if Dir.pwd == File.expand_path("../../..", __FILE__)
+  require "simplecov"
+  SimpleCov.coverage_dir "test/coverage"
+  SimpleCov.start do
+    add_group "MagnumPI", "lib"
+    add_group "Test suite", "test"
+    add_filter do |src|
+      src.filename.include?("gem_ext/mechanize")
+    end
+  end
+end

data/test/unit/api/test_consumer.rb

@@ -0,0 +1,176 @@
+require_relative "../../test_helper"
+
+module Unit
+  module API
+    class TestConsumer < MiniTest::Test
+
+      class Consumer
+        include MagnumPI::API::Consumer
+        def to_params(url, *args)
+          args[0]
+        end
+      end
+
+      class IncompleteConsumer
+        include MagnumPI::API::Consumer
+      end
+
+      describe MagnumPI::API::Consumer do
+        before do
+          @consumer = Consumer.new
+          @consumer.stubs(:api).returns(
+            :uri => "http://foo.bar",
+            :format => :json
+          )
+          @consumer.stubs(:resources).returns(
+            :statistics => [:get, "stats", MagnumPI::API::Resources::Variable.new.tap{|var| var.name = :date}]
+          )
+        end
+        describe "#get" do
+          it "makes a GET request" do
+            response = mock
+            response.expects(:content).returns('{"name": "Paul Engel"}')
+            @consumer.expects(:request).with(:get, "http://foo.bar", {:foo => "bar"}).returns(response)
+            assert_equal({"name" => "Paul Engel"}, @consumer.get(:foo => "bar"))
+          end
+        end
+        describe "#post" do
+          it "makes a POST request" do
+            response = mock
+            response.expects(:content).returns('{"name": "Paul Engel"}')
+            @consumer.expects(:request).with(:post, "http://foo.bar", {:foo => "bar"}).returns(response)
+            assert_equal({"name" => "Paul Engel"}, @consumer.post(:foo => "bar"))
+          end
+        end
+        describe "#download" do
+          it "downloads using the Mechanize agent" do
+            response = mock
+            response.expects(:save_as).with("path/to/target")
+            @consumer.expects(:request).with(:get, "http://foo.bar", :foo => "bar").returns(response)
+            @consumer.download "path/to/target", :get, :foo => "bar"
+          end
+        end
+        describe "#resource" do
+          it "interpolates passed variables and makes a request" do
+            @consumer.expects(:send).with(:get, "stats", "2014-03-20")
+            @consumer.resource :statistics, :date => "2014-03-20"
+          end
+          it "interpolates passed variables and downloads a file" do
+            @consumer.expects(:send).with(:download, "path/to/target", :get, "stats", "2014-03-20")
+            @consumer.resource :statistics, {:date => "2014-03-20"}, "path/to/target"
+          end
+        end
+        describe "#method_missing" do
+          describe "corresponding resource" do
+            it "delegates to #resource" do
+              @consumer.expects(:resource).with(:statistics, :foo, :bar)
+              @consumer.statistics :foo, :bar
+            end
+          end
+          describe "no corresponding resource" do
+            it "raises a NoMethodError" do
+              assert_raises NoMethodError do
+                @consumer.foo
+              end
+            end
+          end
+        end
+        describe "#request" do
+          it "is delegated to the Mechanize agent" do
+            @consumer.send(:agent).expects(:send).with(:get, :foo, :bar)
+            @consumer.send(:request, :get, :foo, :bar)
+          end
+          it "raises an error when a Mechanize::ResponseCodeError occurs" do
+            agent = @consumer.send(:agent)
+            def agent.send(*args)
+              raise Mechanize::ResponseCodeError.new(Struct.new(:code).new)
+            end
+            assert_raises MagnumPI::API::Consumer::Error do
+              @consumer.get
+            end
+          end
+        end
+        describe "#agent" do
+          it "returns a memoized Mechanize agent" do
+            assert_equal Mechanize, @consumer.send(:agent).class
+            assert_equal @consumer.send(:agent).object_id, @consumer.send(:agent).object_id
+          end
+          it "is configured as expected" do
+            assert_equal OpenSSL::SSL::VERIFY_NONE, @consumer.send(:agent).verify_mode
+            assert_equal Mechanize::Download, @consumer.send(:agent).pluggable_parser.default
+          end
+        end
+        describe "#parse_args" do
+          it "derives the URL and params" do
+            @consumer.expects(:to_url).with({:foo => "bar"}).returns("http://foo.bar")
+            assert_equal ["http://foo.bar", {:foo => "bar"}], @consumer.send(:parse_args, {:foo => "bar"})
+          end
+        end
+        describe "#parse_resource_variables" do
+          it "returns an array containing arguments for making a request" do
+            resource = @consumer.resources[:statistics]
+            assert_equal [:get, "stats", nil], @consumer.send(:parse_resource_variables, resource, {})
+            assert_equal [:get, "stats", nil], @consumer.send(:parse_resource_variables, resource, {:DATE => "2014-03-20"})
+            assert_equal [:get, "stats", "2014-03-20"], @consumer.send(:parse_resource_variables, resource, {:date => "2014-03-20"})
+            assert_equal [:get, "stats", "2014-03-20"], @consumer.send(:parse_resource_variables, resource, {"date" => "2014-03-20"})
+            assert_equal [:get, "stats", "2014-03-20"], @consumer.send(:parse_resource_variables, resource, ["2014-03-20"])
+            assert_equal [:get, "stats", "2014-03-20"], @consumer.send(:parse_resource_variables, resource, "2014-03-20")
+            assert_raises ArgumentError do
+              @consumer.send :parse_resource_variables, resource, ["2014-03-20", "foo"]
+            end
+
+            resource = [:post, "foobar"]
+            assert_equal [:post, "foobar"], @consumer.send(:parse_resource_variables, resource, {})
+            assert_equal [:post, "foobar"], @consumer.send(:parse_resource_variables, resource, {:DATE => "2014-03-20"})
+            assert_equal [:post, "foobar"], @consumer.send(:parse_resource_variables, resource, {:date => "2014-03-20"})
+            assert_equal [:post, "foobar"], @consumer.send(:parse_resource_variables, resource, {"date" => "2014-03-20"})
+            assert_equal [:post, "foobar"], @consumer.send(:parse_resource_variables, resource, ["2014-03-20"])
+            assert_equal [:post, "foobar"], @consumer.send(:parse_resource_variables, resource, ["2014-03-20", "foo"])
+          end
+        end
+        describe "#to_url" do
+          it "returns api[:uri]" do
+            assert_equal "http://foo.bar", @consumer.send(:to_url)
+          end
+        end
+        describe "#to_params" do
+          it "raises a NotImplementedError" do
+            assert_raises NotImplementedError do
+              IncompleteConsumer.new.send :to_params, "url"
+            end
+          end
+        end
+        describe "#parse_content" do
+          it "parses the passed content" do
+            assert_equal(
+              {
+                "foo" => "bar"
+              }, @consumer.send(:parse_content,
+                <<-JSON
+                  {"foo": "bar"}
+                JSON
+              )
+            )
+            @consumer.expects(:api).returns :format => "xml"
+            assert_equal(
+              {
+                "bar" => ["BAR"],
+                "baz" => [{"hello" => "world", "content" => "Baz!"}]
+              }, @consumer.send(:parse_content,
+                <<-XML
+                  <xml>
+                    <bar>BAR</bar>
+                    <baz hello="world">Baz!</baz>
+                  </xml>
+                XML
+              )
+            )
+            @consumer.expects(:api).returns :format => "unknown"
+            assert_equal("foobar", @consumer.send(:parse_content, "foobar"))
+          end
+        end
+      end
+
+    end
+  end
+end

data/test/unit/api/test_instance.rb

@@ -0,0 +1,53 @@
+require_relative "../../test_helper"
+
+module Unit
+  module API
+    class TestInstance < MiniTest::Test
+
+      class Foo
+        include MagnumPI::API::Instance
+      end
+
+      describe MagnumPI::API::Instance do
+        describe ".initialize" do
+          it "defines @api and @resources" do
+            api = mock
+            api.expects(:finalize).returns(api)
+            resources = mock
+            resources.expects(:to_hash).returns(resources)
+
+            Foo.expects(:api).returns api
+            Foo.expects(:resources).returns resources
+            foo = Foo.new
+
+            assert_equal api, foo.instance_variable_get(:@api)
+            assert_equal resources, foo.instance_variable_get(:@resources)
+          end
+        end
+        describe "instances" do
+          before do
+            api = mock
+            api.expects(:finalize).returns(api)
+            Foo.expects(:api).returns api
+            Foo.expects(:resources).returns Hash.new
+          end
+          describe "#api" do
+            it "returns @api" do
+              foo, api = Foo.new, api
+              foo.instance_variable_set :@api, api
+              assert_equal api, foo.send(:api)
+            end
+          end
+          describe "#resources" do
+            it "returns @resources" do
+              foo, resources = Foo.new, resources
+              foo.instance_variable_set :@resources, resources
+              assert_equal resources, foo.send(:resources)
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/test/unit/api/test_resources.rb

@@ -0,0 +1,19 @@
+require_relative "../../test_helper"
+
+module Unit
+  module API
+    class TestResources < MiniTest::Test
+
+      describe MagnumPI::API::Resources do
+        describe ".var" do
+          it "returns a MagnumPI::API::Resources::Variable instance" do
+            variable = MagnumPI::API::Resources.new.var("foo")
+            assert_equal MagnumPI::API::Resources::Variable, variable.class
+            assert_equal "foo", variable.name
+          end
+        end
+      end
+
+    end
+  end
+end

data/test/unit/api/test_scheme.rb

@@ -0,0 +1,81 @@
+require_relative "../../test_helper"
+
+module Unit
+  module API
+    class TestScheme < MiniTest::Test
+
+      describe MagnumPI::API::Scheme do
+        before do
+          @scheme = MagnumPI::API::Scheme.new
+        end
+
+        describe "#initialize" do
+          it "presets `uri` and `format`" do
+            assert_equal({:uri => String, :format => Symbol}, @scheme.instance_eval("_types"))
+          end
+        end
+
+        describe "#class" do
+          it "returns MagnumPI::API::Scheme" do
+            assert_equal MagnumPI::API::Scheme, @scheme.class
+          end
+        end
+
+        describe "#finalize" do
+          it "foo" do
+            @scheme.foo String
+            @scheme.bar "bar"
+            object_id = @scheme.instance_eval("_values").object_id
+
+            assert_equal({:bar => "bar"}, @scheme.finalize)
+            assert_equal({:foo => "foo", :bar => "bar"}, @scheme.finalize(:foo => "foo"))
+            assert_equal object_id, @scheme.instance_eval("_values").object_id
+            assert_equal({:foo => "FOO", :bar => "bar"}, @scheme.finalize(:foo => "FOO"))
+
+            assert_raises ArgumentError do
+              @scheme.finalize :foo => :foo
+            end
+          end
+        end
+
+        describe "#_types" do
+          it "is an internal memoized hash" do
+            assert_equal true, @scheme.instance_eval("_types").is_a?(Hash)
+            assert_equal @scheme.instance_eval("_types").object_id, @scheme.instance_eval("_types").object_id
+          end
+        end
+
+        describe "types" do
+          describe "defining" do
+            it "can only be done once" do
+              assert_equal({:uri => String, :format => Symbol}, @scheme.instance_eval("_types"))
+              @scheme.format String
+              assert_equal({:uri => String, :format => Symbol}, @scheme.instance_eval("_types"))
+              @scheme.foo String
+              assert_equal({:uri => String, :format => Symbol, :foo => String}, @scheme.instance_eval("_types"))
+              @scheme.foo Symbol
+              assert_equal({:uri => String, :format => Symbol, :foo => String}, @scheme.instance_eval("_types"))
+            end
+          end
+          describe "validating" do
+            describe "when setting a valid value" do
+              it "allows value to be set" do
+                assert_equal({}, @scheme.instance_eval("_values"))
+                @scheme.format :json
+                assert_equal({:format => :json}, @scheme.instance_eval("_values"))
+                @scheme.format :xml
+                assert_equal({:format => :xml}, @scheme.instance_eval("_values"))
+              end
+            end
+            describe "when setting an invalid value" do
+              it "raises an error" do
+                assert_equal "Invalid value for 'format': \"json\" (expected Symbol)", assert_raises(ArgumentError){ @scheme.format "json" }.message
+              end
+            end
+          end
+        end
+      end
+
+    end
+  end
+end