acts_as_api 0.4.4 → 1.0.0

data/lib/acts_as_api/base.rb

@@ -10,7 +10,6 @@ module ActsAsApi
     # When invoked, it enriches the current model with the
     # class and instance methods to act as api.
     def acts_as_api
-
       class_eval do
         include ActsAsApi::Base::InstanceMethods
         extend ActsAsApi::Base::ClassMethods
@@ -19,13 +18,11 @@ module ActsAsApi
       if block_given?
         yield ActsAsApi::Config
       end
-
     end
 
     module ClassMethods
-
-      def acts_as_api?#:nodoc:
-        self.included_modules.include?(InstanceMethods)
+      def acts_as_api? #:nodoc:
+        included_modules.include?(InstanceMethods)
       end
 
       # Determines the attributes, methods of the model that are accessible in the api response.
@@ -33,9 +30,7 @@ module ActsAsApi
       # So once the model acts as api, you have to determine all attributes here that should
       # be contained in the api responses.
       def api_accessible(api_template, options = {}, &block)
-
         attributes = api_accessible_attributes(api_template).try(:dup) || ApiTemplate.new(api_template)
-
         attributes.merge!(api_accessible_attributes(options[:extend])) if options[:extend]
 
         if block_given?
@@ -53,12 +48,11 @@ module ActsAsApi
     end
 
     module InstanceMethods
-
       # Creates the api response of the model and returns it as a Hash.
       # Will raise an exception if the passed api template is not defined for the model
       def as_api_response(api_template, options = {})
         api_attributes = self.class.api_accessible_attributes(api_template)
-        raise ActsAsApi::TemplateNotFoundError.new("acts_as_api template :#{api_template.to_s} was not found for model #{self.class}") if api_attributes.nil?
+        raise ActsAsApi::TemplateNotFoundError.new("acts_as_api template :#{api_template} was not found for model #{self.class}") if api_attributes.nil?
 
         before_api_response(api_template)
         response_hash = around_api_response(api_template) do
@@ -69,20 +63,17 @@ module ActsAsApi
         response_hash
       end
 
-    protected
-
-      def before_api_response(api_remplate)
-      end
+      protected
 
-      def after_api_response(api_remplate)
-      end
+        def before_api_response(_api_template)
+        end
 
-      def around_api_response(api_remplate)
-        yield
-      end
+        def after_api_response(_api_template)
+        end
 
+        def around_api_response(_api_template)
+          yield
+        end
     end
-
   end
-
 end

data/lib/acts_as_api/collection.rb

@@ -6,12 +6,11 @@ module ActsAsApi
     def as_api_response(api_template, options = {})
       collect do |item|
         if item.respond_to?(:as_api_response)
-          item.as_api_response(api_template,options)
+          item.as_api_response(api_template, options)
         else
           item
         end
       end
     end
-
   end
 end

data/lib/acts_as_api/config.rb

@@ -1,9 +1,6 @@
 module ActsAsApi
-
   module Config
-
     class << self
-
       attr_writer :accepted_api_formats, :dasherize_for, :include_root_in_json_collections, :add_root_node_for, :default_root, :allow_jsonp_callback, :add_http_status_to_jsonp_response
 
       # The accepted response formats
@@ -52,7 +49,5 @@ module ActsAsApi
         @add_http_status_to_jsonp_response.nil? ? true : @add_http_status_to_jsonp_response
       end
     end
-
   end
-
 end

data/lib/acts_as_api/exceptions.rb

@@ -1,4 +1,4 @@
 module ActsAsApi
   class ActsAsApiError < RuntimeError; end
-  class TemplateNotFoundError < ActsAsApiError; end  
-end
+  class TemplateNotFoundError < ActsAsApiError; end
+end

data/lib/acts_as_api/rails_renderer.rb

@@ -3,7 +3,6 @@ module ActsAsApi
   #
   # See ActsAsApi::Config about the possible configurations
   module RailsRenderer
-
     def self.setup
       ActionController.add_renderer :acts_as_api_jsonp do |json, options|
         json = ActiveSupport::JSON.encode(json) unless json.respond_to?(:to_str)
@@ -16,6 +15,5 @@ module ActsAsApi
         self.response_body = json
       end
     end
-
   end
 end

