is_listable 0.0.4

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/CHANGELOG

@@ -0,0 +1,5 @@
+== 0.0.3
+
+Added the ability to add permalinks with is_listable. Before this version, it would have conflicted since it's looking
+for the id. If you are calling, for example  Post.find_by_permalink() this would be an issue. So what you can do now is this:
+is_listable :permalink => "my_permalink_attribute"

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Michael van Rooijen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,176 @@
+= Is Listable
+
+"Is Listable" is a gem that provides a way to implement a simple listing method by using generated view helpers to create up and down buttons.
+This will allow you to very quickly get the "Move Up" and "Move Down" button functionality to move your database records up and down in order. 
+
+This plugin depends on the acts_as_list plugin. I have created a gem version out of it for convenience when installing this gem.
+
+== Installation
+
+=== Add Repository Source(s)
+
+  gem sources -a http://gemcutter.org
+  gem sources -a http://gems.github.com
+
+=== Gem
+
+  # Gem Cutter
+  sudo gem install is_listable
+
+  # GitHub
+  sudo gem install meskyanichi-is_listable
+
+=== Plugin
+
+  ./script/plugin install git://github.com/meskyanichi/is_listable.git
+
+
+== Simple Setup
+
+==== Initializing the gems inside "environment.rb"
+
+  # For GemCutter Version
+  config.gem "is_listable",   :lib => "is_listable",  :source => 'http://gemcutter.org'
+  config.gem "acts_as_list",  :lib => "acts_as_list", :source => 'http://gemcutter.org'
+  
+  # For GitHub Version
+  config.gem "meskyanichi-is_listable",   :lib => "is_listable",  :source => 'http://gems.github.com'
+  config.gem "acts_as_list",  :lib => "acts_as_list", :source => 'http://gemcutter.org'
+
+==== PostModel
+  class Post < ActiveRecord::Base
+    acts_as_list
+  end
+
+==== PostsController
+  class PostsController < ApplicationController
+    is_listable
+  end
+
+==== PostsController#index
+  <table>
+    <tr>
+      <th colspan="2">Position</th>
+      <th>Name</th>
+    </tr>
+    <% @posts.each do |post| %>
+    <tr>
+      <td><%= up_button_for_posts(post)</td>
+      <td><%= down_button_for_posts(post)</td>
+      <td><%= post.name %></td>
+     </tr>
+     <% end %>
+  </table>
+
+This is basically all it takes to already get the gems working their magic.
+This will by default assume the posts table in the database has a "position" column which will determine the records position.
+
+
+== Additional Options
+
+Here's what additional options you can pass to the methods provided by the Is Listable gem.
+
+=== is_listable
+
+The is_listable method takes a hash of options. These are the following options you can provide:
+
+- :column			(default: 'position')
+- :controller		(default: the invoked methods' controller name)
+- :model			(default: the invoked methods' controller name, pluralized and camelcased)
+- :scope			(default: nil)
+- :redirect_to		(default: :back)
+
+View the implementation examples below:
+
+==== :column
+Specify the column name that represents the position in the database
+  class PostsController < ApplicationController
+    is_listable :column => 'position'
+  end
+
+
+==== :controller
+Specify the controller name which the is_listable should be invoked on.
+99% of the time you do not need to provide it, as the is_listable method knows what controller invoked it.
+  class PostsController < ApplicationController
+    is_listable :controller => "posts"
+  end
+
+
+==== :model
+Specify the model name which the is_listable should be invoked on.
+By default it will try to use (in this case) the Post model, since it's the singular and camelcased "posts".
+If Post is not the model you wish to the PostController make listable, just provide the :model hash value of the
+model you would like to sort.
+  class PostsController < ApplicationController
+    is_listable :model => "Post"
+  end
+
+
+==== :scope
+Pass in an ActiveRecord object that's associated to the model.
+It is mainly to prevent user's from haxing the web app and then updating
+other users' record position. So this is a very simple solution that'll prevent it from happening.
+  class PostsController < ApplicationController
+    is_listable :scope => current_user
+  end
+
+
+==== :redirect_to
+This option will allow you to specify a location to redirect to after the sort process has completed.
+By default it will redirect back to the page the request came from.
+  class PostsController < ApplicationController
+    is_listable :redirect_to => {:controller => "posts", :action => "index"}
+  end
+
+
+==== :permalink
+Let's say that you are using permalinks to allow pretty URL's. This would normally conflict since is_listable only accepts
+objects as a parameter in the view helpers that are provided. However, the :permalink option will fix this problem! If you
+are using, for example, the plugin "permalink_fu" and let it handle the creation of permalinks, you will most likely have permalinks
+stored in the "permalink" attribute inside your database. If this is the case, you can let is_listable work together with it like so.
+Note: Of course, if the permalink attribute inside the database is called, for example, "perm", you just replace the string "permalink" with "perm".
+  class PostsController < ApplicationController
+    is_listable :permalink => "permalink"
+  end
+
+
+=== up_button_for_object and down_button_for_object
+
+Once the is_listable method is invoked on a controller, it will generate two view helpers which will be available to all views.
+This is a very simple implementation, and the arguments taken are similar to those of the link_to and button_to methods provided by Rails.
+
+  up_button_for_posts(post, options)
+
+The first argument you must provide, should be the ActiveRecord object that's, for example, currently inside a @objects.each loop.
+The second argument takes a hash of options. Like the link_to() and button_to() they will accept "url" and "html" attributes.
+
+  up_button_for_posts(post, {
+    :url	=> { :controller => 'posts , :action => 'position', :direction => 'higher', :id => post},
+    :html	=> { :id => "posts_up_button_#{post.id}", :class => "posts_up_button" }
+  })
+
+So like the example above, you can add any additional, or overwrite existing attributes/options inside the second argument as a hash.
+Note that, by default, the view helpers will automatically render out the id/class attributes on the html button tag the same as in the example above. So you can easily apply styles to the provided classes and perform javascript calls on these unique ids namings.
+
+  down_button_for_posts(post, {
+    :url	=> { :controller => 'posts , :action => 'position', :direction => 'lower', :id => post},
+    :html	=> { :id => "posts_down_button_#{post.id}", :class => "posts_down_button" }
+  })
+
+So the work is basically done unless you are trying to accomplish something a little more complex that the defaults do not provide.
+But, usually this is not the case and you can just call the simple method like so:
+
+  up_button_for_posts(post)
+
+However, what you might want to change frequently is the name/label of the button. By default the up_button_for_objects and the down_button_for_objects will either name the button "up" or "down" depending on which was called. To overwrite the defaults, you simply provide a name key/value of "name" like so:
+
+  up_button_for_posts(post, :name => "Move Up")
+
+This will change the "Up" label to "Move Up".
+
+
+
+== Copyright
+
+Copyright (c) 2009 Michael van Rooijen. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "is_listable"
+    gem.summary = "\"Is Listable\" is a gem that provides a way to implement a simple listing method by using generated view helpers to create up and down buttons."
+    gem.description = "This will allow you to very quickly get the \"Move Up\" and \"Move Down\" button functionality to move your database records up and down in order. "
+    gem.email = "meskyan@gmail.com"
+    gem.homepage = "http://github.com/meskyanichi/is_listable"
+    gem.authors = ["Michael van Rooijen"]
+    gem.add_dependency('acts_as_list')
+    gem.files.include 'lib/*' 
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "is_listable #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.4

data/init.rb

@@ -0,0 +1,2 @@
+require "is_listable"
+ActionController::Base.send :include, IsListable

data/is_listable.gemspec

@@ -0,0 +1,50 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{is_listable}
+  s.version = "0.0.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Michael van Rooijen"]
+  s.date = %q{2009-10-02}
+  s.description = %q{This will allow you to very quickly get the "Move Up" and "Move Down" button functionality to move your database records up and down in order. }
+  s.email = %q{meskyan@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "CHANGELOG",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "init.rb",
+     "is_listable.gemspec",
+     "lib/is_listable.rb",
+     "lib/is_listable.rb"
+  ]
+  s.homepage = %q{http://github.com/meskyanichi/is_listable}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{"Is Listable" is a gem that provides a way to implement a simple listing method by using generated view helpers to create up and down buttons.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<acts_as_list>, [">= 0"])
+    else
+      s.add_dependency(%q<acts_as_list>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<acts_as_list>, [">= 0"])
+  end
+end

data/lib/is_listable.rb

@@ -0,0 +1,143 @@
+module IsListable
+
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  
+  module ClassMethods
+    
+    # Is Listable
+    #
+    # Is Listable should be invoked inside a controller and takes a hash of options.
+    # This will generate a controller action, based on the name of the column in the database.
+    # If the column is named, for example "position", which is the default, then the action inside
+    # the controller will be defined as "position". What this also does is it provides two view helpers
+    # per controller. If you for example have a controller named "PostsController" then this will generate two
+    # view helpers, namely: "up_button_for_posts" and "down_button_for_posts". Both of them take two arguments, of which
+    # only the first is required, and asks for the post object for which the button should be generated.
+    #
+    # Example:
+    # up_button_for_posts(post)
+    # down_button_for_posts(post)
+    # 
+    # That's the bare minimum for getting the listability to work!
+    # By default, the button that will be rendered will already have id and class attributes embedded in them.
+    #
+    # The above examples would generate these id and class attribute name and values:
+    # 
+    # id => "posts_up_button_1", :class => "posts_up_button"
+    # id => "posts_down_button_1", :class => "posts_up_button"
+    #
+    # So this assists in easy button styling and applying javascript calls on.
+    # These attributes can be overwritten by adding options inside the hash
+    #
+    # up_button_for_posts(post, :url => {}, :html => {})
+    #
+    # Inside the :url hash attribute you may specify controller, action, id and any custom attributes you may like when using
+    # the button_to and link_to helper methods. As the :url hash attribute, you may also specify the :html hash attribute to 
+    # add additional or overwrite existing html attributes for the html button tag. 
+    def is_listable(options = {})
+      
+      # Options - Has default values.
+      # Can be overwritten by user through the hash-argument
+      options = {
+        :column       => 'position',
+        :controller   => controller_name,
+        :model        => controller_name.camelcase.singularize,
+        :scope        => nil,
+        :redirect_to  => :back,
+        :permalink    => nil
+      }.update(options)
+      
+      # Include the ActionView::Helpers inside of ActionController::Base
+      # This will enable html button parsing
+      ActionController::Base.send(:include, ActionView::Helpers)
+      
+      # This will create an action dynamically inside the corresponding controller
+      # which the view helpers will link to automatically.
+      define_method options[:column] do
+        if options[:scope].nil?
+          if params[:direction].eql?('higher')
+            if options[:permalink].nil?
+              Kernel.const_get(options[:model]).find(params[:id]).move_higher
+            else
+              Kernel.const_get(options[:model]).send("find_by_#{options[:permalink]}", params[:id]).move_higher
+            end
+          elsif params[:direction].eql?('lower')
+            if options[:permalink].nil?
+              Kernel.const_get(options[:model]).find(params[:id]).move_lower
+            else
+              Kernel.const_get(options[:model]).send("find_by_#{options[:permalink]}", params[:id]).move_lower
+            end
+          end
+        else
+          if params[:direction].eql?('higher')
+            if options[:permalink].nil?
+              options[:scope].send(options[:model].underscore.pluralize.to_sym).find(params[:id]).move_higher
+            else
+              options[:scope].send(options[:model].underscore.pluralize.to_sym).send("find_by_#{options[:permalink]}", params[:id]).move_higher
+            end
+          elsif params[:direction].eql?('lower')
+            if options[:permalink].nil?
+              options[:scope].send(options[:model].underscore.pluralize.to_sym).find(params[:id]).move_lower
+            else
+              options[:scope].send(options[:model].underscore.pluralize.to_sym).send("find_by_#{options[:permalink]}", params[:id]).move_lower
+            end
+          end
+        end
+        redirect_to(options[:redirect_to])
+      end
+      
+      # Defines the up_button_for_(@controller_name) method
+      # This method will be available inside all views inside the whole application
+      define_method "up_button_for_#{options[:controller]}" do |object, *method_options|
+        
+        # Set default options and overwrite the existing ones with
+        # possible user input
+        method_options = {
+          :name       => 'up',
+          :attribute  => :id,
+          :url        => { :controller => options[:controller], :action => options[:column], :id => object, :direction => 'higher' },
+          :html       => { :id => "#{options[:controller]}_up_button_#{object.id}", :class => "#{options[:controller]}_up_button" }
+        }.update(method_options.empty? ? {} : method_options.first)
+        
+
+        # Generate the up button
+        button_to(method_options[:name], method_options[:url], method_options[:html]) unless object.first?
+      end
+      
+      # Defines the down_button_for_(@controller_name) method
+      # This method will be available inside all views inside the whole application
+      define_method "down_button_for_#{options[:controller]}" do |object, *method_options|
+        
+        # Find the last position of the objects list and store it inside an instance variable
+        # This will prevent multiple queries from being executed when the method is invoked
+        # from inside a for/each loop. A simple form of variable caching to improve performance.
+        if options[:scope].nil?
+          @last_position ||= Kernel.const_get(options[:model]).last.send(options[:column].to_sym)
+        else
+          @last_position ||= options[:scope].send(options[:model].pluralize.underscore.to_sym).last.send(options[:column].to_sym)
+        end
+        
+        # Set default options and overwrite the existing ones with
+        # possible user input
+        method_options = {
+          :name => 'down',
+          :url  => { :controller => options[:controller], :action => options[:column], :id => object, :direction => 'lower' },
+          :html => { :id => "#{options[:controller]}_down_button_#{object.id}", :class => "#{options[:controller]}_down_button" }
+        }.update(method_options.empty? ? {} : method_options.first)
+        
+        # Generate the down button
+        unless object.send(options[:column]).eql?(@last_position)
+          button_to(method_options[:name], method_options[:url], method_options[:html]) 
+        end
+      end
+      
+      # Makes the methods available to the views
+      helper_method "up_button_for_#{options[:controller]}",
+                    "down_button_for_#{options[:controller]}"
+    end
+  end
+end
+
+ActionController::Base.send :include, IsListable

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: is_listable
+version: !ruby/object:Gem::Version 
+  version: 0.0.4
+platform: ruby
+authors: 
+- Michael van Rooijen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-02 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: acts_as_list
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: "This will allow you to very quickly get the \"Move Up\" and \"Move Down\" button functionality to move your database records up and down in order. "
+email: meskyan@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- CHANGELOG
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- init.rb
+- is_listable.gemspec
+- lib/is_listable.rb
+has_rdoc: true
+homepage: http://github.com/meskyanichi/is_listable
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: "\"Is Listable\" is a gem that provides a way to implement a simple listing method by using generated view helpers to create up and down buttons."
+test_files: []
+