standardapi 1.0.6 → 1.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 58e5aa906cbdb420349c0ae94d74186ca8191c7f
-  data.tar.gz: 8a362d7d2fb5f90921260e93ee04df163c868520
+  metadata.gz: 67dc838f6d2096fd1f791c9781490db311b9b4b2
+  data.tar.gz: 96d425ce24603f45e9ea714e55b347d5fa9838ae
 SHA512:
-  metadata.gz: c89fa1bc6e4e0b2d8165a67dd3bb4d761b6d2681aac2c352fcc4da496f1dd048e4147be27d4193c90858123b7e34730b7e4f670f67cc693cb2941145efb724d0
-  data.tar.gz: e92218bbf59865553d2012606db1071a20310cdf129ed753d24ae78486abd4292b1a381dc8fd757aba24a87763380ea16db8abb0177283630aec870c4ebdd0ec
+  metadata.gz: 9ee824965d303ebe14f3bd0122df8332e4ed8f1c6ee28bd35ac3b3df1f817229cb23b2b668d4dcf8fcf5a81071ed52b22cf526e89cc29ade3cae51c66ca4d31b
+  data.tar.gz: e146f7d6db4c276b92fd4f899c83e41a6afb6384c7e10c6bd49b777ee062fa49e3979d0157b8de3a1889b505d072d10c62abd7f05bc0c098c3ed9d399d74c90c

data/lib/standard_api/test_case/create_tests.rb

@@ -4,7 +4,7 @@ module StandardAPI
       extend ActiveSupport::Testing::Declarative
 
       test '#create.json' do
-        attrs = attributes_for(singular_name).select{|k,v| !model.readonly_attributes.include?(k.to_s) }
+        attrs = attributes_for(singular_name, :nested).select{|k,v| !model.readonly_attributes.include?(k.to_s) }
         create_webmocks(attrs)
 
         assert_difference("#{model.name}.count") do
@@ -14,8 +14,11 @@ module StandardAPI
 
           json = JSON.parse(response.body)
           assert json.is_a?(Hash)
-          (model.attribute_names & attrs.keys.map(&:to_s)).each do |test_key|
-            assert_equal normalize_to_json(test_key, attrs[test_key.to_sym]), json[test_key]
+
+          m = assigns(singular_name)
+          view_attributes(m.reload).select { |x| attrs.keys.map(&:to_s).include?(x) }.each do |key, value|
+            message = "Model / Attribute: #{m.class.name}##{key}"
+            assert_equal normalize_to_json(m, key, attrs[key.to_sym]), json[key.to_s], message
           end
         end
       end
@@ -31,8 +34,10 @@ module StandardAPI
 
           json = JSON.parse(response.body)
           assert json.is_a?(Hash)
-          (model.attribute_names & attrs.keys.map(&:to_s)).each do |test_key|
-            assert_equal normalize_to_json(test_key, attrs[test_key.to_sym]), json[test_key]
+          m = assigns(singular_name).reload
+          view_attributes(m).select { |x| attrs.keys.map(&:to_s).include?(x) }.each do |key, value|
+            message = "Model / Attribute: #{m.class.name}##{key}"
+            assert_equal normalize_attribute(m, key, attrs[key.to_sym]), value, message
           end
         end
       end
@@ -51,27 +56,33 @@ module StandardAPI
       end
 
       test '#create.json params[:include]' do
-        attrs = attributes_for(singular_name, :nested).select{ |k,v| !model.readonly_attributes.include?(k.to_s) }
-        create_webmocks(attrs)
+        travel_to Time.now do
+          attrs = attributes_for(singular_name, :nested).select{ |k,v| !model.readonly_attributes.include?(k.to_s) }
+          create_webmocks(attrs)
 
-        assert_difference("#{model.name}.count") do
-          post :create, singular_name => attrs, include: includes, :format => 'json'
-          assert_response :created
-          assert assigns(singular_name)
+          assert_difference("#{model.name}.count") do
+            post :create, singular_name => attrs, include: includes, :format => 'json'
+            assert_response :created
+            assert assigns(singular_name)
 
