make_resourceful 1.0.1 → 2.0.0.pre.beta

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b4d2696450977a5370e0ad8e968c56fd633b7276e7e7963505b7d7d22a47006c
+  data.tar.gz: 79a14f2c03df4ec188a88d0f50e10228f085bf2c2cb525133ffbbfdb17035923
+SHA512:
+  metadata.gz: a33582780d8b43b953b8bd0e2980549cee1d7c275083758aec2c6809776fa80b2890ad791fad0f27781300f0511efb046dd30a32377c93dc44e3eed4e56d6028
+  data.tar.gz: 053cfc6b27dcd4bfef4b98132eb39b338e153b72be3cb77f4bf970fd527f1b4a15e1e89aed30862f3fd1efcc62a5f38be3b56a9440826a28fb8210aa6bcb1288

data/Rakefile

@@ -1,6 +1,6 @@
 require 'rake'
-require 'rake/rdoctask'
-require 'spec/rake/spectask'
+require 'rdoc/task'
+require 'rspec/core/rake_task'
 
 desc 'Default: run specs.'
 task :default => :spec
@@ -8,13 +8,13 @@ task :default => :spec
 spec_files = Rake::FileList["spec/**/*_spec.rb"]
 
 desc "Run specs"
-Spec::Rake::SpecTask.new do |t|
-  t.spec_files = spec_files
-  t.spec_opts = ["-c"]
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = "spec/**/*_spec.rb"
+  t.rspec_opts = ["-c"]
 end
 
 desc "Generate code coverage"
-Spec::Rake::SpecTask.new(:coverage) do |t|
+RSpec::Core::RakeTask.new(:coverage) do |t|
   t.spec_files = spec_files
   t.rcov = true
   t.rcov_opts = ['--exclude', 'spec,/var/lib/gems']

data/VERSION

@@ -1 +1 @@
-1.0.1
+2.0.0-beta

data/lib/make_resourceful.rb

@@ -1,7 +1,7 @@
 
 class MakeResourcefulTie < Rails::Railtie
   initializer "my_railtie.configure_rails_initialization" do
-    require_relative 'resourceful/maker'
+    require File.join(File.dirname(__FILE__), 'resourceful/maker')
     ActionController::Base.extend Resourceful::Maker
   end
 end

data/lib/resourceful/builder.rb

@@ -30,6 +30,7 @@ module Resourceful
       @shallow_parent   = nil
       @custom_member_actions = []
       @custom_collection_actions = []
+      @permitted_params = []
     end
 
     # This method is only meant to be called internally.
@@ -41,7 +42,7 @@ module Resourceful
       apply_publish
 
       kontroller = @controller
-      
+
       Resourceful::ACTIONS.each do |action_named|
         # See if this is a method listed by #actions
         unless @ok_actions.include? action_named
@@ -51,28 +52,31 @@ module Resourceful
         end
       end
 
-      kontroller.hidden_actions.reject! &@ok_actions.method(:include?)
+      if kontroller.respond_to?(:hidden_actions) 
+        kontroller.hidden_actions.reject! &@ok_actions.method(:include?)
+      end
       kontroller.send :include, @action_module
-      
+
       merged_callbacks = kontroller.resourceful_callbacks.merge @callbacks
       merged_responses = kontroller.resourceful_responses.merge @responses
-      
+
+      kontroller.permitted_params = @permitted_params
       kontroller.resourceful_callbacks = merged_callbacks
       kontroller.resourceful_responses = merged_responses
       kontroller.made_resourceful = true
 
-      kontroller.parents = @parents
+      kontroller.parent_controllers = @parents
       kontroller.shallow_parent = @shallow_parent
       kontroller.model_namespace = @model_namespace
-      kontroller.before_filter :load_object, :only => (@ok_actions & SINGULAR_PRELOADED_ACTIONS) + @custom_member_actions
-      kontroller.before_filter :load_objects, :only => (@ok_actions & PLURAL_ACTIONS) + @custom_collection_actions
-      kontroller.before_filter :load_parent_object, :only => @ok_actions + @custom_member_actions + @custom_collection_actions
+      kontroller.before_action :load_object, :only => (@ok_actions & SINGULAR_PRELOADED_ACTIONS) + @custom_member_actions
+      kontroller.before_action :load_objects, :only => (@ok_actions & PLURAL_ACTIONS) + @custom_collection_actions
+      kontroller.before_action :load_parent_object, :only => @ok_actions + @custom_member_actions + @custom_collection_actions
     end
 
     # :call-seq:
     #   actions(*available_actions)
     #   actions :all
