harpy 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 35426c39b7a3ab5a5cbe8a32afd1db109a81f6dc
-  data.tar.gz: 6869a454bd349bbcd33a1aa7fe7fdce6255f087d
+SHA256:
+  metadata.gz: f6437acd381d436843e94394aa9d1c6df605c4ca43ca5fb3e32746a4f6d805ed
+  data.tar.gz: b03c709ef5b4297a059280926773fb376b5f9feb77ab6656ea9f7d169cd69c6b
 SHA512:
-  metadata.gz: 3c730539fe647176feb1c0e1d60a05c8a8df3ac6ecb5e7b44cf8089f976fd1b3896d8f0c94dfd15dc8c47d338ac725b48ddbce6d23eb8b3b856e37a8ad980936
-  data.tar.gz: f95e41e0b7c2c54f69c324233be772a95ffc79c588d93c38bf8b314f3bef1a0d9a0938831c56a1ed2a23746a9923f3ab8a8aa579a8f2906d0a8a15684dd9f691
+  metadata.gz: 074b8e393b71cb510d5f8acf96aa2473395689458d4b7b1ca58965b44a1a902be536f77f452a0bd1d5d675b456244d52cf0937b1c266abdc019f16eaed71b475
+  data.tar.gz: 96996c71087173593a8eaed967fdd500a505ab92b6ddcf0e2025cb62ab87735a29748e9e8958ed37573e74ea96c3bdfb8c4afabe5de4865fd5316598c19b705d

data/.gitignore