-          json = JSON.parse(response.body)
-          assert json.is_a?(Hash)
-          includes.each do |included|
-            assert json.key?(included.to_s), "#{included.inspect} not included in response"
+            json = JSON.parse(response.body)
+            assert json.is_a?(Hash)
+            includes.each do |included|
+              assert json.key?(included.to_s), "#{included.inspect} not included in response"
 
-            association = assigns(:record).class.reflect_on_association(included)
-            if ['belongs_to', 'has_one'].include?(association.macro)
-              assigns(:record).send(included).attributes do |key, value|
-                assert_equal json[included.to_s][key.to_s], value
-              end
-            else
-              assigns(:record).send(included).first.attributes.each do |key, value|
-                assert_equal json[included.to_s][0][key.to_s], value
+              association = assigns(:record).class.reflect_on_association(included)
+              next if !association
+
+              if ['belongs_to', 'has_one'].include?(association.macro.to_s)
+                view_attributes(assigns(:record).send(included)) do |key, value|
+                  assert_equal json[included.to_s][key.to_s], normalize_to_json(assigns(:record), key, value)
+                end
+              else
+                m = assigns(:record).send(included).first.try(:reload)
+                view_attributes(m).each do |key, value|
+                  message = "Model / Attribute: #{m.class.name}##{key}"
+                  assert_equal normalize_to_json(m, key, value), json[included.to_s][0][key.to_s], message
+                end
               end
             end
           end

data/lib/standard_api/test_case/index_tests.rb

@@ -25,16 +25,9 @@ module StandardAPI
       test '#index.json params[:order]' do
         orders.each do |order|
           @controller.instance_variable_set('@orders', nil) # Hack for dealing with caching / multiple request per controller life
-          if order.is_a?(Hash)
-            order.values.last.each do |o|
-              get :index, order: {order.keys.first => o}, format: 'json'
-              assert_equal model.sort(order.keys.first => o).to_sql, assigns(plural_name).to_sql
-            end
-          else
-            get :index, order: order, format: 'json'
-            assert_equal model.sort(order).to_sql, assigns(:records).to_sql
-          end
-        end
+          get :index, order: order, format: 'json'
+          assert_equal model.sort(order).to_sql, assigns(:records).to_sql
+         end
       end
 
       test '#index.json params[:offset]' do
@@ -43,10 +36,32 @@ module StandardAPI
       end
 
       test '#index.json params[:include]' do
-        create_model
-        get :index, include: includes, format: 'json'
-        includes.each do |included|
-          assert JSON.parse(response.body)[0].key?(included.to_s), "#{included.inspect} not included in response"
+        travel_to Time.now do
+          create_model
+          get :index, include: includes, format: 'json'
+        
+          json = JSON.parse(response.body)[0]
+          assert json.is_a?(Hash)
+          includes.each do |included|
+            assert json.key?(included.to_s), "#{included.inspect} not included in response"
+
+            association = assigns(:records).first.class.reflect_on_association(included)
+            next if !association
+
+            if ['belongs_to', 'has_one'].include?(association.macro.to_s)
+              m = assigns(:records).first.send(included)
+              view_attributes(m) do |key, value|
+                message = "Model / Attribute: #{m.class.name}##{key}"
+                assert_equal json[included.to_s][key.to_s], normalize_to_json(m, key, value), message
+              end
+            else
+              m = assigns(:records).first.send(included).first.try(:reload)
+              view_attributes(m).each do |key, value|
+                message = "Model / Attribute: #{m.class.name}##{key}"
+                assert_equal json[included.to_s][0][key.to_s], normalize_to_json(m, key, value), message
+              end
+            end
+          end
         end
       end
 

data/lib/standard_api/test_case/show_tests.rb

@@ -22,13 +22,17 @@ module StandardAPI
           assert json.key?(included.to_s), "#{included.inspect} not included in response"
 
           association = assigns(:record).class.reflect_on_association(included)