-    # 
+    #
     # Adds the default RESTful actions to the controller.
     #
     # If the only argument is <tt>:all</tt>,
@@ -108,25 +112,40 @@ module Resourceful
       available_actions.each { |action| @ok_actions << action.to_sym }
     end
     alias build actions
-    
+
     # :call-seq:
     #   member_actions(*available_actions)
-    # 
-    # Registers custom member actions which will use the load_object before_filter.
+    # Registers custom member actions which will use the load_object before_action.
     # These actions are not created, but merely registered for filtering.
     def member_actions(*available_actions)
       available_actions.each { |action| @custom_member_actions << action.to_sym }
     end
-    
+
     # :call-seq:
     #   collection_actions(*available_actions)
-    # 
-    # Registers custom collection actions which will use the load_objects before_filter.
+    #
+    # Registers custom collection actions which will use the load_objects before_action.
     # These actions are not created, but merely registered for filtering.
     def collection_actions(*available_actions)
       available_actions.each { |action| @custom_collection_actions << action.to_sym }
     end
 
+    # :call-seq:
+    #   permitted_params(*params_allowed)
+    #
+    # When using strong parameters, specifies which params are permitted
+    #
+    # If the only argument is <tt>:all</tt>,
+    # all parameters are permitted
+    def permitted_params(*params_permitted)
+      if params_permitted.first == :all
+        @permitted_params = params_permitted.first
+      else
+        @permitted_params = [] unless @permitted_params.is_a?(Array)
+        params_permitted.each { |param| @permitted_params << param.to_sym }
+      end
+    end
+
     # :call-seq:
     #   before(*events) { ... }
     #
@@ -148,11 +167,11 @@ module Resourceful
     # to the current object's title
     # for the show and edit actions.
     #
-    # Successive before blocks for the same action will be chained and executed 
+    # Successive before blocks for the same action will be chained and executed
     # in order when the event occurs.
     #
     # For example:
-    #    
+    #
     #   before :show, :edit do
     #     @page_title = current_object.title
     #   end
@@ -161,7 +180,7 @@ module Resourceful
     #     @side_bar = true
     #   end
     #
-    # These before blocks will both be executed for the show action and in the 
+    # These before blocks will both be executed for the show action and in the
     # same order as they were defined.
     def before(*events, &block)
       add_callback :before, *events, &block
@@ -230,7 +249,7 @@ module Resourceful
     #   end
     #
     # This is the same as
-    #     
+    #
     #   response_for :new do |format|
     #     format.html { render :action => 'edit' }
     #   end
@@ -277,8 +296,8 @@ module Resourceful
     #
     # Then GET /posts/12.yaml would render
     #
-    #   --- 
-    #   post: 
+    #   ---
+    #   post:
     #     title: Cool Stuff
     #     rendered_content: |-
     #       <p>This is a post.</p>
@@ -331,7 +350,7 @@ module Resourceful
         :only => [:show, :index]
       }.merge(Hash === formats.last ? formats.pop : {})
       raise "Must specify :attributes option" unless options[:attributes]
-      
+
       Array(options.delete(:only)).each do |action|
         @publish[action] ||= []
         formats.each do |format|
@@ -370,7 +389,7 @@ module Resourceful
         @shallow_parent = options[:shallow]
       end
     end
-    
+
     # Specifies a namespace for the resource model. It can be given as a
     # Module::NameSpace, 'Module::NameSpace' (in a string), or
     # 'module/name_space' (underscored form).
@@ -387,7 +406,7 @@ module Resourceful
     end
 
     private
-    
+
     def apply_publish
       @publish.each do |action, types|
         @responses[action.to_sym] ||= []
@@ -395,10 +414,10 @@ module Resourceful
       end
     end
 
-    def add_callback(type, *events, &block)    
+    def add_callback(type, *events, &block)
       events.each do |event|
         @callbacks[type][event.to_sym] ||= []
-        @callbacks[type][event.to_sym] << block        
+        @callbacks[type][event.to_sym] << block
       end
     end
   end

data/lib/resourceful/default/accessors.rb

@@ -51,7 +51,7 @@ module Resourceful
       # which provides a lot of flexibility
       # (see the documentation for current_model for details).
       def current_objects
-        @current_objects ||= current_model.find(:all)
+        @current_objects ||= current_model.all
       end
 
       # Calls current_objects and stores
@@ -183,7 +183,16 @@ module Resourceful
       # of the current object.
       # This is only meaningful for +create+ or +update+.
       def object_parameters
-        params[namespaced_model_name.underscore.tr('/', '_')]
+        if params.respond_to?(:permit) && self.class.permitted_params && params[:action].to_s != "new"
+          permitable_method = if self.class.permitted_params == :all
+            [:permit!]
+          else
+            [:permit, self.class.permitted_params]
+          end
+          params.require(namespaced_model_name.underscore.tr('/', '_')).send(*permitable_method)
+        else
+          params[namespaced_model_name.underscore.tr('/', '_')]
+        end
       end
 
       # Returns a list of the names of all the potential parents of the current model.
@@ -194,7 +203,7 @@ module Resourceful
       #
       # Note that the parents must be declared via Builder#belongs_to.
       def parent_names
-        self.class.parents
+        self.class.parent_controllers
       end
 
       # Returns true if an appropriate parent id parameter has been supplied.
@@ -333,7 +342,7 @@ module Resourceful
       # Assigns the current parent object, as given by parent_objects,
       # to its proper instance variable, as given by parent_name.
       #
-      # This is automatically added as a before_filter.
+      # This is automatically added as a before_action.
       # You shouldn't need to use it directly unless you're creating a new action.
       def load_parent_object
         instance_variable_set("@#{parent_name}", parent_object) if parent?
@@ -341,11 +350,11 @@ module Resourceful
       end
 
       # Renders a 422 error if no parent id is given.
-      # This is meant to be used with before_filter
+      # This is meant to be used with before_action
       # to ensure that some actions are only called with a parent id.
       # For example:
       #
-      #   before_filter :ensure_parent_exists, :only => [:create, :update]
+      #   before_action :ensure_parent_exists, :only => [:create, :update]
       #
       def ensure_parent_exists
         return true if parent?

data/lib/resourceful/maker.rb

@@ -11,14 +11,15 @@ module Resourceful
     def self.extended(base)
       base.class_attribute :resourceful_callbacks
       base.class_attribute :resourceful_responses
-      base.class_attribute :parents
+      base.class_attribute :parent_controllers
       base.class_attribute :shallow_parent
       base.class_attribute :model_namespace
       base.class_attribute :made_resourceful
-      
+      base.class_attribute :permitted_params
+
       base.resourceful_callbacks = {}
       base.resourceful_responses = {}
-      base.parents               = []
+      base.parent_controllers    = []
       base.model_namespace       = nil
       base.made_resourceful      = false
     end
@@ -53,7 +54,7 @@ module Resourceful
     #       current_object.current_user = current_user
     #     end
     #   end
-    # 
+    #
     def make_resourceful(options = {}, &block)
       # :stopdoc:
       include Resourceful::Base

data/spec/builder_spec.rb

@@ -39,8 +39,8 @@ describe Resourceful::Builder, " applied without any modification" do
     @kontroller.made_resourceful.should be_true
   end
 
-  it "should set load_parent_object as a before_filter for no actions" do
-    @kontroller.expects(:before_filter).with(:load_parent_object, :only => [])
+  it "should set load_parent_object as a before_action for no actions" do
+    @kontroller.expects(:before_action).with(:load_parent_object, :only => [])
     @builder.apply
   end
 end
@@ -67,8 +67,8 @@ describe Resourceful::Builder, " with some actions set" do
     (@kontroller.hidden_actions & @actions).should be_empty
   end
 
-  it "should set load_parent_object as a before_filter for the given actions" do
-    @kontroller.expects(:before_filter).with(:load_parent_object, :only => [:show, :index, :new, :create])
+  it "should set load_parent_object as a before_action for the given actions" do
+    @kontroller.expects(:before_action).with(:load_parent_object, :only => [:show, :index, :new, :create])
     @builder.apply
   end
 end

data/spec/serialize_spec.rb

@@ -1,37 +1,41 @@
-require File.dirname(__FILE__) + '/spec_helper'
+require_relative './spec_helper'
 
 describe Resourceful::Serialize, ".normalize_attributes" do
+  def expect_normalize(object)
+    expect(Resourceful::Serialize.normalize_attributes(object))
+  end
+
   it "should return nil if given nil" do
-    Resourceful::Serialize.normalize_attributes(nil).should be_nil
+    expect_normalize(nil).to be_nil
   end
 
   it "should return a basic hash if given a non-injectable attribute" do
-    Resourceful::Serialize.normalize_attributes(:foo).should == {:foo => nil}
-    Resourceful::Serialize.normalize_attributes(12).should == {12 => nil}
+    expect_normalize(:foo).to eq({:foo => nil})
+    expect_normalize(12).to eq({12 => nil})
   end
 
   it "should return a basic hash with a symbol key if given a string attribute" do
-    Resourceful::Serialize.normalize_attributes("foo").should == {:foo => nil}
+    expect_normalize("foo").to eq({:foo => nil})
   end
 
   it "should preserve hashes" do
-    Resourceful::Serialize.normalize_attributes({:foo => nil, :bar => nil, :baz => nil}).should ==
-      {:foo => nil, :bar => nil, :baz => nil}
-    Resourceful::Serialize.normalize_attributes({:foo => 3, :bar => 1, :baz => 4}).should ==
-      {:foo => 3, :bar => 1, :baz => 4}
-    Resourceful::Serialize.normalize_attributes({:foo => 3, :bar => 1, :baz => [:foo, :bar]}).should ==
-      {:foo => 3, :bar => 1, :baz => [:foo, :bar]}
+    expect_normalize({:foo => nil, :bar => nil, :baz => nil}).to eq({:foo => nil, :bar => nil, :baz => nil})
+    expect_normalize({:foo => 3, :bar => 1, :baz => 4}).to eq({:foo => 3, :bar => 1, :baz => 4})
+    expect_normalize({:foo => 3, :bar => 1, :baz => [:foo, :bar]}).to eq({:foo => 3, :bar => 1, :baz => [:foo, :bar]})
   end
 
   it "should merge injectable attributes into one big hash" do
-    Resourceful::Serialize.normalize_attributes([:foo, :bar, :baz]).should ==
-      {:foo => nil, :bar => nil, :baz => nil}
-    Resourceful::Serialize.normalize_attributes([:foo, :bar, {:baz => nil},
-                                                 :boom, {:bop => nil, :blat => nil}]).should ==
-      {:foo => nil, :bar => nil, :baz => nil, :boom => nil, :bop => nil, :blat => nil}
-    Resourceful::Serialize.normalize_attributes([:foo, :bar, {:baz => 12},
-                                                 :boom, {:bop => "foo", :blat => [:fee, :fi, :fo]}]).should ==
-      {:foo => nil, :bar => nil, :baz => 12, :boom => nil, :bop => "foo", :blat => [:fee, :fi, :fo]}
+    expect_normalize([:foo, :bar, :baz]).to eq({:foo => nil, :bar => nil, :baz => nil})
+    expect_normalize(
+      [:foo, :bar, {:baz => nil}, :boom, {:bop => nil, :blat => nil}]
+    ).to eq(
+           {:foo => nil, :bar => nil, :baz => nil, :boom => nil, :bop => nil, :blat => nil}
+         )
+    expect_normalize(
+      [:foo, :bar, {:baz => 12}, :boom, {:bop => "foo", :blat => [:fee, :fi, :fo]}]
+    ).to eq(
+           {:foo => nil, :bar => nil, :baz => 12, :boom => nil, :bop => "foo", :blat => [:fee, :fi, :fo]}
+         )
   end
 end
 
@@ -63,9 +67,9 @@ describe Array, " of serializable objects" do
 
   it "should follow deep attributes for #to_serializable" do
     @array.to_serializable([:fur, {:friend => :name}]).should ==
-      [{'fur' => 'brown',  'friend' => {'name' => 'rex'}},
+      [{'fur' => 'brown', 'friend' => {'name' => 'rex'}},
        {'fur' => 'yellow', 'friend' => {'name' => 'rover'}},
-       {'fur' => 'green',  'friend' => {'name' => 'fido'}}]
+       {'fur' => 'green', 'friend' => {'name' => 'fido'}}]
   end
 
   it "should raise an error if #serialize is called without the :attributes option" do
@@ -74,9 +78,9 @@ describe Array, " of serializable objects" do
 
   it "should serialize to a hash with a pluralized root for #serialize" do
     YAML.load(@array.serialize(:yaml, :attributes => [:fur, {:friend => :name}])).should ==
-      {"cats" => [{'fur' => 'brown',  'friend' => {'name' => 'rex'}},
+      {"cats" => [{'fur' => 'brown', 'friend' => {'name' => 'rex'}},
                   {'fur' => 'yellow', 'friend' => {'name' => 'rover'}},
-                  {'fur' => 'green',  'friend' => {'name' => 'fido'}}]}
+                  {'fur' => 'green', 'friend' => {'name' => 'fido'}}]}
   end
 
   it "should serialize to an XML document with a pluralized root for #serialize(:xml, ...)" do
@@ -92,7 +96,7 @@ describe Array, " of serializable objects" do
   end
 end
 
-describe ActiveRecord::Base, " with a few attributes and an association" do
+describe ActiveModel::Base, " with a few attributes and an association" do
   before :each do
     @person = stub_model("Person")
     @party_hat = stub_model("PartyHat")
@@ -124,7 +128,7 @@ describe ActiveRecord::Base, " with a few attributes and an association" do
     doc = REXML::Document.new(@model.serialize(:xml, :attributes => [:name, :eye_color, {:party_hat => :pattern}]),
                               :ignore_whitespace_nodes => :all)
     doc.root.name.should == "person"
-    doc.root.children.find { |e| e.name == "name"      }.text.should == "joe"
+    doc.root.children.find { |e| e.name == "name" }.text.should == "joe"
     doc.root.children.find { |e| e.name == "eye-color" }.text.should == "blue"
 
     hat = doc.root.children.find { |e| e.name == "party-hat" }

metadata

@@ -1,25 +1,25 @@
 --- !ruby/object:Gem::Specification
 name: make_resourceful
 version: !ruby/object:Gem::Version
-  version: 1.0.1
-  prerelease: 
+  version: 2.0.0.pre.beta
 platform: ruby
 authors:
-- Hampton Catlin
-autorequire: 
+- Hampton Lintorn-Catlin
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2012-02-23 00:00:00.000000000Z
+date: 2024-06-26 00:00:00.000000000 Z
 dependencies: []
-description: ! '      Take back control of your Controllers. Make them awesome. Make
-  them sleek. Make them resourceful.
-
-'
+description: "      Take back control of your Controllers. Make them awesome. Make
+  them sleek. Make them resourceful.\n"
 email: hcatlin@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- README.rdoc
+- Rakefile
+- VERSION
 - lib/make_resourceful.rb
 - lib/resourceful/base.rb
 - lib/resourceful/builder.rb
@@ -45,9 +45,6 @@ files:
 - lib/resourceful/maker.rb
 - lib/resourceful/response.rb
 - lib/resourceful/serialize.rb
-- Rakefile
-- Readme.rdoc
-- VERSION
 - spec/accessors_spec.rb
 - spec/actions_spec.rb
 - spec/base_spec.rb
@@ -61,27 +58,25 @@ files:
 - spec/urls_spec.rb
 homepage: http://github.com/hcatlin/make_resourceful
 licenses: []
-post_install_message: 
+metadata: {}
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.6
-signing_key: 
-specification_version: 3
+rubygems_version: 3.5.3
+signing_key:
+specification_version: 4
 summary: An elegant, structured way to build ActionPack Controllers
 test_files:
 - spec/accessors_spec.rb