simple_restricted_attributes 1.0.0

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 [name of plugin creator]
+
+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

@@ -0,0 +1,260 @@
+SimpleRestrictedAttributes
+====================
+
+This simple_restricted_attributes plugin provides the capabilities to restrict attributes(fields)
+of db table's while add or update a record. It validate your attributes values before
+your validation stuff.
+
+Features
+========
+
+ - Provides four different ways of restriction on fields (i.e read_only, create_only, update_only and hidden)
+ - Restrict to add/modify values of particular attributes at model level while creating/updating a record.
+ - Restrict functionality perform at before validation.
+ - Able to set restriction on instance varibles also.
+
+
+
+
+*NOTE: You can try its more featured version(i.e restricted_attributes plugin) ONLY if you are using declarative_authorization plugin/gem. Find more information about that plugin on following link
+(More Info - https://github.com/gkathare/restricted_attributes)
+
+
+
+
+
+Method
+======
+has_restricted_attributes(options = {})
+  
+  This method accepts the options in a hash:
+    
+    1 :read_only            # In this you can add attributes to restrict from add/update the value.
+    			    # Access attributes values:  can read,  But can't add or modify
+                            # Format for single attribute -
+                            # :read_only => :name or :read_only => "name"
+                            # Format for array of attributes -
+                            # :read_only => [:name, :bio] or :read_only => ["name", "bio"]
+
+    2 :create_only          # In this you can add attributes to restrict from update the value.
+    			    # Access attributes values: can read and add,  But can't modify.
+                            # Format for single attribute -
+                            # :create_only => :name or :create_only => "name"
+                            # Format for array of attributes -
+                            # :create_only => [:name, :bio] or :create_only => ["name", "bio"]
+
+    3 :update_only          # In this you can add attributes to restrict from add the value.
+    			    # Access attributes values: can read and modify,  But can't add.
+                            # Format for single attribute -
+                            # :update_only => :name or :update_only => "name"
+                            # Format for array of attributes -
+                            # :update_only => [:name, :bio] or :update_only => ["name", "bio"]
+
+    4 :hidden_only          # In this you can add attributes to restrict from add/update the value.
+    			    # Mainly used with 'is_restricted?()' helper Method & instance Method to
+			    # check has a read access or not.
+			    # Access attributes values: can read,  But can't add or modify.
+			    # Format for single attribute -
+                            # :hidden_only => :name or :hidden_only => "name"
+                            # Format for array of attributes -
+                            # :hidden_only => [:name, :bio] or :hidden_only => ["name", "bio"]
+
+    5 :read_only_message    # validation message for read_only attributes
+                            # Format - :read_only_message => "blah blah"  (string type)
+                            # Default message - "is a read only attribute."
+
+    6 :create_only_message  # validation message for create_only attributes
+                            # Format - :create_only_message => "blah blah"  (string type)
+                            # Default message - "can't update, its permitted to create only."
+
+    7 :update_only_message  # validation message for update_only attributes
+                            # Format - :update_only_message => "blah blah"  (string type)
+                            # Default message - "can't add, its permitted to update only."
+
+    8 :hidden_only_message  # validation message for hidden_only attributes
+                            # Format - :hidden_only_message => "blah blah"  (string type)
+                            # Default message - "is a hidden attribute."
+
+
+
+======================================================================================================================
+------------------------------------------ Examples Set 1 ------------------------------------------------------------
+
+
+# Example 1 Simple one
+================================================================
+
+    class Post < ActiveRecord::Base
+        has_restricted_attributes :read_only => [:status],
+                            :create_only => [:title, :publish],
+                            :update_only => [:tags],
+			    :hidden_only => [:activated],
+                            :read_only_message => "is a read only attribute",
+                            :create_only_message => "can't update, its permitted to create only.",
+                            :update_only_message => "can't add, its permitted to update only."
+    end
+
+
+
+    So, the restricted attributes will be as shown in following table.
+    
+    #Post Model :
+
+    |-----------|-------------------------------------------------------------|
+    |           |( Read/Hidden Only ) |  ( Create Only )  |  (Update Only )   |
+    |           | :status /:activated | :title, :publish  |     :tags         |
+    |           |-------------------------------------------------------------|
+    |   Can ->  |   Create  |  Update | Create  | Update  | Create  | Update  |
+    |-----------|-----------|---------|-------------------|-------------------|
+    |   Any     |           |         |         |         |         |         |
+    |   User    |     NO    |    NO   |  YES    |   NO    |   NO    |  YES    |
+    |           |           |         |         |         |         |         |
+    ---------------------------------------------------------------------------
+
+    Console Output :
+    ---------------
+
+    >> post = Post.new(:status => true, :title => "New Title", :tags => "new, topic")
+    >> post.save
+    => false
+
+    >> post.errors
+    => #<OrderedHash {:status => ["is a read only attribute"], :tags=>["can't add, its permitted to update only."]}>
+
+    # for hidden attributes
+    >> post = Post.new(:activated => true)
+    >> post.save
+    => false
+
+    >> post.errors
+    => #<OrderedHash {:status => ["is a hidden attribute"]}>
+    OR
+    >> post.is_restricted?(:read, :activated)  # To check :activated field is restricted to read.
+    => true
+
+
+--------------------------------------------- End Examples Set 1 -----------------------------------------------------
+======================================================================================================================
+
+
+
+
+
+Helper Method & Instance Method ( For View & Controller files )
+===============================================================
+
+
+1 Helper Method `is_restricted?()` :
+------------------------------------
+
+    Syntax:
+    -------------------------------------------------
+    |   is_restricted?(Klass, action, field)        |
+    -------------------------------------------------
+
+     This method accepts 3 arguments :
+
+     1 Klass    # This is a mandatory & first argument of this method.
+                # Should be valid class (i.e Model Name), no String.
+                # Should be in constantize format
+                # Ex :  User ,  Post,  Comment
+
+     2 action   # This is a mandatory & second argument of this method.
+                # Valid actions : "create" or "update" or "read".
+                # Should be either in symbol or in string format
+                # Ex :  :create or :update or :read  or "create" or "update" or "read"
+
+     3 field    # This is a mandatory & third argument of this method.
+                # Should be valid attributes/field of that model or related db table.
+                # Should be either in symbol or in string format
+                # Ex :  :title or "title"
+
+
+
+2 Instance Method `is_restricted?()` :
+--------------------------------------
+
+    Syntax:
+    ----------------------------------------------
+    |    object.is_restricted?(action, field)    |
+    ----------------------------------------------
+
+     This method accepts 2 arguments :
+
+     1 action   # This is a mandatory & first argument of this method.
+                # Valid actions : "create" or "update" or "read".
+                # Should be either in symbol or in string format
+                # Ex :  :create or :update or :read  or "create" or "update" or "read"
+
+     2 field    # This is a mandatory & second argument of this method.
+                # Should be valid attributes/field of that model or related db table.
+                # Should be either in symbol or in string format
+                # Ex :  :title or "title"
+
+
+
+
+======================================================================================================================
+------------------------------------------ Examples Set 2 ------------------------------------------------------------
+
+
+
+# Example 1 ( Use of Helper Method )
+====================================
+
+    # /models/post.rb
+    class Post < ActiveRecord::Base
+        has_restricted_attributes :read_only => [:active],
+                            :create_only => [:title],
+                            :update_only => [:abuse],
+			    :read_only_message => "is a read only attribute"
+    end
+
+    So for this post class we can check its particular field is restricted or not.
+    (You can use this method in controller, view and helper file.)
+
+     ---------------------------------------------------
+     |      is_restricted?(Post, :update, :title)      |
+     ---------------------------------------------------
+
+        - return true(:title is restricted)
+
+
+
+
+# Example 2 ( Use of Instance Method )
+=======================================
+
+    # /models/post.rb
+    class Post < ActiveRecord::Base
+        has_restricted_attributes :read_only => [:active],
+                            :create_only => [:title],
+                            :update_only => [:abuse],
+			    :read_only_message => "is a read only attribute"
+    end
+
+    So for this post class we can check its particular field is restricted or not.
+
+    -----------------------------------------------------
+    |      post = Post.find(params[:id])                |
+    |      is_restricted?(:update, :title)              |
+    -----------------------------------------------------
+
+        - return true(:title is restricted)
+
+
+
+
+--------------------------------------------- End Examples Set 2 -----------------------------------------------------
+======================================================================================================================
+
+
+
+
+===========================================================================
+Easiest way to contact me(Ganesh Kathare):
+My email - kathare[dot]ganesh[at]gmail[dot]com (kathare.ganesh@gmail.com)
+===========================================================================
+
+Copyright (c) 2011 Ganesh Kathare, Navi Mumbai MH, India. released under the MIT license
+

data/Rakefile

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+
+PKG_FILES = FileList[
+  '[a-zA-Z]*',
+  'lib/**/*',
+  'test/**/*'
+]
+ 
+spec = Gem::Specification.new do |s|
+  s.name = "simple_restricted_attributes"
+  s.version = "1.0.0"
+  s.author = "Ganesh Kathare"
+  s.email = "kathare.ganesh@gmail.com"
+  s.homepage = "https://github.com/gkathare"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "Sharing simple_restricted_attributes"
+  s.files = PKG_FILES.to_a
+  s.require_path = "lib"
+  s.has_rdoc = false
+  s.extra_rdoc_files = ["README"]
+  s.description = <<EOF
+  This simple_restricted_attributes plugin/gem provides the capabilities to restrict attributes(fields) 
+  of db table's while add or update a record. It validate your attributes values before
+  your validation stuff.
+EOF
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_zip = true
+  pkg.need_tar = true
+end

data/init.rb

@@ -0,0 +1,3 @@
+# Include hook code here
+$:.unshift "#{File.dirname(__FILE__)}/lib"
+require 'simple_restricted_attributes'

data/lib/restricted/restricted_attrib.rb

@@ -0,0 +1,104 @@
+module RestrictedAttrib
+ 
+  ## Class Methods
+  module ClassMethods
+    def self.extended(base)
+       base.before_validation :check_for_restricted_values
+    end
+  end
+
+  ## Instance Methods
+  module InstanceMethods
+    # check the changed attributes of a class are restricted or not.
+    def check_for_restricted_values
+      
+      restrict_read_only = self.read_only
+      restrict_create_only = self.create_only
+      restrict_update_only = self.update_only
+      restrict_hidden_only = self.hidden_only
+      
+      # check for read only attributes
+      unless restrict_read_only.blank?
+        restrict_read_only.each do |ro|
+          if self.changed.include?(ro) || !eval("self.instance_variable_get :@#{ro}").blank?
+            self.errors.add(ro.humanize, self.read_only_message)
+          end
+        end
+      end
+
+      # check for create only attributes
+      if !restrict_create_only.blank? && !self.new_record?
+        restrict_create_only.each do |co|
+          if self.changed.include?(co) || !eval("self.instance_variable_get :@#{co}").blank?
+            self.errors.add(co.humanize, self.create_only_message)
+          end
+        end
+      end
+
+      # check for update only attributes
+      if !restrict_update_only.blank? && self.new_record?
+        restrict_update_only.each do |uo|
+          if self.changed.include?(uo) || !eval("self.instance_variable_get :@#{uo}").blank?
+            self.errors.add(uo.humanize, self.update_only_message)
+          end
+        end
+      end
+
+      # check for hidden only attributes
+      if !restrict_hidden_only.blank?
+        restrict_hidden_only.each do |ho|
+          if self.changed.include?(ho) || !eval("self.instance_variable_get :@#{ho}").blank?
+            self.errors.add(ho.humanize, self.hidden_only_message)
+          end
+        end
+      end
+      
+      # will return validation result
+      return false unless self.errors.blank?
+    end
+
+    def is_restricted?(action, field, user = nil)
+      action = action.to_s
+      field = field.to_s
+      klass = self.class
+      klass_object = self
+
+      unless klass_object.methods.include?("read_only")
+         raise NoMethodError, "undefined method `is_restricted?` for #{klass} model. You need to add `has_restricted_method` method in #{klass} model."
+      end
+
+      if action.nil? || !['create', 'update', 'read'].include?(action)
+        raise ArgumentError, "Invalid action - (#{action}), Pass valid action - :read or :create or :update or 'read' or 'create' or 'update'"
+      end
+
+      klass_attributes = klass_object.attributes.keys
+      if field.nil? || (!klass_attributes.include?(field) && !klass_object.methods.include?("#{field}="))
+        raise ActiveRecord::UnknownAttributeError, "#{klass}: unknown attribute(field): #{field}"
+      end
+
+      restrict_read_only = self.read_only
+      restrict_create_only = self.create_only
+      restrict_update_only = self.update_only
+      restrict_hidden_only = self.hidden_only
+
+      if action == "create" || action == "update" || action == "read"
+        return true if !restrict_hidden_only.blank? && restrict_hidden_only.include?(field)
+      end
+
+      if action == "create" || action == "update"
+        return true if !restrict_read_only.blank? && restrict_read_only.include?(field)
+      end
+
+      if action == "create"
+        return true if !restrict_update_only.blank? && restrict_update_only.include?(field)
+      end
+
+      if action == "update"
+        return true if !restrict_create_only.blank? && restrict_create_only.include?(field)
+      end
+      return false
+    end
+
+  end
+end
+

data/lib/simple_restricted_attributes.rb

@@ -0,0 +1,120 @@
+require "restricted/restricted_attrib"
+
+module SimpleRestrictedAttributes
+
+  module Restricted
+
+    def has_restricted_attributes(options = {})
+      cattr_accessor :read_only, :create_only, :update_only, :hidden_only
+      cattr_accessor :read_only_message, :create_only_message, :update_only_message, :hidden_only_message
+      
+      # set the read only attributes of a class
+      if options[:read_only]
+        only_read = []
+        if options[:read_only].is_a?(Array)
+          only_read = options[:read_only].collect {|r| r.to_s }
+        else
+          only_read << options[:read_only].to_s
+        end
+        self.read_only = only_read
+      end
+
+      # set the create only attributes of a class
+      if options[:create_only]
+        only_create = []
+        if options[:create_only].is_a?(Array)
+          only_create = options[:create_only].collect {|c| c.to_s }
+        else
+          only_create << options[:create_only].to_s
+        end
+        self.create_only = only_create
+      end
+
+      # set the create only attributes of a class
+      if options[:update_only]
+        only_update = []
+        if options[:update_only].is_a?(Array)
+          only_update = options[:update_only].collect {|u| u.to_s }
+        else
+          only_update << options[:update_only].to_s
+        end
+        self.update_only = only_update
+      end
+
+      # set the hidden only attributes of a class
+      if options[:hidden_only]
+        only_hidden = []
+        if options[:hidden_only].is_a?(Array)
+          only_hidden = options[:hidden_only].collect {|u| u.to_s }
+        else
+          only_hidden << options[:hidden_only].to_s
+        end
+        self.hidden_only = only_hidden
+      end
+
+      # Default validation messages
+      ro_msg = "is a read only attribute."
+      co_msg = "can't update, its permitted to create only."
+      uo_msg = "can't add, its permitted to update only."
+      ho_msg = "is a hidden attribute."
+
+      # assign validation messages to restricted attributes
+      self.read_only_message = options[:read_only_message] ? options[:read_only_message].to_s : ro_msg
+      self.create_only_message = options[:create_only_message] ? options[:create_only_message].to_s : co_msg
+      self.update_only_message = options[:update_only_message] ? options[:update_only_message].to_s : uo_msg
+      self.hidden_only_message = options[:hidden_only_message] ? options[:hidden_only_message].to_s : ho_msg
+
+      extend RestrictedAttrib::ClassMethods
+      include RestrictedAttrib::InstanceMethods      
+    end    
+  end
+
+  module RestrictedHelpers
+    def is_restricted?(klass, action, field, user = nil)
+      action = action.to_s
+      field = field.to_s
+      raise ArgumentError, "Must pass valid class" if klass.nil? || !klass.is_a?(Class)
+
+      klass_object = klass.new
+
+      unless klass_object.methods.include?("read_only")
+         raise NoMethodError, "undefined method `is_restricted?` for #{klass} model. You need to add `has_restricted_attributes` method in #{klass} model."
+      end
+      
+      if action.nil? || !['create', 'update', 'read'].include?(action)
+        raise ArgumentError, "Invalid action - (#{action}), Pass valid action - :read or :create or :update or 'read' or 'create' or 'update'"
+      end
+
+      klass_attributes = klass_object.attributes.keys
+      if field.nil? || !klass_attributes.include?(field)
+        raise ActiveRecord::UnknownAttributeError, "#{klass}: unknown attribute(field): #{field}"
+      end
+
+      restrict_read_only = klass_object.read_only
+      restrict_create_only = klass_object.create_only
+      restrict_update_only = klass_object.update_only
+      restrict_hidden_only = klass_object.hidden_only
+
+      if action == "create" || action == "update" || action == "read"
+        return true if !restrict_hidden_only.blank? && restrict_hidden_only.include?(field)
+      end
+      
+      if action == "create" || action == "update"
+        return true if !restrict_read_only.blank? && restrict_read_only.include?(field)
+      end
+      
+      if action == "create"
+        return true if !restrict_update_only.blank? && restrict_update_only.include?(field)
+      end
+
+      if action == "update"
+        return true if !restrict_create_only.blank? && restrict_create_only.include?(field)
+      end      
+      return false
+    end
+  end
+end
+
+ActiveRecord::Base.send(:extend, SimpleRestrictedAttributes::Restricted)
+ActionView::Base.send(:include, SimpleRestrictedAttributes::RestrictedHelpers)
+ActionController::Base.send(:include, SimpleRestrictedAttributes::RestrictedHelpers)

data/test/simple_restricted_attributes_test.rb

@@ -0,0 +1,8 @@
+require 'test_helper'
+
+class SimpleRestrictedAttributesTest < ActiveSupport::TestCase
+  # Replace this with your real tests.
+  test "the truth" do
+    assert true
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,3 @@
+require 'rubygems'
+require 'test/unit'
+require 'active_support'

metadata

@@ -0,0 +1,63 @@
+--- !ruby/object:Gem::Specification 
+name: simple_restricted_attributes
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 1.0.0
+platform: ruby
+authors: 
+  - Ganesh Kathare
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-21 00:00:00 +05:30
+default_executable: 
+dependencies: []
+
+description: "  This simple_restricted_attributes plugin/gem provides the capabilities to restrict attributes(fields) \n  of db table's while add or update a record. It validate your attributes values before\n  your validation stuff.\n"
+email: kathare.ganesh@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+  - README
+files: 
+  - init.rb
+  - MIT-LICENSE
+  - Rakefile
+  - README
+  - lib/simple_restricted_attributes.rb
+  - lib/restricted/restricted_attrib.rb
+  - test/simple_restricted_attributes_test.rb
+  - test/test_helper.rb
+has_rdoc: true
+homepage: https://github.com/gkathare
+licenses: []
+
+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.5.1
+signing_key: 
+specification_version: 3
+summary: Sharing simple_restricted_attributes
+test_files: []
+