effective_resources 0.3.5 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b018fe0f5e92d239f3139ac0eb959167099ee33f
-  data.tar.gz: 2459f02e66bfabf218e2aa532d18fae10fdf910f
+  metadata.gz: 1c0486c174dd667b0157db3c09422b990ae5145d
+  data.tar.gz: 6c066a0c0ad0b9bfeabece6aad26b005db39a269
 SHA512:
-  metadata.gz: 75db72dc613e30bcb488620e2dc15d900ae8dd8cabc6dca51a3ec100d55385e339c353667438a7bb03d9e1518837eb3b9038d9c01fa22cecb6734087cb22fe3e
-  data.tar.gz: ea6d9ff7eb2a2c63dc7a84462387d490564e13038db5a6984a23ce6d75be06f577cdf7bb7bfaa1bd45b90fc2320ddefcb1db14cbde009a861a7620403569d079
+  metadata.gz: fb3b59b6125d11e74dc7699b6b11f78c7e5731bee9c0b8fc86380317acca67284773d075caa0a6978f184b3adec73063293883665693667516edf9a303e4e327
+  data.tar.gz: af797ee70b12863d379b7a7e7a404353791bf1b76d08aa4e3dff22a80ba9839b8d27cc6ef75ad5fa8dfb372fb4aa9e9321f288baaac47258466f78dcf278e741

data/README.md

@@ -36,8 +36,15 @@ class PostsController < ApplicationController
 
   protected
 
+  # If it's a Hash of attributes, the controller will call .where(attributes)
+  # and the attributes will be used to initialize the datatable on index
+  #
+  # If it's an ActiveRecord scope, or symbol, we initialize a datatable with {resource_scope: true}
+  # and leave it as a TODO for the datatable to do the right thin .
   def post_scope
-    {client_id: current_user.client_id} # Or a symbol
+    {client_id: current_user.client_id}
+    # Post.where(client_id: current_user.client_id)
+    # :approved
   end
 
   def post_params

data/app/controllers/concerns/effective/crud_controller.rb

@@ -12,10 +12,42 @@ module Effective
         define_method(action) do
           self.resource ||= resource_class.find(params[:id])
 
-          @page_title ||= resource.to_s
           EffectiveResources.authorized?(self, action, resource)
+
+          if (request.post? || request.patch? || request.put?)
+            raise "expected @#{resource_name} to respond to #{action}!" unless resource.respond_to?("#{action}!")
+
+            begin
+              raise 'exception' unless resource.send("#{action}!")
+
+              flash[:success] = "Successfully #{action}#{action.to_s.end_with?('e') ? 'd' : 'ed'} #{resource_human_name}"
+              redirect_back fallback_location: resource_redirect_path
+            rescue => e
+              flash.now[:danger] = "Unable to #{action} #{resource_human_name}: #{resource.errors.full_messages.to_sentence.presence || e.message}"
+
+              referer = request.referer.to_s
+
+              if referer.end_with?(send(effective_resource.edit_path, resource))
+                @page_title ||= "Edit #{resource}"
+                render :edit
+              elsif referer.end_with?(send(effective_resource.new_path))
+                @page_title ||= "New #{resource_name.titleize}"
+                render :new
+              else
+                @page_title ||= resource.to_s
+                flash[:danger] = flash.now[:danger]
+
+                if referer.present? && (Rails.application.routes.recognize_path(URI(referer).path) rescue false)
+                  redirect_back fallback_location: resource_redirect_path
+                else
+                  redirect_to(resource_redirect_path)
+                end
+              end
+            end
+          end
         end
       end
+
     end
 
     def index
@@ -102,7 +134,7 @@ module Effective
       when 'Save'               ; send(effective_resource.edit_path, resource)
       when 'Save and Continue'  ; send(effective_resource.index_path)
       when 'Save and Add New'   ; send(effective_resource.new_path)
-      else send(effective_resource.show_path, resource)
+      else send((effective_resource.show_path(check: true) || effective_resource.edit_path), resource)
       end
     end
 
@@ -147,9 +179,14 @@ module Effective
           effective_resource.klass
         else
           case (resource_scope = send(resource_scope_method_name))
-          when Hash   ; effective_resource.klass.where(resource_scope)
-          when Symbol ; effective_resource.klass.send(resource_scope)
-          when nil    ; effective_resource.klass
+          when ActiveRecord::Relation
+            effective_resource.relation.merge(resource_scope)
+          when Hash
+            effective_resource.klass.where(resource_scope)
+          when Symbol
+            effective_resource.klass.send(resource_scope)
+          when nil
+            effective_resource.klass
           else
             raise "expected #{resource_scope_method_name} to return a Hash or Symbol"
           end