@@ -1,4 +1,5 @@
 *.gem
 .bundle
 pkg/*
-*.rbc
+*.rbc
+Gemfile.lock

data/.travis.yml

@@ -1,9 +1,7 @@
 rvm:
-  - 1.9.3
-  - 2.0.0
-  - 2.1.0
-  - rbx-19mode
-  - jruby-19mode
-  - jruby-20mode
+  - 2.4.6
+  - 2.5.5
+  - 2.6.3
+  - jruby-9.2.7.0
 notifications:
   disabled: true

data/README.md

@@ -9,11 +9,11 @@ Client for REST API with HATEOAS
 Dependencies
 ------------
 
-* Ruby 1.8.7 or 1.9.2
-* gem "typhoeus", "~> 0.2.4"
-* gem "activesupport", ">= 3.1.0"
-* gem "activemodel", ">= 3.1.0"
-* gem "hash-deep-merge", "~> 0.1.1"
+* Ruby >= 2.4.
+* gem "typhoeus", ">= 0.6.5"
+* gem "activesupport", ">= 5.2.0"
+* gem "activemodel", ">= 5.2.0"
+* gem "hash-deep-merge", ">= 0.1.1"
 
 Usage
 -----

data/harpy.gemspec

@@ -1,9 +1,10 @@
 # -*- encoding: utf-8 -*-
 $:.push File.expand_path("../lib", __FILE__)
+require "harpy"
 
 Gem::Specification.new do |s|
   s.name        = "harpy"
-  s.version     = "1.0.0"
+  s.version     = Harpy::VERSION::STRING
   s.platform    = Gem::Platform::RUBY
   s.authors     = ["Joseph HALTER", "Jonathan TRON"]
   s.email       = ["joseph.halter@thetalentbox.com", "jonathan.tron@thetalentbox.com"]
@@ -17,10 +18,10 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency "typhoeus", "~> 0.6.5"
-  s.add_runtime_dependency "activesupport", [">= 3.1.0"]
-  s.add_runtime_dependency "activemodel", [">= 3.1.0"]
-  s.add_runtime_dependency "hash-deep-merge", ["~> 0.1.1"]
+  s.add_runtime_dependency "typhoeus", ">= 0.6.5"
+  s.add_runtime_dependency "activesupport", [">= 5.2.0"]
+  s.add_runtime_dependency "activemodel", [">= 5.2.0"]
+  s.add_runtime_dependency "hash-deep-merge", [">= 0.1.1"]
 
   s.add_development_dependency "rake", [">= 0.8.7"]
   s.add_development_dependency "rspec"

data/lib/harpy.rb

@@ -14,6 +14,7 @@ module Harpy
   autoload :Resource, "harpy/resource"
   autoload :BodyToBig, "harpy/resource"
   autoload :UnknownResponseCode, "harpy/resource"
+  autoload :VERSION, "harpy/gem_version"
 
   def self.client=(new_client)
     @client = new_client
@@ -38,10 +39,10 @@ module Harpy
   def self.entry_point
     @entry_point || raise(EntryPointRequired, 'you can setup one with Harpy.entry_point_url = "http://localhost"')
   end
-  
+
   def self.reset
     @client = nil
     @entry_point = nil
   end
 
-end
+end

data/lib/harpy/gem_version.rb

@@ -0,0 +1,14 @@
+module Harpy
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 1
+    MINOR = 1
+    TINY  = 0
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/harpy/resource.rb

@@ -16,6 +16,7 @@ module Harpy
       base.send :include, ActiveModel::Validations
       base.send :include, ActiveModel::Validations::Callbacks
       base.define_model_callbacks :save, :create, :update, :destroy, :only => [:before, :after]
+      base.send :include, InstanceMethods
     end
 
     def self.from_url(hash)
@@ -93,6 +94,14 @@ module Harpy
         delete_from_urn urn id
       end
 
+      def uman_attribute_name(attr, options = {})
+        attr
+      end
+
+      def lookup_ancestors
+        [self]
+      end
+
     private
 
       def url
@@ -122,128 +131,135 @@ module Harpy
       end
     end
 
-    def initialize(attrs = nil)
-      @attrs = {}
-      self.attributes = attrs || {}
-    end
+    module InstanceMethods
 
-    def attributes=(attrs)
-      attrs.each do |key, value|
-        if respond_to? "#{key}="
-          send "#{key}=", value
-        else
-          @attrs[key] = value
+      def initialize(attrs = nil)
+        @attrs = {}
+        self.attributes = attrs || {}
+      end
+
+      def attributes=(attrs)
+        attrs.each do |key, value|
+          if respond_to? "#{key}="
+            send "#{key}=", value
+          else
+            @attrs[key] = value
+          end
         end
       end
-    end
 
-    def as_json(*args)
-      hash = @attrs.dup
-      hash.delete "link"
-      hash.delete "urn"
-      hash
-    end
+      def as_json(*args)
+        hash = @attrs.dup
+        hash.delete "link"
+        hash.delete "urn"
+        hash
+      end
 
-    def save
-      if valid?
-        run_callbacks :save do
-          json = JSON.generate as_json
-          raise BodyToBig, "Size: #{json.bytesize} bytes (max 1MB)" if json.bytesize > 1.megabyte
-          persisted? ? update(json) : create(json)
+      def save
+        if valid?
+          run_callbacks :save do
+            json = JSON.generate as_json
+            raise BodyToBig, "Size: #{json.bytesize} bytes (max 1MB)" if json.bytesize > 1.megabyte
+            persisted? ? update(json) : create(json)
+          end
+        else
+          false
         end
-      else
-        false
       end
-    end
 
-    def destroy
-      raise Harpy::UrlRequired unless url
-      run_callbacks :destroy do
-        process_response Harpy.client.delete(url), :destroy
+      def destroy
+        raise Harpy::UrlRequired unless url
+        run_callbacks :destroy do
+          process_response Harpy.client.delete(url), :destroy
+        end
       end
-    end
 
-    def link(rel)
-      link = (@attrs["link"]||[]).detect{|l| l["rel"]==rel.to_s}
-      link["href"] if link
-    end
+      def link(rel)
+        link = (@attrs["link"]||[]).detect{|l| l["rel"]==rel.to_s}
+        link["href"] if link
+      end
 
-    def url
-      link "self"
-    end
+      def url
+        link "self"
+      end
 
-    def url_collection
-      Harpy.entry_point.resource_url self.class.resource_name
-    end
+      def url_collection
+        Harpy.entry_point.resource_url self.class.resource_name
+      end
 
-    def id
-      @attrs["urn"].split(":").last if @attrs["urn"]
-    end
+      def id
+        @attrs["urn"].split(":").last if @attrs["urn"]
+      end
 
-    def persisted?
-      @attrs["urn"].present?
-    end
+      def persisted?
+        @attrs["urn"].present?
+      end
 
-    def inspect
-      "<#{self.class.name} @attrs:#{@attrs.inspect} @errors:#{errors.full_messages.inspect} persisted:#{persisted?}>"
-    end
+      def inspect
+        "<#{self.class.name} @attrs:#{@attrs.inspect} @errors:#{errors.full_messages.inspect} persisted:#{persisted?}>"
+      end
 
-    def has_key?(key)
-      @attrs.has_key? key.to_s
-    end
+      def has_key?(key)
+        @attrs.has_key? key.to_s
+      end
 
-    def hash
-      urn.hash
-    end
+      def hash
+        urn.hash
+      end
 
-    def ==(other)
-      other.equal?(self) || (urn && other.instance_of?(self.class) && other.urn == urn)
-    end
-    alias_method :eql?, :==
+      def ==(other)
+        other.equal?(self) || (urn && other.instance_of?(self.class) && other.urn == urn)
+      end
+      alias_method :eql?, :==
 
-  private
+    private
 
-    def create(json)
-      run_callbacks :create do
-        process_response Harpy.client.post(url_collection, :body => json), :create
+      def create(json)
+        run_callbacks :create do
+          process_response Harpy.client.post(url_collection, :body => json), :create
+        end
       end
-    end
 
-    def update(json)
-      run_callbacks :update do
-        raise Harpy::UrlRequired unless url
-        process_response Harpy.client.put(url, :body => json), :update
+      def update(json)
+        run_callbacks :update do
+          raise Harpy::UrlRequired unless url
+          process_response Harpy.client.put(url, :body => json), :update
+        end
       end
-    end
 
-    def process_response(response, context)
-      case response.code
-      when 200, 201, 302
-        @attrs.merge! JSON.parse(response.body)
-        true
-      when 204
-        context==:create ? Harpy.client.invalid_code(response) : true
-      when 401
-        raise Harpy::Unauthorized, "Server returned a 401 response code"
-      when 422
-        JSON.parse(response.body)["errors"].each do |attr, attr_errors|
-          attr_errors.each{|attr_error| errors[attr] = attr_error }
+      def process_response(response, context)
+        case response.code
+        when 200, 201, 302
+          @attrs.merge! JSON.parse(response.body)
+          true
+        when 204
+          context==:create ? Harpy.client.invalid_code(response) : true
+        when 401
+          raise Harpy::Unauthorized, "Server returned a 401 response code"
+        when 422
+          JSON.parse(response.body)["errors"].each do |attr, attr_errors|
+            attr_errors.each{|attr_error| errors.add(attr, :invalid, message: attr_error) }
+          end
+          false
+        else
+          Harpy.client.invalid_code response
         end
-        false
-      else
-        Harpy.client.invalid_code response
       end
-    end
 
-    def method_missing(method, *args)
-      key = method.to_s
-      if persisted? && !@attrs.has_key?(key)
-        super
-      elsif key=~/[\]=]\z/
-        super
-      else
+      def read_attribute_for_validation(key)
         @attrs[key]
       end
+
+      def method_missing(method, *args)
+        key = method.to_s
+        if persisted? && !@attrs.has_key?(key)
+          super
+        elsif key=~/[\]=]\z/
+          super
+        else
+          @attrs[key]
+        end
+      end
     end
   end
 end

data/lib/harpy/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative "gem_version"
+
+module Harpy
+  def self.version
+    gem_version
+  end
+end

data/spec/harpy/client_spec.rb

@@ -5,13 +5,20 @@ describe Harpy::Client do
   let(:users_url) { "http://localhost/users" }
 
   context "by default" do
-    its(:options) { should be_empty }
+    describe '#options' do
+      subject { super().options }
+      it { is_expected.to be_empty }
+    end
   end
 
   context "initialized with options" do
     let(:options) { {:username => "harpy", :password => "spec"} }
     subject { Harpy::Client.new(options) }
-    its(:options) { should == options }
+
+    describe '#options' do
+      subject { super().options }
+      it { is_expected.to eq(options) }
+    end
   end
 
   [:get, :head, :post, :put, :patch, :delete].each do |method|
@@ -22,32 +29,32 @@ describe Harpy::Client do
           Typhoeus.stub(entry_url, method: method){@expected}
         end
         it "sends a #{method.to_s.upcase} to the url" do
-          subject.send(method, entry_url).should == @expected
+          expect(subject.send(method, entry_url)).to eq(@expected)
         end
         it "merges options" do
           client = Harpy::Client.new :headers => {"Authorization" => "spec"}
           Typhoeus.stub(entry_url, method: method){Typhoeus::Response.new :code => 200}
           response = client.send method, entry_url, :headers => {"X-Files" => "Harpy"}
-          response.request.options[:headers].should include({"X-Files" => "Harpy", "Authorization" => "spec"})
+          expect(response.request.options[:headers]).to include({"X-Files" => "Harpy", "Authorization" => "spec"})
         end
       end
       context "with multiple urls" do
         it "does not execute requests" do
-          lambda {
+          expect {
             subject.send method, [entry_url, users_url]
-          }.should_not raise_error
+          }.not_to raise_error
         end
         it "returns one requests per url" do
           requests = subject.send method, [entry_url, users_url]
-          requests.size.should == 2
-          requests.collect{|r| r.options[:method]}.should =~ [method, method]
-          requests.collect(&:url).should =~ [entry_url, users_url]
+          expect(requests.size).to eq(2)
+          expect(requests.collect{|r| r.options[:method]}).to match_array([method, method])
+          expect(requests.collect(&:url)).to match_array([entry_url, users_url])
         end
         it "merges options" do
           client = Harpy::Client.new :headers => {"Authorization" => "spec"}
           requests = client.send method, [entry_url, users_url], :headers => {"X-Files" => "Harpy"}
           requests.each do |request|
-            request.options[:headers].should include({"X-Files" => "Harpy", "Authorization" => "spec"})
+            expect(request.options[:headers]).to include({"X-Files" => "Harpy", "Authorization" => "spec"})
           end
         end
       end
@@ -62,35 +69,35 @@ describe Harpy::Client do
       Typhoeus.stub(users_url, method: :get){ @users_response }
     end
     it "executes requests in parallel" do
-      Typhoeus::Hydra.hydra.should_receive(:run).once
+      expect(Typhoeus::Hydra.hydra).to receive(:run).once
       subject.run subject.get([entry_url, users_url])
     end
     it "returns responses" do
       responses = subject.run subject.get([entry_url, users_url])
-      responses.should =~ [@entry_response, @users_response]
+      expect(responses).to match_array([@entry_response, @users_response])
     end
     it "requests response is filled in" do
       requests = subject.get([entry_url, users_url])
       subject.run requests
-      requests[0].response.should == @entry_response
-      requests[1].response.should == @users_response
+      expect(requests[0].response).to eq(@entry_response)
+      expect(requests[1].response).to eq(@users_response)
     end
   end
   describe "#invalid_code(response)" do
     it "raises Harpy::ClientTimeout on request timeout" do
-      lambda {
+      expect {
         subject.invalid_code double("Response", :timed_out? => true)
-      }.should raise_error Harpy::ClientTimeout
+      }.to raise_error Harpy::ClientTimeout
     end
     it "raises Harpy::ClientError on code 0" do
-      lambda {
+      expect {
         subject.invalid_code double("Response", :timed_out? => false, :code => 0, :return_message => "Could not connect to server")
-      }.should raise_error Harpy::ClientError, "Could not connect to server"
+      }.to raise_error Harpy::ClientError, "Could not connect to server"
     end
     it "raises Harpy::InvalidResponseCode with code otherwise" do
-      lambda {
+      expect {
         subject.invalid_code double("Response", :timed_out? => false, :code => 404)
-      }.should raise_error Harpy::InvalidResponseCode, "404"
+      }.to raise_error Harpy::InvalidResponseCode, "404"
     end
   end
 end