her 0.3.3 → 0.3.4

data/Rakefile

@@ -7,12 +7,12 @@ require "rspec/core/rake_task"
 task :default => :spec
 
 desc "Run all specs"
-RSpec::Core::RakeTask.new(:spec) do |task| # {{{
+RSpec::Core::RakeTask.new(:spec) do |task|
   task.pattern = "spec/**/*_spec.rb"
-end # }}}
+end
 
 desc "Generate YARD Documentation"
-YARD::Rake::YardocTask.new do |task| # {{{
+YARD::Rake::YardocTask.new do |task|
   task.options = [
     "-o", File.expand_path("../doc", __FILE__),
     "--readme=README.md",
@@ -24,4 +24,4 @@ YARD::Rake::YardocTask.new do |task| # {{{
     "--title=Her",
   ]
   task.files   = ["lib/**/*.rb"]
-end # }}}
+end

data/lib/her/api.rb

@@ -6,10 +6,10 @@ module Her
     attr_reader :base_uri, :connection, :options
 
     # Setup a default API connection. Accepted arguments and options are the same as {API#setup}.
-    def self.setup(attrs={}, &block) # {{{
+    def self.setup(attrs={}, &block)
       @@default_api = new
       @@default_api.setup(attrs, &block)
-    end # }}}
+    end
 
     # Setup the API connection.
     #
@@ -49,21 +49,21 @@ module Her
     #     connection.use MyCustomParser
     #     connection.use Faraday::Adapter::NetHttp
     #   end
-    def setup(attrs={}) # {{{
+    def setup(attrs={})
       attrs[:url] = attrs.delete(:base_uri) if attrs.include?(:base_uri) # Support legacy :base_uri option
       @base_uri = attrs[:url]
       @options = attrs
       @connection = Faraday.new(attrs.slice(:url, :ssl)) do |connection|
         yield connection if block_given?
       end
-    end # }}}
+    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 Array
     # and a metadata Hash.
     #
     # @private
-    def request(attrs={}) # {{{
+    def request(attrs={})
       method = attrs.delete(:_method)
       path = attrs.delete(:_path)
       headers = attrs.delete(:_headers)
@@ -80,12 +80,12 @@ module Her
         end
       end
       response.env[:body]
-    end # }}}
+    end
 
     private
     # @private
-    def self.default_api(attrs={}) # {{{
+    def self.default_api(attrs={})
       defined?(@@default_api) ? @@default_api : nil
-    end # }}}
+    end
   end
 end

data/lib/her/collection.rb

@@ -3,10 +3,10 @@ module Her
     attr_reader :metadata, :errors
 
     # @private
-    def initialize(items=[], metadata={}, errors=[]) # {{{
+    def initialize(items=[], metadata={}, errors=[])
       super(items)
       @metadata = metadata || {}
       @errors = errors || []
-    end # }}}
+    end
   end
 end

data/lib/her/middleware/accept_json.rb

@@ -2,14 +2,14 @@ module Her
   module Middleware
     # This middleware adds a "Accept: application/json" HTTP header
     class AcceptJSON < Faraday::Middleware
-      def add_header(headers) # {{{
+      def add_header(headers)
         headers.merge! "Accept" => "application/json"
-      end # }}}
+      end
 
-      def call(env) # {{{
+      def call(env)
         add_header(env[:request_headers])
         @app.call(env)
-      end # }}}
+      end
     end
   end
 end

data/lib/her/middleware/first_level_parse_json.rb

@@ -6,7 +6,7 @@ module Her
       #
       # @param [String] body The response body
       # @return [Mixed] the parsed response
-      def parse(body) # {{{
+      def parse(body)
         json = MultiJson.load(body, :symbolize_keys => true)
         errors = json.delete(:errors) || []
         metadata = json.delete(:metadata) || []
@@ -15,15 +15,15 @@ module Her
           :errors => errors,
           :metadata => metadata
         }
-      end # }}}
+      end
 
       # This method is triggered when the response has been received. It modifies
       # the value of `env[:body]`.
       #
       # @param [Hash] env The response environment
-      def on_complete(env) # {{{
+      def on_complete(env)
         env[:body] = parse(env[:body])
