acts_as_api 0.3.11 → 0.4

data/.gitignore

@@ -4,8 +4,11 @@ pkg/*
 Gemfile.lock
 test
 acts_as_api.tmproj
-spec/rails_app/db/*.sqlite3
-spec/rails_app/tmp/**/*
-spec/rails_app/log/*.log
+spec/active_record_dummy/db/*.sqlite3
+spec/active_record_dummy/tmp/**/*
+spec/active_record_dummy/log/*.log
+spec/mongoid_dummy/tmp/**/*
+spec/mongoid_dummy/log/*.log
 .rspec
-.rvmrc
+.rvmrc
+*.sqlite3-journal

data/.travis.yml

@@ -1,4 +1,8 @@
+script: bundle exec rake spec:all
+
 rvm:
   - 1.8.7
   - 1.9.2
-  - ree
+  - 1.9.3
+  - ruby-head
+  - ree  

data/Gemfile

@@ -6,7 +6,8 @@ gemspec
 group :test do
   gem 'sqlite3-ruby'
   gem 'mongoid', '>= 2.0.1'
+  gem 'rspec', '>= 2.9.0'
   gem 'rspec-rails', '>= 2.5.0'
   gem 'webrat'
-  gem 'rocco', :git => 'git://github.com/fabrik42/rocco.git'
+  gem 'shared_engine', :path => './spec/shared_engine'
 end

data/History.txt

@@ -1,3 +1,7 @@
+=== 0.4 2012-04-30
+
+* Added support for a second parameter (options) to pass to as_api_response
+
 === 0.3.11 2011-11-06
 
 * Added :postfix, :prefix options for template rendering

data/README.md

@@ -6,6 +6,8 @@ It provides a simple interface to determine the representation of your model dat
 
 In addition to Rails it theoretically can be used with any ruby app and any database (__ActiveRecord__ and __Mongoid__ are supported out of the box) as it only has few dependencies.
 
+The lib is _very_ fast in generating your responses and battle tested in production with platforms like [Diaspora](https://joindiaspora.com) or [flinc](https://flinc.org).
+
 ## Introduction
 
 acts_as_api enriches the models and controllers of your app in a Rails-like way so you can easily determine how your API responses should look like:
@@ -54,7 +56,7 @@ There are a lot of how-tos like:
 * DRY templates for your api responses
 * Ships with support for __ActiveRecord__ and __Mongoid__
 * Support for Rails 3 Responders
-* Plays very well together with client libs like [Backbone.js](http://documentcloud.github.com/backbone) or [RestKit](http://restkit.org) (iOS).
+* Plays very well together with client libs like [Backbone.js](http://documentcloud.github.com/backbone), [RestKit](http://restkit.org) (iOS) or [gson](http://code.google.com/p/google-gson) (Android).
 * Easy but very flexible syntax for defining the templates
 * XML, JSON and JSON-P support out of the  box, easy to extend
 * Minimal dependecies (you can also use it without Rails)
@@ -76,14 +78,17 @@ There are a lot of how-tos like:
 
 * Wiki: https://github.com/fabrik42/acts_as_api/wiki
 
+* Want to contribute - the spec suite is explained here: https://github.com/fabrik42/acts_as_api/tree/master/spec
+
 ### Travis CI build status ![acts_as_api on travis ci](http://travis-ci.org/fabrik42/acts_as_api.png)
 
-Specs run with 1.9.2, 1.8.7 and REE: http://travis-ci.org/#!/fabrik42/acts_as_api
+Specs run with 1.9.3, 1.9.2, 1.8.7 and REE: http://travis-ci.org/#!/fabrik42/acts_as_api
 
 ### Tested with:
 
-* MRI 1.9.2-p180
-* MRI 1.8.7-p334
+* MRI 1.9.3-p125
+* MRI 1.9.2-p290
+* MRI 1.8.7-p358
 * But it just should work fine with other versions too... :)
 
 ### Downwards Compatibility

data/Rakefile

@@ -8,17 +8,40 @@ RSpec::Core::RakeTask.new
 
 namespace :spec do
 
-  desc "Run ActiveRecord RSpec code examples only"
-  RSpec::Core::RakeTask.new do |t|
-    t.name = :active_record
-    t.rspec_opts = ["--color", "--format", "documentation", "--tag", "orm:active_record"]
+  supported_orms = %w(mongoid active_record)
+
+  supported_orms.each do |orm|
+    desc "Run #{orm} specs only"
+    RSpec::Core::RakeTask.new do |t|
+      t.name = orm
+      t.rspec_opts = ["--color"]
+    end
+
+    task "prepare_#{orm}" do
+      ENV['ACTS_AS_API_ORM'] = orm
+    end
+
+    Rake::Task["spec:#{orm}"].prerequisites << "spec:prepare_#{orm}"
+  end
+
+
+#  task :all => supported_orms.map{|orm| "spec:#{orm}"}
+
+  desc "Runs specs for all ORMs (#{supported_orms.join(', ')})"
+  task :all do
+    supported_orms.each do |orm|
+      puts "Starting to run specs for #{orm}..."
+      system("bundle exec rake spec:#{orm}")
+      raise "#{orm} failed!" unless $?.exitstatus == 0
+    end
   end
 
 end
 
+
 gemspec = Gem::Specification.load("acts_as_api.gemspec")
 
-task :default => :spec
+task :default => "spec:all"
 
 desc "Generate the gh_pages site"
 task :rocco do

data/acts_as_api.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |s|
   s.add_dependency('activesupport','>= 3.0.0')
   s.add_dependency('rack','>= 1.1.0')
 
-  s.add_development_dependency('rails', ['>= 3.1.0'])
+  s.add_development_dependency('rails', ['>= 3.2.3'])
   s.add_development_dependency('mongoid', ['>= 2.0.1'])
 
   s.rdoc_options  = ['--charset=UTF-8']

data/lib/acts_as_api/api_template.rb

@@ -11,18 +11,11 @@ module ActsAsApi
 
     # The name of the api template as a Symbol.
     attr_accessor :api_template
-    
-    attr_reader :options
 
-    # Returns a new ApiTemplate with the api template name
-    # set to the passed template.
-    def self.create(template)
-      t = ApiTemplate.new
-      t.api_template = template
-      return t
-    end
+    attr_reader :options
 
-    def initialize
+    def initialize(api_template)
+      self.api_template = api_template
       @options ||= {}
     end
 
@@ -67,82 +60,80 @@ module ActsAsApi
     # If a special template name for the passed item is specified
     # it will be returned, if not the original api template.
     def api_template_for(fieldset, field)
-      return api_template unless fieldset.is_a? ActsAsApi::ApiTemplate
       fieldset.option_for(field, :template) || api_template
     end
 
     # Decides if the passed item should be added to
     # the response based on the conditional options passed.
-    def allowed_to_render?(fieldset, field, model)
+    def allowed_to_render?(fieldset, field, model, options)
       return true unless fieldset.is_a? ActsAsApi::ApiTemplate
-      allowed = true
-      allowed = condition_fulfilled?(model, fieldset.option_for(field, :if)) if fieldset.option_for(field, :if)
-      allowed = !(condition_fulfilled?(model, fieldset.option_for(field, :unless))) if fieldset.option_for(field, :unless)
-      return allowed
+      
+      fieldset_options = fieldset.options_for(field)
+      
+      if fieldset_options[:unless]
+        !(condition_fulfilled?(model, fieldset_options[:unless], options))
+      elsif fieldset_options[:if]
+        condition_fulfilled?(model, fieldset_options[:if], options)
+      else
+        true
+      end
     end
 
     # Checks if a condition is fulfilled
     # (result is not nil or false)
-    def condition_fulfilled?(model, condition)
+    def condition_fulfilled?(model, condition, options)
       case condition
       when Symbol
         result = model.send(condition)
       when Proc
-        result = condition.call(model)
+        result = call_proc(condition, model, options)
       end
-      !result.nil? && !result.is_a?(FalseClass)
+      !!result
     end
 
     # Generates a hash that represents the api response based on this
     # template for the passed model instance.
-    def to_response_hash(model)
-      queue = []
+    def to_response_hash(model, fieldset = self, options = {})
       api_output = {}
-      
-      queue << { :output =>  api_output, :item => self }
-
-      until queue.empty? do
-        leaf = queue.pop
-        fieldset = leaf[:item]
-                
-        fieldset.each do |field, value|
-
-          next unless allowed_to_render?(fieldset, field, model)
-
-          case value
-          when Symbol
-            if model.respond_to?(value)
-              out = model.send value
-            end
-
-          when Proc
-            out = value.call(model)
-
-          when String
-            # go up the call chain
-            out = model
-            value.split(".").each do |method|
-              out = out.send(method.to_sym)
-            end
-
-          when Hash
-            leaf[:output][field] ||= {}
-            queue << { :output =>  leaf[:output][field], :item => value }
-            next
-          end
-
-          if out.respond_to?(:as_api_response)
-            sub_template = api_template_for(fieldset, field)
-            out = out.send(:as_api_response, sub_template)
-          end
-
-          leaf[:output][field] = out
+
+      fieldset.each do |field, value|
+        next unless allowed_to_render?(fieldset, field, model, options)
+
+        out = process_value(model, value, options)
+
+        if out.respond_to?(:as_api_response)
+          sub_template = api_template_for(fieldset, field)
+          out = out.as_api_response(sub_template, options)
         end
-        
+
+        api_output[field] = out
       end
-      
+
       api_output
     end
-    
+
+  private
+
+    def process_value(model, value, options)
+      case value
+      when Symbol
+        model.send(value)
+      when Proc
+        call_proc(value,model,options)
+      when String
+        value.split('.').inject(model) { |result, method| result.send(method) }
+      when Hash
+        to_response_hash(model, value)
+      end
+    end
+
+    def call_proc(the_proc,model,options)
+      if the_proc.arity == 2
+        the_proc.call(model, options)
+      else
+        the_proc.call(model)
+      end
+    end
+
   end
 end

data/lib/acts_as_api/array.rb

@@ -6,11 +6,11 @@ class Array
   # The Array checks all its items if they respond to the +as_api_response+ method.
   # If they do, the result of this method will be collected.
   # If they don't, the item itself will be collected.
-  def as_api_response(api_template)
+  def as_api_response(api_template, options = {})
 
     collect do |item|
       if item.respond_to?(:as_api_response)
-        item.as_api_response(api_template)
+        item.as_api_response(api_template,options)
       else
         item
       end

data/lib/acts_as_api/base.rb

@@ -34,7 +34,7 @@ module ActsAsApi
       # be contained in the api responses.
       def api_accessible(api_template, options = {}, &block)
 
-        attributes = api_accessible_attributes(api_template) || ApiTemplate.create(api_template)
+        attributes = api_accessible_attributes(api_template) || ApiTemplate.new(api_template)
 
         attributes.merge!(api_accessible_attributes(options[:extend])) if options[:extend]
 
@@ -56,25 +56,31 @@ module ActsAsApi
 
       # 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)
+      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?
-          
-        before_api_response(api_template) if respond_to? :before_api_response
-        
-        response_hash = if respond_to? :around_api_response
-          around_api_response api_template do
-            api_attributes.to_response_hash(self)
-          end
-        else
-          api_attributes.to_response_hash(self)
-        end
 
-        after_api_response(api_template) if respond_to? :after_api_response
+        before_api_response(api_template)
+        response_hash = around_api_response(api_template) do
+          api_attributes.to_response_hash(self, api_attributes, options)
+        end
+        after_api_response(api_template)
 
         response_hash
       end
 
+    protected
+
+      def before_api_response(api_remplate)
+      end
+
+      def after_api_response(api_remplate)
+      end
+
+      def around_api_response(api_remplate)
+        yield
+      end
+
     end
 
   end

data/lib/acts_as_api/config.rb

@@ -49,10 +49,10 @@ module ActsAsApi
       # If true the jsonp function call will get the http status passed
       # as a second parameter
       def add_http_status_to_jsonp_response
-        @add_http_status_to_jsonp_response || true     
+        @add_http_status_to_jsonp_response.nil? ? true : @add_http_status_to_jsonp_response
       end
     end
     
   end
 
-end
+end

data/lib/acts_as_api/rendering.rb

@@ -41,14 +41,14 @@ module ActsAsApi
 
       if !output_params[:root].nil?
         api_root_name = output_params[:root].to_s
+      elsif api_model.class.respond_to?(:model_name)        
+        api_root_name = api_model.class.model_name        
       elsif api_model.respond_to?(:collection_name)
         api_root_name = api_model.collection_name
-      elsif api_model.respond_to?(:model_name)
-        api_root_name = api_model.model_name
       elsif api_model.is_a?(Array) && !api_model.empty? && api_model.first.class.respond_to?(:model_name)
         api_root_name = api_model.first.class.model_name
-      elsif api_model.class.respond_to?(:model_name)
-        api_root_name = api_model.class.model_name
+      elsif api_model.respond_to?(:model_name)
+        api_root_name = api_model.model_name        
       else
         api_root_name = ActsAsApi::Config.default_root.to_s
       end

data/lib/acts_as_api/version.rb

@@ -1,3 +1,3 @@
 module ActsAsApi
-  VERSION = "0.3.11"
+  VERSION = "0.4"
 end

data/spec/README.md

@@ -0,0 +1,55 @@
+# Spec folder intro
+
+## Running specs
+
+Every ORM has a rake task. Run `rake -T` to see them all.
+
+`rake spec:all` will run all spec suites in a row.
+
+`rake spec:#{orm_name}` will run the spec suite for a specific ORM.
+
+## 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).
+
+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.
+
+To achieve this goal and because of the need to keep the specs as DRY as possible, the following spec setup was created:
+
+### A shared engine
+
+In order to keep the spec suite DRY it uses a Rails engine, available at `./shared_engine`.
+
+It contains the controllers that are re-used by the ORM-specific Rails apps and some mixins that can be shared over the models of different ORMs.
+
+### Dummy Rails apps
+
+There used to be one Rails app that contained all supported ORMs. But multiple times this setup veiled problems e.g. with ORM-specific dependencies.
+
+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).
+
+They contain **no controllers** to be tested, just models that match the tested ones.
+
+### Adding a dummy Rails app
+
+* Create a new Rails app in the folder `./spec/#{orm_name}_dummy`.
+
+* Create to Models used in the spec (`User, Profile, Untouched, Task`).
+
+* Include `SharedEngine::UserTemplate` in your `User` model.
+
+* Add `mount SharedEngine::Engine => "/shared", :as => "shared"` to your `routes.rb`
+
+* Add the following lines to your Gemfile:
+
+```ruby
+gem 'shared_engine', :path => '../shared_engine'
+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`.