-          if ['belongs_to', 'has_one'].include?(association.macro)
-            assigns(:record).send(included).attributes do |key, value|
+          next if !association
+
+          if ['belongs_to', 'has_one'].include?(association.macro.to_s)
+            view_attributes(assigns(:record).send(included)) do |key, value|
               assert_equal json[included.to_s][key.to_s], value
             end
           else
-            assigns(:record).send(included).first.attributes.each do |key, value|
-              assert_equal json[included.to_s][0][key.to_s], value
+            m = assigns(:record).send(included).first.try(:reload)
+            view_attributes(m).each do |key, value|
+              message = "Model / Attribute: #{m.class.name}##{key}"
+              assert_equal normalize_to_json(m, key, value), json[included.to_s][0][key.to_s], message
             end
           end
         end

data/lib/standard_api/test_case/update_tests.rb

@@ -11,8 +11,9 @@ module StandardAPI
         put :update, id: m.id, singular_name => attrs, format: 'json'
         assert_response :ok
 
-        (m.attribute_names & attrs.keys.map(&:to_s)).each do |test_key|
-          assert_equal normalize_attribute(test_key, attrs[test_key.to_sym]), m.reload.send(test_key)
+        view_attributes(m.reload).select { |x| attrs.keys.map(&:to_s).include?(x) }.each do |key, value|
+          message = "Model / Attribute: #{m.class.name}##{key}"
+          assert_equal normalize_attribute(m, key, attrs[key.to_sym]), value, message
         end
         assert JSON.parse(@response.body).is_a?(Hash)
       end
@@ -21,12 +22,13 @@ module StandardAPI
         m = create_model
         attrs = attributes_for(singular_name, :nested).select{|k,v| !model.readonly_attributes.include?(k.to_s) }
         create_webmocks(attrs)
-
         put :update, id: m.id, singular_name => attrs, format: 'json'
         assert_response :ok
 
-        (m.attribute_names & attrs.keys.map(&:to_s)).each do |test_key|
-          assert_equal normalize_attribute(test_key, attrs[test_key.to_sym]), m.reload.send(test_key)
+        # (m.attribute_names & attrs.keys.map(&:to_s)).each do |test_key|
+        view_attributes(m.reload).select { |x| attrs.keys.map(&:to_s).include?(x) }.each do |key, value|
+          message = "Model / Attribute: #{m.class.name}##{key}"
+          assert_equal normalize_attribute(m, key, attrs[key.to_sym]), value, message
         end
         assert JSON.parse(@response.body).is_a?(Hash)
       end
@@ -42,24 +44,31 @@ module StandardAPI
       end
 
       test '#update.json params[:include]' do
-        m = create_model
-        attrs = attributes_for(singular_name, :nested).select{|k,v| !model.readonly_attributes.include?(k) }
-        create_webmocks(attrs)
+        travel_to Time.now do
+          m = create_model
+          attrs = attributes_for(singular_name, :nested).select{|k,v| !model.readonly_attributes.include?(k) }
+          create_webmocks(attrs)
 
-        put :update, id: m.id, include: includes, singular_name => attrs, format: 'json'
+          put :update, id: m.id, include: includes, singular_name => attrs, format: 'json'
 
-        json = JSON.parse(response.body)
-        includes.each do |included|
-          assert json.key?(included.to_s), "#{included.inspect} not included in response"
+          json = JSON.parse(response.body)
+          includes.each do |included|
+            assert json.key?(included.to_s), "#{included.inspect} not included in response"
 