-      end # }}}
+      end
     end
   end
 end

data/lib/her/middleware/second_level_parse_json.rb

@@ -7,22 +7,22 @@ module Her
       #
       # @param [String] body The response body
       # @return [Mixed] the parsed response
-      def parse(body) # {{{
+      def parse(body)
         json = MultiJson.load(body, :symbolize_keys => true)
         {
           :data => json[:data],
           :errors => json[:errors],
           :metadata => json[:metadata]
         }
-      end # }}}
+      end
 
       # This method is triggered when the response has been received. It modifies
       # the value of `env[:body]`.
       #
       # @param [Hash] env The response environment
-      def on_complete(env) # {{{
+      def on_complete(env)
         env[:body] = parse(env[:body])
-      end # }}}
+      end
     end
   end
 end

data/lib/her/model/hooks.rb

@@ -53,14 +53,14 @@ module Her
 
       # Wrap a block between “before” and “after” hooks
       # @private
-      def wrap_in_hooks(resource, *hooks) # {{{
+      def wrap_in_hooks(resource, *hooks)
         perform_before_hooks(resource, *hooks)
         yield(resource, resource.class)
         perform_after_hooks(resource, *hooks.reverse)
-      end # }}}
+      end
 
       # @private
-      def hooks # {{{
+      def hooks
         @her_hooks ||= begin
           if superclass.respond_to?(:hooks)
             superclass.hooks.dup
@@ -68,16 +68,16 @@ module Her
             {}
           end
         end
-      end # }}}
+      end
 
       private
       # @private
-      def set_hook(time, name, action) # {{{
+      def set_hook(time, name, action)
         (self.hooks["#{time}_#{name}".to_sym] ||= []) << action
-      end # }}}
+      end
 
       # @private
-      def perform_hook(record, time, name) # {{{
+      def perform_hook(record, time, name)
         Array(self.hooks["#{time}_#{name}".to_sym]).each do |hook|
           if hook.is_a? Symbol
             record.send(hook)
@@ -85,23 +85,23 @@ module Her
             hook.call(record)
           end
         end
-      end # }}}
+      end
 
       # Perform “after” hooks on a resource
       # @private
-      def perform_after_hooks(resource, *hooks) # {{{
+      def perform_after_hooks(resource, *hooks)
         hooks.each do |hook|
           perform_hook(resource, :after, hook)
         end
-      end # }}}
+      end
 
       # Perform “before” hooks on a resource
       # @private
-      def perform_before_hooks(resource, *hooks) # {{{
+      def perform_before_hooks(resource, *hooks)
         hooks.each do |hook|
           perform_hook(resource, :before, hook)
         end
-      end # }}}
+      end
     end
   end
 end

data/lib/her/model/http.rb

@@ -3,27 +3,27 @@ module Her
     # This module interacts with Her::API to fetch HTTP data
     module HTTP
       # Automatically inherit a superclass' api
-      def her_api # {{{
+      def her_api
         @her_api ||= begin
           superclass.her_api if superclass.respond_to?(:her_api)
         end
-      end # }}}
+      end
 
       # Link a model with a Her::API object
-      def uses_api(api) # {{{
+      def uses_api(api)
         @her_api = api
-      end # }}}
+      end
 
       # Main request wrapper around Her::API. Used to make custom request to the API.
       # @private
-      def request(attrs={}) # {{{
+      def request(attrs={})
         parsed_data = her_api.request(attrs)
         if block_given?
           yield parsed_data
         else
           parsed_data
         end
-      end # }}}
+      end
 
       # Make a GET request and return either a collection or a resource
       #
@@ -34,7 +34,7 @@ module Her
       #
       #   @popular_users = User.get(:popular)
       #   # Fetched via GET "/users/popular"
-      def get(path, attrs={}) # {{{
+      def get(path, attrs={})
         path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
         get_raw(path, attrs) do |parsed_data|
           if parsed_data[:data].is_a?(Array)
@@ -43,32 +43,32 @@ module Her
             new(parsed_data[:data].merge :_metadata => parsed_data[:data], :_errors => parsed_data[:errors])
           end
         end
-      end # }}}
+      end
 
       # Make a GET request and return the parsed JSON response (not mapped to objects)