@@ -161,6 +198,7 @@ module Effective
       return {} unless resource_scope_method_name.present?
 
       case (resource_scope = send(resource_scope_method_name))
+      when ActiveRecord::Relation ; {resource_scope: true}
       when Hash   ; resource_scope
       when Symbol ; {resource_scope: true}
       when nil    ; {}

data/app/models/effective/resources/attributes.rb

@@ -11,16 +11,19 @@ module Effective
       end
 
       # All attributes from the klass, sorted as per attributes block.
-      # Does not include :id, :created_at, :updated_at
-      def klass_attributes
+      # Does not include :id, :created_at, :updated_at unless all is passed
+      def klass_attributes(all: false)
         attributes = (klass.new().attributes rescue nil)
         return [] unless attributes
 
-        attributes = (attributes.keys - [klass.primary_key, 'created_at', 'updated_at'] - belong_tos.map { |reference| reference.foreign_key }).map do |att|
+        names = attributes.keys - belong_tos.map { |reference| reference.foreign_key }
+        names = names - [klass.primary_key, 'created_at', 'updated_at'] unless all
+
+        attributes = names.map do |name|
           if klass.respond_to?(:column_for_attribute) # Rails 4+
-            Effective::Attribute.new(att, klass.column_for_attribute(att).type)
+            Effective::Attribute.new(name, klass.column_for_attribute(name).type)
           else
-            Effective::Attribute.new(att, klass.columns_hash[att].type)
+            Effective::Attribute.new(name, klass.columns_hash[name].type)
           end
         end
 

data/app/models/effective/resources/init.rb

@@ -12,8 +12,10 @@ module Effective
           _klass_by_name(input)
         when ActiveRecord::Relation
           input.klass
+        when (ActiveRecord::Reflection::AbstractReflection rescue :nil)
+          ((input.klass rescue nil).presence || _klass_by_name(input.class_name)) unless input.options[:polymorphic]
         when ActiveRecord::Reflection::MacroReflection
-          input.klass unless input.options[:polymorphic]
+          ((input.klass rescue nil).presence || _klass_by_name(input.class_name)) unless input.options[:polymorphic]
         when ActionDispatch::Journey::Route
           _klass_by_name(input.defaults[:controller])
         when Class
@@ -42,6 +44,8 @@ module Effective
             return klass
           end
         end
+
+        nil
       end
 
       def _initialize_relation(input)

data/app/models/effective/resources/naming.rb

@@ -4,7 +4,7 @@ module Effective
       SPLIT = /\/|::/  # / or ::
 
       def name # 'post'
-        @name ||= (klass.try(:name).to_s.split(SPLIT).last || '').singularize.downcase
+        @name ||= (klass.try(:name).to_s.split(SPLIT).last || '').singularize.underscore
       end
 
       def plural_name # 'posts'

data/app/models/effective/resources/relation.rb

@@ -186,11 +186,22 @@ module Effective
             .pluck(klass.primary_key)
         elsif association.macro == :has_many && association.options[:through].present?
           key = sql_column(klass.primary_key)
-          values = relation.pluck(association.source_reflection.klass.primary_key).uniq.compact
 
-          keys = association.through_reflection.klass
-            .where(association.source_reflection.foreign_key => values)
-            .pluck(association.through_reflection.foreign_key)
+          if association.source_reflection.options[:polymorphic]
+            reflected_klass = association.klass
+          else
+            reflected_klass = association.source_reflection.klass
+          end
+
+          values = relation.pluck(reflected_klass.primary_key).uniq.compact
+
+          scope = association.through_reflection.klass.where(association.source_reflection.foreign_key => values)
+
+          if association.source_reflection.options[:polymorphic]
+            scope = scope.where(association.source_reflection.foreign_type => reflected_klass.name)
+          end
+
+          keys = scope.pluck(association.through_reflection.foreign_key)
         elsif association.macro == :has_many
           key = sql_column(klass.primary_key)
           keys = relation.pluck(association.foreign_key)

data/app/models/effective/resources/sql.rb

@@ -20,6 +20,7 @@ module Effective
       end
 
       def max_id
+        return 999999 unless klass.respond_to?(:unscoped)
         @max_id ||= klass.unscoped.maximum(klass.primary_key).to_i
       end
 

data/lib/effective_resources/version.rb

@@ -1,3 +1,3 @@
 module EffectiveResources
-  VERSION = '0.3.5'.freeze
+  VERSION = '0.3.6'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: effective_resources
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.6
 platform: ruby
 authors:
 - Code and Effect
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-10 00:00:00.000000000 Z
+date: 2017-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails