effective_resources 0.9.5 → 0.10.0

data/app/models/concerns/effective_resource.rb

@@ -0,0 +1,24 @@
+# EffectiveResource
+#
+# Mark your model with 'effective_resource'
+
+module EffectiveResource
+  extend ActiveSupport::Concern
+
+  module ActiveRecord
+    def effective_resource(options = nil, &block)
+      return @_effective_resource unless block_given?
+
+      include ::EffectiveResource
+      @_effective_resource = Effective::Resource.new(self, &block)
+    end
+  end
+
+  included do
+  end
+
+  module ClassMethods
+  end
+
+end
+

data/app/models/effective/model_reader.rb

@@ -0,0 +1,29 @@
+module Effective
+  class ModelReader
+    DATATYPES = [:binary, :boolean, :date, :datetime, :decimal, :float, :hstore, :inet, :integer, :string, :text]
+
+    attr_reader :attributes
+
+    def initialize(&block)
+      @attributes = {}
+      instance_exec(&block)
+    end
+
+    def method_missing(m, *args, &block)
+      raise "#{m} has already been defined" if attributes[m]
+
+      if m == :timestamps
+        attributes[:created_at] = [:datetime]
+        attributes[:updated_at] = [:datetime]
+        return
+      end
+
+      unless DATATYPES.include?(args.first)
+        raise "expected first argument to be a datatype. Try name :string"
+      end
+
+      attributes[m] = args
+    end
+
+  end
+end

data/app/models/effective/resource.rb

@@ -3,18 +3,22 @@ module Effective
     include Effective::Resources::Actions
     include Effective::Resources::Associations
     include Effective::Resources::Attributes
+    include Effective::Resources::Controller
     include Effective::Resources::Init
     include Effective::Resources::Instance
     include Effective::Resources::Forms
     include Effective::Resources::Klass
+    include Effective::Resources::Model
     include Effective::Resources::Naming
     include Effective::Resources::Paths
     include Effective::Resources::Relation
     include Effective::Resources::Sql
 
     # post, Post, Admin::Post, admin::Post, admin/posts, admin/post, admin/effective::post
-    def initialize(input, namespace: nil)
-      _initialize(input, namespace: namespace)
+    def initialize(input, namespace: nil, &block)
+      _initialize_input(input, namespace: namespace)
+      _initialize_model(&block) if block_given?
+      self
     end
 
     def to_s

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

@@ -5,8 +5,8 @@ module Effective
       # This was written for the Edit actions fallback templates and Datatables
       # Effective::Resource.new('admin/posts').routes[:index]
       def routes