-          association = assigns(:record).class.reflect_on_association(included)
-          if ['belongs_to', 'has_one'].include?(association.macro)
-            assigns(:record).send(included).attributes do |key, value|
-              assert_equal json[included.to_s][key.to_s], value
-            end
-          else
-            assigns(:record).send(included).first.attributes.each do |key, value|
-              assert_equal json[included.to_s][0][key.to_s], value
+            association = assigns(:record).class.reflect_on_association(included)
+            next if !association
+
+            if ['belongs_to', 'has_one'].include?(association.macro.to_s)
+              view_attributes(assigns(:record).send(included)) do |key, value|
+                message = "Model / Attribute: #{assigns(:record).send(included).class.name}##{key}"
+                assert_equal json[included.to_s][key.to_s], value, message
+              end
+            else
+              m = assigns(:record).send(included).first.try(:reload)
+              view_attributes(m).each do |key, value|
+                message = "Model / Attribute: #{m.class.name}##{key}"
+                assert_equal normalize_to_json(assigns(:record), key, value), json[included.to_s][0][key.to_s], message
+              end
             end
           end
         end

data/lib/standard_api/test_case.rb

@@ -15,20 +15,26 @@ module StandardAPI::TestCase
     [:filters, :orders, :includes].each do |attribute|
       klass.send(:class_attribute, attribute)
     end
-    if defined?(model_class_name.constantize)
+
+    begin
       model_class = model_class_name.constantize
       klass.send(:filters=, model_class.attribute_names)
       klass.send(:orders=, model_class.attribute_names)
       klass.send(:includes=, model_class.reflect_on_all_associations.map(&:name))
+    rescue NameError => e
+      raise e if e.message != "uninitialized constant #{model_class_name}"
     end
-    
+
     klass.extend(ClassMethods)
 
-    klass.controller_class.action_methods.each do |action|
-      if const_defined?("StandardAPI::TestCase::#{action.capitalize}Tests")
-        # Include the test if there is a route
-        # if Rails.application.routes.url_for(controller: @controller.controller_path, action: 'destroy', only_path: true)
+    routes = Rails.application.routes.set.routes.inject({}) do |acc, r|
+      acc[r.defaults[:controller]] ||= {}
+      acc[r.defaults[:controller]][r.defaults[:action]] = true
+      acc
+    end
 
+    klass.controller_class.action_methods.each do |action|
+      if const_defined?("StandardAPI::TestCase::#{action.capitalize}Tests") && routes[klass.controller_class.controller_path][action]
         klass.include("StandardAPI::TestCase::#{action.capitalize}Tests".constantize)
       end
     end
@@ -55,28 +61,47 @@ module StandardAPI::TestCase
       validators = self.class.model.validators_on(attribute)
     end
   end
-    
-  def normalize_attribute(attribute, value)
-    validators = self.class.model.validators_on(attribute)
-    value
+
+  def normalizers
+    self.class.instance_variable_get('@normalizers')
+  end
+
+  def normalize_attribute(record, attribute, value)
+    if normalizers[self.class.model] && normalizers[self.class.model][attribute]
+      b = normalizers[self.class.model][attribute]
+      b.arity == 2 ? b.call(record, value) : b.call(value)
+    else
+      # validators = self.class.model.validators_on(attribute)
+      value
+    end
   end
     
-  def normalize_to_json(attribute, value)
-    value = normalize_attribute(attribute, value)
+  def normalize_to_json(record, attribute, value)
+    value = normalize_attribute(record, attribute, value)
       
     return nil if value.nil?
 
     if model.column_types[attribute].is_a?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Decimal)
-      "#{value}"
-    elsif model.column_types[attribute].is_a?(ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter)
-      value.to_datetime.utc.iso8601.gsub(/\+00:00$/, 'Z')
+      "#{value.to_f}"
+    # elsif model.column_types[attribute].is_a?(ActiveRecord::AttributeMethods::TimeZoneConversion::TimeZoneConverter)
+      # value.to_datetime.utc.iso8601.gsub(/\+(00:00|UTC)$/, 'Z')
+      # value.as_json
     else
-      value
+      value.as_json
     end
   end
 
+  def view_attributes(record)
+    return [] if record.nil?
+    record.attributes.select { |x| !@controller.send(:excludes_for, record.class).include?(x.to_sym) }
+  end
+
   module ClassMethods