data/lib/acts_as_api/rendering.rb

@@ -1,9 +1,7 @@
 module ActsAsApi
-
   # The methods of this module are included into the AbstractController::Rendering
   # module.
   module Rendering
-
     # Provides an alternative to the +render+ method used within the controller
     # to simply generate API outputs.
     #
@@ -23,13 +21,13 @@ module ActsAsApi
       api_format_options = {}
 
       ActsAsApi::Config.accepted_api_formats.each do |item|
-        if render_options.has_key?(item)
+        if render_options.key?(item)
           api_format_options[item] = render_options[item]
           render_options.delete item
         end
       end
 
-      meta_hash = render_options[:meta] if render_options.has_key?(:meta)
+      meta_hash = render_options[:meta] if render_options.key?(:meta)
 
       api_format =  api_format_options.keys.first
       api_model  =  api_format_options.values.first
@@ -64,17 +62,14 @@ module ActsAsApi
 
       output_params[:root] = api_root_name
 
-      #output_params[:root] = output_params[:root].camelize if render_options.has_key?(:camelize) && render_options[:camelize]
-      #output_params[:root] = output_params[:root].dasherize if !render_options.has_key?(:dasherize) || render_options[:dasherize]
-
       api_response = api_model.as_api_response(api_template)
 
       if api_response.is_a?(Array) && api_format.to_sym == :json && ActsAsApi::Config.include_root_in_json_collections
-        api_response = api_response.collect{|f| { api_root_name.singularize => f } }
+        api_response = api_response.collect { |f| { api_root_name.singularize => f } }
       end
 
-      if meta_hash or ActsAsApi::Config.add_root_node_for.include? api_format
-        api_response = { api_root_name.to_sym =>  api_response}
+      if meta_hash || ActsAsApi::Config.add_root_node_for.include?(api_format)
+        api_response = { api_root_name.to_sym => api_response }
       end
 
       api_response = meta_hash.merge api_response if meta_hash
@@ -89,7 +84,5 @@ module ActsAsApi
 
       render output_params
     end
-
   end
-
 end

data/lib/acts_as_api/responder.rb

@@ -18,22 +18,17 @@ module ActsAsApi
   #  end
   #
   # The `:api_template` parameter is required so the responder knows which api template it should render.
-
   class Responder < ActionController::Responder
-    module Module
-      # Overrides the base implementation of display, replacing it with
-      # the render_for_api method whenever api_template is specified.
-      def display(resource, given_options={})
-        api_template = options[:api_template]
+    # Overrides the base implementation of display, replacing it with
+    # the render_for_api method whenever api_template is specified.
+    def display(resource, given_options = {})
+      api_template = options[:api_template]
 
-        if api_template.nil? || !resource.respond_to?(:as_api_response)
-          controller.render given_options.merge!(options).merge!(format => resource)
-        else
-          controller.render_for_api api_template, given_options.merge!(options).merge!(format => resource)
-        end
+      if api_template.nil? || !resource.respond_to?(:as_api_response)
+        controller.render given_options.merge!(options).merge!(format => resource)
+      else
+        controller.render_for_api api_template, given_options.merge!(options).merge!(format => resource)
       end
     end
-
-    include Module
   end
 end

data/lib/acts_as_api/version.rb

@@ -1,3 +1,3 @@
 module ActsAsApi
-  VERSION = "0.4.4"
+  VERSION = '1.0.0'.freeze
 end

data/spec/README.md

@@ -10,7 +10,7 @@ Every ORM has a rake task. Run `rake -T` to see them all.
 
 ## Working with the specs
 
-acts_as_api can be used with lots of different configurations, depending e.g. on the ORM (ActiveRecord, Mongoid, vanilla ruby) or the way the content is rendered (usual Rails controller, vs. Responder).
+acts_as_api can be used with lots of different configurations, depending e.g. on the ORM (ActiveRecord, Mongoid, vanilla ruby) or the way the content is rendered (usual Rails controller vs. Responder).
 
 A goal of the lib is to stay consistent in its behaviour over these different configurations, so it won't get in your way, once you change other parts of your application.
 
@@ -28,15 +28,25 @@ There used to be one Rails app that contained all supported ORMs. But multiple t
 
 Now there are multiple Rails apps, one for every supported ORM: `./active_record_dummy` and `./mongoid_dummy`.
 