-      def get_raw(path, attrs={}, &block) # {{{
+      def get_raw(path, attrs={}, &block)
         path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
         request(attrs.merge(:_method => :get, :_path => path), &block)
-      end # }}}
+      end
 
       # Make a GET request and return a collection of resources
-      def get_collection(path, attrs={}) # {{{
+      def get_collection(path, attrs={})
         path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
         get_raw(path, attrs) do |parsed_data|
           new_collection(parsed_data)
         end
-      end # }}}
+      end
 
       # Make a GET request and return a collection of resources
-      def get_resource(path, attrs={}) # {{{
+      def get_resource(path, attrs={})
         path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
         get_raw(path, attrs) do |parsed_data|
           new(parsed_data[:data].merge :_metadata => parsed_data[:data], :_errors => parsed_data[:errors])
         end
-      end # }}}
+      end
 
       # Make a POST request and return either a collection or a resource
-      def post(path, attrs={}) # {{{
+      def post(path, attrs={})
         path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
         post_raw(path, attrs) do |parsed_data|
           if parsed_data[:data].is_a?(Array)
@@ -77,32 +77,32 @@ module Her
             new(parsed_data[:data].merge :_metadata => parsed_data[:data], :_errors => parsed_data[:errors])
           end
         end
-      end # }}}
+      end
 
       # Make a POST request and return the parsed JSON response (not mapped to objects)
-      def post_raw(path, attrs={}, &block) # {{{
+      def post_raw(path, attrs={}, &block)
         path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
         request(attrs.merge(:_method => :post, :_path => path), &block)
-      end # }}}
+      end
 
       # Make a POST request and return a collection of resources
-      def post_collection(path, attrs={}) # {{{
+      def post_collection(path, attrs={})
         path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
         post_raw(path, attrs) do |parsed_data|
           new_collection(parsed_data)
         end
-      end # }}}
+      end
 
       # Make a POST request and return a collection of resources
-      def post_resource(path, attrs={}) # {{{
+      def post_resource(path, attrs={})
         path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
         post_raw(path, attrs) do |parsed_data|
           new(parsed_data[:data])
         end
-      end # }}}
+      end
 
       # Make a PUT request and return either a collection or a resource
-      def put(path, attrs={}) # {{{
+      def put(path, attrs={})
         path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
         put_raw(path, attrs) do |parsed_data|
           if parsed_data[:data].is_a?(Array)
@@ -111,32 +111,32 @@ module Her
             new(parsed_data[:data].merge :_metadata => parsed_data[:data], :_errors => parsed_data[:errors])
           end
         end
-      end # }}}
+      end
 
       # Make a PUT request and return the parsed JSON response (not mapped to objects)
-      def put_raw(path, attrs={}, &block) # {{{
+      def put_raw(path, attrs={}, &block)
         path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
         request(attrs.merge(:_method => :put, :_path => path), &block)
-      end # }}}
+      end
 
       # Make a PUT request and return a collection of resources
-      def put_collection(path, attrs={}) # {{{
+      def put_collection(path, attrs={})
         path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
         put_raw(path, attrs) do |parsed_data|
           new_collection(parsed_data)
         end
-      end # }}}
+      end
 
       # Make a PUT request and return a collection of resources
-      def put_resource(path, attrs={}) # {{{
+      def put_resource(path, attrs={})
         path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
         put_raw(path, attrs) do |parsed_data|
           new(parsed_data[:data].merge :_metadata => parsed_data[:data], :_errors => parsed_data[:errors])
         end
-      end # }}}
+      end
 
       # Make a PATCH request and return either a collection or a resource
-      def patch(path, attrs={}) # {{{
+      def patch(path, attrs={})
         path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
         patch_raw(path, attrs) do |parsed_data|
           if parsed_data[:data].is_a?(Array)
@@ -145,32 +145,32 @@ module Her
             new(parsed_data[:data].merge :_metadata => parsed_data[:data], :_errors => parsed_data[:errors])
           end
         end
-      end # }}}
+      end
 
       # Make a PATCH request and return the parsed JSON response (not mapped to objects)
