her5 0.8.1

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler"
+require "rake"
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+task :default => :spec
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.pattern = "spec/**/*_spec.rb"
+end

data/UPGRADE.md

@@ -0,0 +1,101 @@
+# Upgrade Her
+
+Here is a list of notable changes by release. Her follows the [Semantic Versioning](http://semver.org/) system.
+
+## 0.8.1 (Note: 0.8.0 yanked)
+
+- Initial support for JSONAPI [link](https://github.com/remiprev/her/pull/347)
+- Fix for has_one association parsing [link](https://github.com/remiprev/her/pull/352)
+- Fix for escaping path variables HT @marshall-lee [link](https://github.com/remiprev/her/pull/354)
+- Fix syntax highlighting in README HT @tippenein [link](https://github.com/remiprev/her/pull/356)
+- Fix associations with Active Model Serializers HT @minktom [link](https://github.com/remiprev/her/pull/359)
+
+## 0.7.6
+
+- Loosen restrictions on ActiveSupport and ActiveModel to accommodate security fixes [link](https://github.com/remiprev/her/commit/8ff641fcdaf14be7cc9b1a6ee6654f27f7dfa34c)
+
+## 0.7.5
+
+- Performance fix for responses with large number of objects [link](https://github.com/remiprev/her/pull/337)
+- Bugfix for dirty attributes [link](https://github.com/remiprev/her/commit/70285debc6837a33a3a750c7c4a7251439464b42)
+- Add ruby 2.1 and 2.2 to travis test run. We will likely be removing official 1.9.x support in the near future, and 
+will begin to align our support with the official ruby maintenance schedule. 
+- README updates
+
+## 0.6
+
+Associations have been refactored so that calling the association name method doesn’t immediately load or fetch the data.
+
+```ruby
+class User
+  include Her::Model
+  has_many :comments
+end
+
+# This doesn’t fetch the data yet and it’s still chainable
+comments = User.find(1).comments
+
+# This actually fetches the data
+puts comments.inspect
+
+# This is no longer possible in her-0.6
+comments = User.find(1).comments(:approved => 1)
+
+# To pass additional parameters to the HTTP request, we now have to do this
+comments = User.find(1).comments.where(:approved => 1)
+```
+
+## 0.5
+
+Her is now compatible with `ActiveModel` and includes `ActiveModel::Validations`.
+
+Before 0.5, the `errors` method on an object would return an error list received from the server (the `:errors` key defined by the parsing middleware). But now, `errors` returns the error list generated after calling the `valid?` method (or any other similar validation method from `ActiveModel::Validations`). The error list returned from the server is now accessible from the `response_errors` method.
+
+Since 0.5.5, Her provides a `store_response_errors` method, which allows you to choose the method which will return the response errors. You can use it to revert Her back to its original behavior (ie. `errors` returning the response errors):
+
+```ruby
+class User
+  include Her::Model
+  store_response_errors :errors
+end
+
+user = User.create(:email => "foo") # POST /users returns { :errors => ["Email is invalid"] }
+user.errors # => ["Email is invalid"]
+```
+
+## 0.2.4
+
+Her no longer includes default middleware when making HTTP requests. The user has now to define all the needed middleware. Before:
+
+```ruby
+Her::API.setup :url => "https://api.example.com" do |connection|
+  connection.insert(0, FaradayMiddle::OAuth)
+end
+```
+
+Now:
+
+```ruby
+Her::API.setup :url => "https://api.example.com" do |connection|
+  connection.use FaradayMiddle::OAuth
+  connection.use Her::Middleware::FirstLevelParseJSON
+  connection.use Faraday::Request::UrlEncoded
+  connection.use Faraday::Adapter::NetHttp
+end
+```
+
+## 0.2
+
+The default parser middleware has been replaced to treat first-level JSON data as the resource or collection data. Before it expected this:
+
+```json
+{ "data": { "id": 1, "name": "Foo" }, "errors": [] }
+```
+
+Now it expects this (the `errors` key is not treated as resource data):
+  
+```json
+{ "id": 1, "name": "Foo", "errors": [] }
+```
+
+If you still want to get the old behavior, you can use `Her::Middleware::SecondLevelParseJSON` instead of `Her::Middleware::FirstLevelParseJSON` in your middleware stack.

data/gemfiles/Gemfile.activemodel-3.2.x

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gemspec :path => "../"
+
+gem 'activemodel', '~> 3.2.0'
+gem 'activesupport', '~> 3.2.0'
+gem 'faraday', '~> 0.8.9'

data/gemfiles/Gemfile.activemodel-4.0

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gemspec :path => "../"
+
+gem 'activemodel', '~> 4.0.0'
+gem 'activesupport', '~> 4.0.0'
+gem 'faraday', '~> 0.8.9'

data/gemfiles/Gemfile.activemodel-4.1

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gemspec :path => "../"
+
+gem 'activemodel', '~> 4.1.0'
+gem 'activesupport', '~> 4.1.0'
+gem 'faraday', '~> 0.8.9'

data/gemfiles/Gemfile.activemodel-4.2

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gemspec :path => "../"
+
+gem 'activemodel', '~> 4.2.0'
+gem 'activesupport', '~> 4.2.0'
+gem 'faraday', '~> 0.8.9'

data/gemfiles/Gemfile.activemodel-5.0.x

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+gemspec :path => "../"
+
+gem 'activemodel', '~> 5.0.0'
+gem 'activesupport', '~> 5.0.0'
+gem 'faraday', '~> 0.8.9'

data/her5.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "her/version"
+
+Gem::Specification.new do |s|
+  s.name        = "her5"
+  s.version     = Her::VERSION
+  s.authors     = ["Rémi Prévost"]
+  s.email       = ["remi@exomel.com"]
+  s.homepage    = "http://her-rb.org"
+  s.license     = "MIT"
+  s.summary     = "A simple Representational State Transfer-based Hypertext Transfer Protocol-powered Object Relational Mapper. Her?"
+  s.description = "Her5 is an ORM that maps REST resources and collections to Ruby objects. THIS IS ONLY AN UPDATE TO MAKE HER (UNMAINTAINED) WORK WITH RAILS 5 I LOVE YOU"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rake", "~> 10.0"
+  s.add_development_dependency "rspec", "~> 2.13"
+  s.add_development_dependency "rspec-its", "~> 1.0"
+  s.add_development_dependency "fivemat", "~> 1.2"
+  s.add_development_dependency "json", "~> 1.8"
+
+  s.add_runtime_dependency "activemodel", ">= 3.0.0", "<= 5.0.0"
+  s.add_runtime_dependency "activesupport", ">= 3.0.0", "<= 5.0.0"
+  s.add_runtime_dependency "faraday", ">= 0.8", "< 1.0"
+  s.add_runtime_dependency "multi_json", "~> 1.7"
+end

data/lib/her.rb

@@ -0,0 +1,19 @@
+require "her/version"
+
+require "multi_json"
+require "faraday"
+require "active_support"
+require "active_support/inflector"
+require "active_support/core_ext/hash"
+
+require "her/model"
+require "her/api"
+require "her/middleware"
+require "her/errors"
+require "her/collection"
+
+module Her
+  module JsonApi
+    autoload :Model, 'her/json_api/model'
+  end
+end

data/lib/her/api.rb

@@ -0,0 +1,120 @@
+module Her
+  # This class is where all HTTP requests are made. Before using Her, you must configure it
+  # so it knows where to make those requests. In Rails, this is usually done in `config/initializers/her.rb`:
+  class API
+    # @private
+    attr_reader :connection, :options
+
+    # Constants
+    FARADAY_OPTIONS = [:request, :proxy, :ssl, :builder, :url, :parallel_manager, :params, :headers, :builder_class].freeze
+
+    # Setup a default API connection. Accepted arguments and options are the same as {API#setup}.
+    def self.setup(opts={}, &block)
+      @default_api = new(opts, &block)
+    end
+
+    # Create a new API object. This is useful to create multiple APIs and use them with the `uses_api` method.
+    # If your application uses only one API, you should use Her::API.setup to configure the default API
+    #
+    # @example Setting up a new API
+    #   api = Her::API.new :url => "https://api.example" do |connection|
+    #     connection.use Faraday::Request::UrlEncoded
+    #     connection.use Her::Middleware::DefaultParseJSON
+    #   end
+    #
+    #   class User
+    #     uses_api api
+    #   end
+    def initialize(*args, &blk)
+      setup(*args, &blk)
+    end
+
+    # Setup the API connection.
+    #
+    # @param [Hash] opts the Faraday options
+    # @option opts [String] :url The main HTTP API root (eg. `https://api.example.com`)
+    # @option opts [String] :ssl A hash containing [SSL options](https://github.com/lostisland/faraday/wiki/Setting-up-SSL-certificates)
+    #
+    # @return Faraday::Connection
+    #
+    # @example Setting up the default API connection
+    #   Her::API.setup :url => "https://api.example"
+    #
+    # @example A custom middleware added to the default list
+    #   class MyAuthentication < Faraday::Middleware
+    #     def call(env)
+    #       env[:request_headers]["X-API-Token"] = "bb2b2dd75413d32c1ac421d39e95b978d1819ff611f68fc2fdd5c8b9c7331192"
+    #       @app.call(env)
+    #     end
+    #   end
+    #   Her::API.setup :url => "https://api.example.com" do |connection|
+    #     connection.use Faraday::Request::UrlEncoded
+    #     connection.use Her::Middleware::DefaultParseJSON
+    #     connection.use MyAuthentication
+    #     connection.use Faraday::Adapter::NetHttp
+    #   end
+    #
+    # @example A custom parse middleware
+    #   class MyCustomParser < Faraday::Response::Middleware
+    #     def on_complete(env)
+    #       json = JSON.parse(env[:body], :symbolize_names => true)
+    #       errors = json.delete(:errors) || {}
+    #       metadata = json.delete(:metadata) || []
+    #       env[:body] = { :data => json, :errors => errors, :metadata => metadata }
+    #     end
+    #   end
+    #   Her::API.setup :url => "https://api.example.com" do |connection|
+    #     connection.use Faraday::Request::UrlEncoded
+    #     connection.use MyCustomParser
+    #     connection.use Faraday::Adapter::NetHttp
+    #   end
+    def setup(opts={}, &blk)
+      opts[:url] = opts.delete(:base_uri) if opts.include?(:base_uri) # Support legacy :base_uri option
+      @options = opts
+      @options[:suppress_response_errors] ||= []
+
+      faraday_options = @options.reject { |key, value| !FARADAY_OPTIONS.include?(key.to_sym) }
+      @connection = Faraday.new(faraday_options) do |connection|
+        yield connection if block_given?
+      end
+      self
+    end
+
+    # Define a custom parsing procedure. The procedure is passed the response object and is
+    # expected to return a hash with three keys: a main data Hash, an errors Hash
+    # and a metadata Hash.
+    #
+    # @private
+    def request(opts={})
+      method = opts.delete(:_method)
+      path = opts.delete(:_path)
+      headers = opts.delete(:_headers)
+      opts.delete_if { |key, value| key.to_s =~ /^_/ } # Remove all internal parameters
+
+      begin
+        response = @connection.send method do |request|
+          request.headers.merge!(headers) if headers
+          if method == :get
+            # For GET requests, treat additional parameters as querystring data
+            request.url path, opts
+          else
+            # For POST, PUT and DELETE requests, treat additional parameters as request body
+            request.url path
+            request.body = opts
+          end
+        end
+
+        { :parsed_data => response.env[:body], :response => response }
+
+      rescue Her::Errors::ResponseError => e
+        raise e unless @options[:suppress_response_errors].include?(e.status)
+      end
+    end
+
+    private
+    # @private
+    def self.default_api(opts={})
+      defined?(@default_api) ? @default_api : nil
+    end
+  end
+end

data/lib/her/collection.rb

@@ -0,0 +1,12 @@
+module Her
+  class Collection < ::Array
+    attr_reader :metadata, :errors
+
+    # @private
+    def initialize(items=[], metadata={}, errors={})
+      super(items)
+      @metadata = metadata
+      @errors = errors
+    end
+  end
+end

data/lib/her/errors.rb

@@ -0,0 +1,104 @@
+module Her
+  module Errors
+
+    # Base class so that all Her errors can be handled generically.
+    class Error < StandardError
+    end
+    
+    class PathError < Error
+      attr_reader :missing_parameter
+
+      def initialize(message, missing_parameter=nil)
+        super(message)
+        @missing_parameter = missing_parameter
+      end
+    end
+
+    class AssociationUnknownError < Error
+    end
+
+    class ParseError < Error
+    end
+
+    class ResourceInvalid < Error
+      attr_reader :resource
+      def initialize(resource)
+        @resource = resource
+        errors = @resource.response_errors.join(", ")
+        super("Remote validation failed: #{errors}")
+      end
+    end
+    
+    # Base class so that response errors can be handled generically.
+    class ResponseError < Error
+      def status
+        0
+      end
+    end
+
+    # Status code 401: authentication required
+    class Unauthorized < ResponseError
+      def status
+        401
+      end
+    end
+
+    # Status code 403: authenticated but not authorized
+    class Forbidden < ResponseError
+      def status
+        403
+      end
+    end
+
+    # Status code 404: resource not found
+    class NotFound < ResponseError
+      def status
+        404
+      end
+    end
+
+    # Status code 500: we blew up
+    class ServerError < ResponseError
+      def status
+        500
+      end
+    end
+
+    # Status code 502: proxy says API has gone away
+    class BadGateway < ResponseError
+      def status
+        502
+      end
+    end
+
+    # Status code 503: API has definitely gone away
+    class Unavailable < ResponseError
+      def status
+        503
+      end
+    end
+
+    # Status code 504: API has probably gone away
+    class TimeOut < ResponseError
+      def status
+        504
+      end
+    end
+
+    def self.exception_class_for_status(status)
+      errors = {
+        401 => "Unauthorized",
+        403 => "Forbidden",
+        404 => "NotFound",
+        500 => "ServerError",
+        502 => "BadGateway",
+        503 => "Unavailable",
+        504 => "TimeOut"
+      }
+      if errors[status]
+        "Her::Errors::#{errors[status]}".constantize
+      end
+    end
+
+  end
+end