-        @_routes ||= (
-          matches = [[namespace, plural_name].compact.join('/'), [namespace, name].compact.join('/')]
+        @routes ||= (
+          matches = [[namespace, plural_name].compact.join('/'.freeze), [namespace, name].compact.join('/'.freeze)]
 
           routes_engine.routes.routes.select do |route|
             matches.any? { |match| match == route.defaults[:controller] }
@@ -19,7 +19,7 @@ module Effective
       # Effective::Resource.new('effective/order', namespace: :admin)
       def routes_engine
         case class_name
-        when 'Effective::Order'
+        when 'Effective::Order'.freeze
           EffectiveOrders::Engine
         else
           Rails.application
@@ -30,7 +30,7 @@ module Effective
       # This will return empty for create, update and destroy
       def action_path_helper(action)
         return unless routes[action]
-        return (routes[action].name + '_path') if routes[action].name.present?
+        return (routes[action].name + '_path'.freeze) if routes[action].name.present?
       end
 
       # Effective::Resource.new('admin/posts').action_path(:edit, Post.last) => '/admin/posts/3/edit'
@@ -107,29 +107,29 @@ module Effective
 
       # Same as controller_path in the view
       def controller_path
-        [namespace, plural_name].compact * '/'
+        [namespace, plural_name].compact * '/'.freeze
       end
 
       private
 
       def is_member_route?(route)
-        (route.path.required_names || []).include?('id')
+        (route.path.required_names || []).include?('id'.freeze)
       end
 
       def is_collection_route?(route)
-        (route.path.required_names || []).include?('id') == false
+        (route.path.required_names || []).include?('id'.freeze) == false
       end
 
       def is_get_route?(route)
-        route.verb.to_s.include?('GET')
+        route.verb.to_s.include?('GET'.freeze)
       end
 
       def is_delete_route?(route)
-        route.verb.to_s.include?('DELETE')
+        route.verb.to_s.include?('DELETE'.freeze)
       end
 
       def is_post_route?(route)
-        ['POST', 'PUT', 'PATCH'].any? { |verb| route.verb == verb }
+        ['POST', 'PUT', 'PATCH'].freeze.any? { |verb| route.verb == verb }
       end
     end
   end

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

@@ -11,6 +11,11 @@ module Effective
         @belong_tos ||= klass.reflect_on_all_associations(:belongs_to)
       end
 
+      # author_id, post_id
+      def belong_tos_ids
+        belong_tos.map { |ass| (ass.options[:foreign_key] || "#{ass.name}_id").to_sym }
+      end
+
       def has_ones
         return [] unless klass.respond_to?(:reflect_on_all_associations)
         @has_ones ||= klass.reflect_on_all_associations(:has_one)

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

@@ -2,12 +2,34 @@ module Effective
   module Resources
     module Attributes
 
+      # This is the attributes as defined by ActiveRecord table
+      # { :name => [:string], ... }
       def attributes
-        (klass_attributes.presence || written_attributes.presence)
+        (klass_attributes.presence || model_attributes.presence)
       end
 
-      def attribute_names
-        attributes.map { |attribute| attribute.name }
+      # The attributes for each belongs_to
+      # { :client_id => [:integer], ... }
+      def belong_tos_attributes
+        belong_tos.inject({}) do |h, ass|
+          unless ass.foreign_key == 'site_id' && ass.respond_to?(:acts_as_site_specific)
+            h[ass.foreign_key.to_sym] = [:integer]
+          end; h
+        end
+      end
+
+      # This is the attributes as defined by the effective_resources do .. end block
+      # { :name => [:string, { permitted: false }], ... }
+      def model_attributes
+        model ? model.attributes : {}
+      end
+
+      # Used by effective_crud_controller to generate the permitted params
+      def permitted_attributes
+        id = {klass.primary_key.to_sym => [:integer]}
+        bts = belong_tos_ids.inject({}) { |h, ass| h[ass] = [:integer]; h }
+
+        id.merge(bts).merge(model_attributes)
       end
 
       # All attributes from the klass, sorted as per attributes block.
@@ -19,46 +41,37 @@ module Effective
         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|
+        attributes = names.inject({}) do |h, name|
           if klass.respond_to?(:column_for_attribute) # Rails 4+
-            Effective::Attribute.new(name, klass.column_for_attribute(name).type)
+            h[name.to_sym] = [klass.column_for_attribute(name).type]
           else
-            Effective::Attribute.new(name, klass.columns_hash[name].type)
-          end
+            h[name.to_sym] = [klass.columns_hash[name].type]
+          end; h
         end
 
-        sort_by_written_attributes(attributes)
+        sort_by_model_attributes(attributes)
       end
 
-      def belong_tos_attributes
-        belong_tos.map do |reference|
-          unless reference.foreign_key == 'site_id' && klass.respond_to?(:acts_as_site_specific)
-            Effective::Attribute.new(reference.foreign_key, :integer)
-          end
-        end.compact.sort
-      end
+      private
 
-      def written_attributes
-        _initialize_written if @written_attributes.nil?
-        @written_attributes
-      end
+      def sort_by_model_attributes(attributes)
+        return attributes unless model_attributes.present?
 
-      private
+        keys = model_attributes.keys
 
-      def sort_by_written_attributes(attributes)
-        attributes.sort do |a, b|
+        attributes.sort do |(a, _), (b, _)|
           index = nil
 
-          index ||= if written_attributes.include?(a) && written_attributes.include?(b)
-            written_attributes.index(a) <=> written_attributes.index(b)
-          elsif written_attributes.include?(a) && !written_attributes.include?(b)
+          index ||= if model_attributes.key?(a) && model_attributes.key?(b)
+            keys.index(a) <=> keys.index(b)
+          elsif model_attributes.key?(a) && !model_attributes.include?(b)
             -1
-          elsif !written_attributes.include?(a) && written_attributes.include?(b)
+          elsif !model_attributes.key?(a) && model_attributes.key?(b)
             1
           end
 
           index || a <=> b
-        end
+        end.to_h
       end
 
     end

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

@@ -0,0 +1,81 @@
+module Effective
+  module Resources
+    module Controller
+
+      # Used by effective_form_submit
+      # The actions we would use to commit. For link_to
+      # { 'Save': { action: :save }, 'Continue': { action: :save }, 'Add New': { action: :save }, 'Approve': { action: :approve } }
+      # Saves a list of commit actions...
+      def submits
+        {}.tap do |submits|
+          if (actions.find { |a| a == :create } || actions.find { |a| a == :update })
+            submits['Save'] = { action: :save, default: true }
+          end
+
+          if actions.find { |a| a == :index }
+            submits['Continue'] = { action: :save, redirect: :index, default: true }
+          end
+
+          if actions.find { |a| a == :new }
+            submits['Add New'] = { action: :save, redirect: :new, default: true }
+          end
+        end
+      end
+
+      def buttons
+        {}.tap do |buttons|
+          member_get_actions.each do |action| # default true means it will be overwritten by dsl methods
+            buttons[action.to_s.titleize] = { action: action, default: true }
+          end
+
+          (member_post_actions - crud_actions).each do |action| # default true means it will be overwritten by dsl methods
+            buttons[action.to_s.titleize] = { action: action, default: true }
+          end
+
+          member_delete_actions.each do |action|
+            buttons[action == :destroy ? 'Delete' : action.to_s.titleize] = { action: action, default: true }
+          end
+
+          if collection_get_actions.find { |a| a == :index }
+            buttons["All #{human_plural_name}".titleize] = { action: :index, default: true }
+          end
+
+          if collection_get_actions.find { |a| a == :new }
+            buttons["New #{human_name}".titleize] = { action: :new, default: true }
+          end
+
+          (collection_get_actions - crud_actions).each do |action|
+            buttons[action.to_s.titleize] = { action: action, default: true }
+          end
+        end
+      end
+
+      # This is the fallback for render_resource_actions when no actions are specified
+      # It is used by datatables
+      def resource_actions
+        {}.tap do |actions|
+          (member_get_actions & crud_actions).each do |action|
+            actions[action.to_s.titleize] = { action: action, default: true }
+          end
+
+          (member_get_actions - crud_actions).each do |action|
+            actions[action.to_s.titleize] = { action: action, default: true }
+          end
+
+          (member_post_actions - crud_actions).each do |action|
+            actions[action.to_s.titleize] = { action: action, default: true }
+          end
+
+          member_delete_actions.each do |action|
+            actions[action == :destroy ? 'Delete' : action.to_s.titleize] = { action: action, default: true }
+          end
+        end
+      end
+
+      def ons
+        {}
+      end
+
+    end
+  end
+end

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

@@ -2,57 +2,6 @@ module Effective
   module Resources
     module Forms
 
-      # Used by effective_form_submit
-      # The actions we would use to commit. For link_to
-      # { 'Save': { action: :save }, 'Continue': { action: :save }, 'Add New': { action: :save }, 'Approve': { action: :approve } }
-      # Saves a list of commit actions...
-      def submits
-        @submits ||= {}.tap do |submits|
-          if (actions.find { |a| a == :create } || actions.find { |a| a == :update })
-            submits['Save'] = { action: :save, default: true, class: 'btn btn-primary' }
-          end
-
-          (member_post_actions - crud_actions).each do |action| # default true means it will be overwritten by dsl methods
-            submits[action.to_s.titleize] = { action: action, default: true, class: 'btn btn-primary' }
-          end
-
-          if actions.find { |a| a == :index }
-            submits['Continue'] = { action: :save, default: true, redirect: :index }
-          end
-
-          if actions.find { |a| a == :new }
-            submits['Add New'] = { action: :save, default: true, redirect: :new }
-          end
-        end
-      end
-
-      # Here we look at all available (class level) member actions, see which ones apply to the current resource
-      # This feeds into the helper simple_form_submit(f)
-      # Returns a Hash of {'Save': {class: 'btn btn-primary'}, 'Approve': {class: 'btn btn-secondary'}}
-      def submits_for(obj, controller:)
-        submits.select do |commit, args|
-          args[:class] = args[:class].to_s
-
-          action = (args[:action] == :save ? (obj.new_record? ? :create : :update) : args[:action])
-
-          (args.key?(:if) ? obj.instance_exec(&args[:if]) : true) &&
-          (args.key?(:unless) ? !obj.instance_exec(&args[:unless]) : true) &&
-          EffectiveResources.authorized?(controller, action, obj)
-        end.transform_values.with_index do |opts, index|
-          if opts[:class].blank?
-            if index == 0
-              opts[:class] = 'btn btn-primary'
-            elsif defined?(EffectiveBootstrap)
-              opts[:class] = 'btn btn-secondary'
-            else
-              opts[:class] = 'btn btn-default'
-            end
-          end
-
-          opts.except(:action, :default, :if, :unless, :redirect)
-        end
-      end
-
       # Used by datatables
       def search_form_field(name, type = nil)
         case (type || sql_type(name))

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

@@ -4,12 +4,14 @@ module Effective
 
       private
 
-      def _initialize(input, namespace: nil)
-        @namespaces = (namespace.kind_of?(String) ? namespace.split('/') : Array(namespace)) if namespace
+      def _initialize_input(input, namespace: nil)
+        @initialized_name = input
 
         @model_klass = case input
         when String, Symbol
           _klass_by_name(input)
+        when Class
+          input
         when ActiveRecord::Relation
           input.klass
         when (ActiveRecord::Reflection::AbstractReflection rescue :nil)
@@ -19,14 +21,25 @@ module Effective
         when ActionDispatch::Journey::Route
           @initialized_name = input.defaults[:controller]
           _klass_by_name(input.defaults[:controller])
-        when Class
-          input
         when nil    ; raise 'expected a string or class'
         else        ; _klass_by_name(input.class.name)
         end
 
-        @relation = _initialize_relation(input)
-        @instance = input if (klass && input.instance_of?(klass))
+        if namespace
+          @namespaces = (namespace.kind_of?(String) ? namespace.split('/') : Array(namespace))
+        end
+
+        if input.kind_of?(ActiveRecord::Relation)
+          @relation = input
+        end
+
+        if input.kind_of?(ActiveRecord::Reflection::MacroReflection) && input.scope
+          @relation = klass.where(nil).merge(input.scope)
+        end
+
+        if klass && input.instance_of?(klass)
+          @instance = input
+        end
       end
 
       def _klass_by_name(input)
@@ -50,17 +63,6 @@ module Effective
         nil
       end
 
-      def _initialize_relation(input)
-        return nil unless klass && klass.respond_to?(:where)
-
-        case input
-        when ActiveRecord::Relation
-          input
-        when ActiveRecord::Reflection::MacroReflection
-          klass.where(nil).merge(input.scope) if input.scope
-        end || klass.where(nil)
-      end
-
       # Lazy initialized
       def _initialize_written
         @written_attributes = []