-      def patch_raw(path, attrs={}, &block) # {{{
+      def patch_raw(path, attrs={}, &block)
         path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
         request(attrs.merge(:_method => :patch, :_path => path), &block)
-      end # }}}
+      end
 
       # Make a PATCH request and return a collection of resources
-      def patch_collection(path, attrs={}) # {{{
+      def patch_collection(path, attrs={})
         path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
         patch_raw(path, attrs) do |parsed_data|
           new_collection(parsed_data)
         end
-      end # }}}
+      end
 
       # Make a PATCH request and return a collection of resources
-      def patch_resource(path, attrs={}) # {{{
+      def patch_resource(path, attrs={})
         path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
         patch_raw(path, attrs) do |parsed_data|
           new(parsed_data[:data].merge :_metadata => parsed_data[:data], :_errors => parsed_data[:errors])
         end
-      end # }}}
+      end
 
       # Make a DELETE request and return either a collection or a resource
-      def delete(path, attrs={}) # {{{
+      def delete(path, attrs={})
         path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
         delete_raw(path, attrs) do |parsed_data|
           if parsed_data[:data].is_a?(Array)
@@ -179,29 +179,29 @@ module Her
             new(parsed_data[:data].merge :_metadata => parsed_data[:data], :_errors => parsed_data[:errors])
           end
         end
-      end # }}}
+      end
 
       # Make a DELETE request and return the parsed JSON response (not mapped to objects)
-      def delete_raw(path, attrs={}, &block) # {{{
+      def delete_raw(path, attrs={}, &block)
         path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
         request(attrs.merge(:_method => :delete, :_path => path), &block)
-      end # }}}
+      end
 
       # Make a DELETE request and return a collection of resources
-      def delete_collection(path, attrs={}) # {{{
+      def delete_collection(path, attrs={})
         path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
         delete_raw(path, attrs) do |parsed_data|
           new_collection(parsed_data)
         end
-      end # }}}
+      end
 
       # Make a DELETE request and return a collection of resources
-      def delete_resource(path, attrs={}) # {{{
+      def delete_resource(path, attrs={})
         path = "#{build_request_path(attrs)}/#{path}" if path.is_a?(Symbol)
         delete_raw(path, attrs) do |parsed_data|
           new(parsed_data[:data].merge :_metadata => parsed_data[:data], :_errors => parsed_data[:errors])
         end
-      end # }}}
+      end
 
       # Define custom GET requests
       #
@@ -213,54 +213,54 @@ module Her
       #
       #   User.popular
       #   # Fetched from GET "/users/popular"
-      def custom_get(*paths) # {{{
+      def custom_get(*paths)
         metaclass = (class << self; self; end)
         paths.each do |path|
           metaclass.send(:define_method, path.to_sym) do |*attrs|
             get(path, attrs.first || Hash.new)
           end
         end
-      end # }}}
+      end
 
       # Define custom POST requests
-      def custom_post(*paths) # {{{
+      def custom_post(*paths)
         metaclass = (class << self; self; end)
         paths.each do |path|
           metaclass.send(:define_method, path.to_sym) do |*attrs|
             post(path, attrs.first || Hash.new)
           end
         end
-      end # }}}
+      end
 
       # Define custom PUT requests
-      def custom_put(*paths) # {{{
+      def custom_put(*paths)
         metaclass = (class << self; self; end)
         paths.each do |path|
           metaclass.send(:define_method, path.to_sym) do |*attrs|
             put(path, attrs.first || Hash.new)
           end
         end
-      end # }}}
+      end
 
       # Define custom PATCH requests
-      def custom_patch(*paths) # {{{
+      def custom_patch(*paths)
         metaclass = (class << self; self; end)
         paths.each do |path|
           metaclass.send(:define_method, path.to_sym) do |*attrs|
             patch(path, attrs.first || Hash.new)
           end
         end
-      end # }}}
+      end
 
       # Define custom DELETE requests
-      def custom_delete(*paths) # {{{
+      def custom_delete(*paths)
         metaclass = (class << self; self; end)
         paths.each do |path|
           metaclass.send(:define_method, path.to_sym) do |*attrs|
             delete(path, attrs.first || Hash.new)
           end
         end
-      end # }}}
+      end
     end
   end
 end