-These are very simple apps, basically just clicked together on [railswizard.org](http://railswizard.org).
+These are very simple apps, they contain **no controllers** to be tested, just models that match the tested ones.
 
-They contain **no controllers** to be tested, just models that match the tested ones.
+### Debugging in the dummy apps
 
-### Adding a dummy Rails app
+Even though they are simple, you can still use the `rails console` of the dummy apps to debug acts_as_api.
+
+```
+$ cd spec/active_record_dummy
+$ rails c
+irb> User.last.as_api_response(:name_only)
+```
+
+This can come in very handy sometimes.
+
+### Adding a new dummy Rails app (in case you want to add another ORM)
 
 * Create a new Rails app in the folder `./spec/#{orm_name}_dummy`.
 
-* Create to Models used in the spec (`User, Profile, Untouched, Task`).
+* Create the models used in the spec (`User, Profile, Untouched, Task`).
 
 * Include `UserTemplate` in your `User` model.
 
@@ -51,5 +61,4 @@ gem 'acts_as_api', :path => '../../'
 
 * Add your dummy app to the `Rakefile` in the root folder by adding it to the `supported_orms` array.
 
-
 If you have to do some special setup (e.g. creating a schema) you can do this in `./spec_helper.rb`.

data/spec/active_record_dummy/Gemfile

@@ -2,15 +2,7 @@ source 'https://rubygems.org'
 
 gem 'rails', '5.0.0.1'
 
-# Bundle edge Rails instead:
-# gem 'rails', :git => 'git://github.com/rails/rails.git'
-
 gem 'sqlite3'
 
-gem 'shared_engine', :path => '../shared_engine'
-gem 'acts_as_api', :path => '../../'
-
-group :test do
-  gem 'rspec-rails', '>= 2.5.0'
-  gem 'webrat'  
-end
+gem 'shared_engine', path: '../shared_engine'
+gem 'acts_as_api', path: '../../'

data/spec/active_record_dummy/app/models/user.rb

@@ -1,5 +1,5 @@
 class User < ActiveRecord::Base
-  validates :first_name, :last_name, :presence => true
+  validates :first_name, :last_name, presence: true
 
   has_many :tasks
 
@@ -17,11 +17,11 @@ class User < ActiveRecord::Base
   end
 
   api_accessible :rename_last_name do |t|
-    t.add :last_name, :as => :family_name
+    t.add :last_name, as: :family_name
   end
 
   api_accessible :rename_full_name do |t|
-    t.add :full_name, :as => :other_full_name
+    t.add :full_name, as: :other_full_name
   end
 
   api_accessible :with_former_value do |t|
@@ -29,19 +29,19 @@ class User < ActiveRecord::Base
     t.add :last_name
   end
 
-  api_accessible :age_and_first_name, :extend => :with_former_value do |t|
+  api_accessible :age_and_first_name, extend: :with_former_value do |t|
     t.add :age
     t.remove :last_name
   end
 
   api_accessible :calling_a_proc do |t|
-    t.add Proc.new{|model| model.full_name.upcase  }, :as => :all_caps_name
-    t.add Proc.new{|model| Time.now.class.to_s  }, :as => :without_param
+    t.add proc { |model| model.full_name.upcase }, as: :all_caps_name
+    t.add proc { |_| Time.now.class.to_s }, as: :without_param
   end
 
   api_accessible :calling_a_lambda do |t|
-    t.add lambda{|model| model.full_name.upcase  }, :as => :all_caps_name
-    t.add lambda{|model| Time.now.class.to_s  }, :as => :without_param
+    t.add ->(model) { model.full_name.upcase }, as: :all_caps_name
+    t.add ->(_) { Time.now.class.to_s }, as: :without_param
   end
   api_accessible :include_tasks do |t|
     t.add :tasks
@@ -53,19 +53,19 @@ class User < ActiveRecord::Base
 
   api_accessible :other_sub_template do |t|
     t.add :first_name
-    t.add :tasks, :template => :other_template
+    t.add :tasks, template: :other_template
   end
 
   api_accessible :include_completed_tasks do |t|
-    t.add "tasks.completed.all", :as => :completed_tasks
+    t.add 'tasks.completed.all', as: :completed_tasks
   end
 
   api_accessible :sub_node do |t|
-    t.add Hash[:foo => :say_something], :as => :sub_nodes
+    t.add Hash[foo: :say_something], as: :sub_nodes
   end
 
   api_accessible :nested_sub_node do |t|
-    t.add Hash[:foo, Hash[:bar, :last_name]], :as => :sub_nodes
+    t.add Hash[:foo, Hash[:bar, :last_name]], as: :sub_nodes
   end
 
   api_accessible :nested_sub_hash do |t|
@@ -74,46 +74,46 @@ class User < ActiveRecord::Base
 
   api_accessible :if_over_thirty do |t|
     t.add :first_name
-    t.add :last_name, :if => :over_thirty?
+    t.add :last_name, if: :over_thirty?
   end
 
   api_accessible :if_returns_nil do |t|
     t.add :first_name
-    t.add :last_name, :if => :return_nil
+    t.add :last_name, if: :return_nil
   end
 
   api_accessible :if_over_thirty_proc do |t|
     t.add :first_name
-    t.add :last_name, :if => lambda{|u| u.over_thirty? }
+    t.add :last_name, if: ->(model) { model.over_thirty? }
   end
 
   api_accessible :if_returns_nil_proc do |t|
     t.add :first_name
-    t.add :last_name, :if => lambda{|u| nil }
+    t.add :last_name, if: ->(_) { nil }
   end
 
   api_accessible :unless_under_thirty do |t|
     t.add :first_name
-    t.add :last_name, :unless => :under_thirty?
+    t.add :last_name, unless: :under_thirty?
   end
 
   api_accessible :unless_returns_nil do |t|
     t.add :first_name
-    t.add :last_name, :unless => :return_nil
+    t.add :last_name, unless: :return_nil
   end
 
   api_accessible :unless_under_thirty_proc do |t|
     t.add :first_name
-    t.add :last_name, :unless => lambda{|u| u.under_thirty? }
+    t.add :last_name, unless: ->(model) { model.under_thirty? }
   end
 
   api_accessible :unless_returns_nil_proc do |t|
     t.add :first_name
-    t.add :last_name, :unless => lambda{|u| nil }
+    t.add :last_name, unless: ->(_) { nil }
   end
 
   api_accessible :with_prefix_name_only do |t|
-    t.add lambda{|model| 'true' }, :as => :prefix
+    t.add ->(_) { 'true' }, as: :prefix
     t.add :first_name
     t.add :last_name
   end
@@ -121,17 +121,17 @@ class User < ActiveRecord::Base
   api_accessible :name_only_with_postfix do |t|
     t.add :first_name
     t.add :last_name
-    t.add lambda{|model| 'true' }, :as => :postfix
+    t.add ->(_) { 'true' }, as: :postfix
   end
 
   api_accessible :with_prefix_name_only_with_postfix do |t|
-    t.add lambda{|model| 'true' }, :as => :prefix
+    t.add ->(_) { 'true' }, as: :prefix
     t.add :first_name
     t.add :last_name
-    t.add lambda{|model| 'true' }, :as => :postfix
+    t.add ->(_) { 'true' }, as: :postfix
   end
 
-  def before_api_response(api_response)
+  def before_api_response(_api_response)
     @before_api_response_called = true
   end
 
@@ -139,7 +139,7 @@ class User < ActiveRecord::Base
     !!@before_api_response_called
   end
 
-  def after_api_response(api_response)
+  def after_api_response(_api_response)
     @after_api_response_called = true
   end
 
@@ -151,8 +151,8 @@ class User < ActiveRecord::Base
     @skip_api_response = should_skip
   end
 
-  def around_api_response(api_response)
-    @skip_api_response ? { :skipped => true } : yield
+  def around_api_response(_api_response)
+    @skip_api_response ? { skipped: true } : yield
   end
 
   def over_thirty?
@@ -172,14 +172,13 @@ class User < ActiveRecord::Base
   end
 
   def say_something
-    "something"
+    'something'
   end
 
   def sub_hash
     {
-      :foo => "bar",
-      :hello => "world"
+      foo: 'bar',
+      hello: 'world'
     }
   end
-
 end