-    
+
+    def self.extended(klass)
+      klass.instance_variable_set('@normalizers', {})
+    end
+
     def include_filter_tests
       model.instance_variable_get('@filters').each do |filter|
         next if filter[1].is_a?(Proc) # Custom filter
@@ -120,6 +145,10 @@ module StandardAPI::TestCase
 
     def model=(val)
       @model = val
+      filters = val.attribute_names
+      orders = val.attribute_names
+      includes = val.reflect_on_all_associations.map(&:name)
+      @model
     end
 
     def model
@@ -140,6 +169,13 @@ module StandardAPI::TestCase
       end
     end
 
+    def normalize(*attributes, &block)
+      attributes.each do |attribute|
+        @normalizers[model] ||= {}
+        @normalizers[model][attribute] = block
+      end
+    end
+
   end
 
 end

data/lib/standard_api/views/application/_record.json.jbuilder

@@ -0,0 +1,36 @@
+record.attributes.each do |name, value|
+  # Skip if attribute is included in excludes
+  next if defined?(excludes) && excludes[record.model_name.singular].try(:find) { |x| x.to_s = name.to_s }
+  json.set! name, value
+end
+
+includes.each do |inc, subinc|
+  association = record.class.reflect_on_association(inc)
+  if association && association.klass < ActiveRecord::Base
+    json.set! inc do
+      collection = [:has_many, :has_and_belongs_to_many].include?(association.macro)
+
+      partial = if lookup_context.exists?(association.klass.model_name.element, controller_name)
+        association.klass.model_name.element
+      else
+        'record'
+      end
+
+      if collection
+        json.array! record.send(inc), partial: partial, as: :record, locals: { includes: subinc }
+      else
+        if record.send(inc).nil?
+          json.set! association.klass.model_name.element, nil
+        else
+          json.partial! partial, record: record.send(inc), includes: subinc
+        end
+      end
+    end
+  else
+    json.set! inc, record.send(inc)
+  end
+end
+
+if !record.errors.blank?
+  json.set! 'errors', record.errors.to_h
+end

data/lib/standard_api/views/application/index.json.jbuilder

@@ -1,3 +1,3 @@
-models = @records if !models
+records = @records if !records
 
-json.array! models, partial: 'application/model', as: :model, includes: includes
+json.array! models, partial: 'application/record', as: :record, includes: includes

data/lib/standard_api/views/application/schema.json.jbuilder

@@ -0,0 +1,30 @@
+mapping = {
+    'timestamp without time zone' => 'datetime',
+    'time without time zone' => 'datetime',
+    'text' => 'string',
+    'json' => 'hash',
+    'integer' => 'integer',
+    'character varying(255)' => 'string',
+    'character varying(128)' => 'string',
+    'character varying(50)' => 'string',
+    'character varying' => 'string',
+    'jsonb' => 'hash',
+    'inet' => 'string', #TODO: should be inet
+    'hstore' => 'hash',
+    'date' => 'datetime',
+    'numeric(16,2)' => 'decimal',
+    'numeric' => 'decimal',
+    'double precision' => 'decimal',
+    'ltree' => 'string',
+    'boolean' => 'boolean',
+    'geometry' => 'hash'
+}
+
+model.columns.each do |column|
+  json.set! column.name, {
+    type: mapping[column.sql_type],
+    primary_key: column.name == model.primary_key,
+    null: column.null,
+    array: column.array
+  }
+end

data/lib/standard_api/views/application/show.json.jbuilder

@@ -1,3 +1,3 @@
-model = @record if !model
+record = @record if !record
 
-json.partial! 'application/model', model: model, includes: includes
+json.partial! 'application/model', record: record, includes: includes

data/lib/standard_api.rb

@@ -19,9 +19,22 @@ module StandardAPI
 
   def self.included(klass)
     klass.hide_action :current_mask
-    klass.helper_method :includes, :orders
+    klass.helper_method :includes, :orders, :model
     klass.prepend_view_path(File.join(File.dirname(__FILE__), 'standard_api', 'views'))
+    klass.extend(ClassMethods)
   end
+  
+  def ping
+    render :text => 'pong'
+  end
+
+  def tables
+    controllers = Dir[Rails.root.join('app/controllers/*_controller.rb')].map{ |path| path.match(/(\w+)_controller.rb/)[1].camelize+"Controller" }.map(&:safe_constantize)
+    controllers.select! { |c| c.ancestors.include?(self.class) && c != self.class }
+    controllers.map!(&:model).compact!.map!(&:table_name)
+    
+    render json: controllers
+  end  
 
   def index
     @records = resources.limit(params[:limit]).offset(params[:offset]).sort(orders)
@@ -66,11 +79,19 @@ module StandardAPI
     @current_mask ||= {}
   end
 
+  module ClassMethods
+    
+    def model
+      return @model if defined?(@model)
+      @model = name.sub(/Controller\z/, '').singularize.camelize.safe_constantize
+    end
+
+  end
+  
   private
 
   def model
-    return @model if defined?(@model)
-    @model = self.class.name.sub(/Controller\z/, '').singularize.camelize.constantize
+    self.class.model
   end
 
   def model_params
@@ -85,6 +106,19 @@ module StandardAPI
     self.send "#{model.model_name.singular}_orders"
   end
 
+  def excludes_for(klass)
+    if defined?(ApplicationHelper) && ApplicationHelper.instance_methods.include?(:excludes)
+       excludes = Class.new.send(:include, ApplicationHelper).new.excludes.with_indifferent_access
+       excludes.try(:[], klass.model_name.singular) || []
+    else
+      []
+    end
+  end
+
+  def model_excludes
+    excludes_for(model)
+  end
+
   def resources
     model.filter(params[:where]).where(current_mask[model.table_name])
   end
@@ -94,7 +128,11 @@ module StandardAPI
   end
 
   def orders
-    @orders ||= params[:order]
+    @orders ||= StandardAPI::Orders.sanitize(params[:order], model_orders)
+  end
+
+  def excludes
+    @excludes ||= model_excludes
   end
 
   # Used in #calculate

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: standardapi
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.0.7
 platform: ruby
 authors:
 - James Bracy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-06 00:00:00.000000000 Z
+date: 2015-09-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord-sort
@@ -198,8 +198,9 @@ files:
 - lib/standard_api/test_case/index_tests.rb
 - lib/standard_api/test_case/show_tests.rb
 - lib/standard_api/test_case/update_tests.rb
-- lib/standard_api/views/application/_model.json.jbuilder
+- lib/standard_api/views/application/_record.json.jbuilder
 - lib/standard_api/views/application/index.json.jbuilder
+- lib/standard_api/views/application/schema.json.jbuilder
 - lib/standard_api/views/application/show.json.jbuilder
 homepage: https://github.com/waratuman/standardapi
 licenses:

data/lib/standard_api/views/application/_model.json.jbuilder

@@ -1,32 +0,0 @@
-model.attributes.each do |name, value|
-  json.set! name, value
-end
-
-includes.each do |inc, subinc|
-  association = model.class.reflect_on_association(inc)
-  if association.klass < ActiveRecord::Base
-    json.set! inc do
-      collection = [:has_many, :has_and_belongs_to_many].include?(association.macro)
-
-      partial = if lookup_context.exists?(association.klass.model_name.element, controller_name)
-        # [controller_name, association.klass.model_name.element].join('/')
-        association.klass.model_name.element
-      else
-        # 'application/model'
-        'model'
-      end
-
-      if collection
-        json.array! model.send(inc), partial: partial, as: :model, locals: { includes: subinc }
-      else
-        json.partial! partial, model: model.send(inc), includes: subinc
-      end
-    end
-  else
-    json.set! inc, model.send(inc)
-  end
-end
-
-if !model.errors.blank?
-  json.set! 'errors', model.errors.to_h
-end