can_camel 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6cd2a7e24ff8c42df996b7255ecfc0710ae5b011
-  data.tar.gz: 97d7813911fdbbcc34c765243df8f047fceef026
+  metadata.gz: b7327da083e2094e5ec46012cd8d677fa1d580a3
+  data.tar.gz: de42690b702c3cf0be312f3a284efdd7d2a8b9da
 SHA512:
-  metadata.gz: 89e48cc509dfe2269a5f308e3234fbcbe2400642b22c916b44937b72f32fcbfb57eaa28de6d4162b23e4d69f37cd4a6a222ca79270994faf6a29d0ff01ba5338
-  data.tar.gz: c765a6da93ea8aa404105b405a22a8598348a5c4a42b54c36655f6c471c61d46228eeb3c077962f88c933457aa4a641ec09e641dc4d3fd3d4faf16e1b86e18e2
+  metadata.gz: d990335cb5d604df985bb522370aabe0ac0750e516a51570c9d1485309bfec14acad9d254cc450e02f570766b01311db060fe682da20a353f3fd53a41fbda428
+  data.tar.gz: d43fd37f23f2cdcfcf28e63281b312ab7d9e714e79412a78a3d90547261e256c5886fc08a5c5e648719d753f8f8d94beae5bc02fad7c56e2207291b8ad878cf4

data/README.md

@@ -14,18 +14,16 @@ can be passed to a filter. Any custom filters could be made and any additional d
 
 Step 1. Installation
 ====================
-run rails g can_camel:install <br>
+run `rails g can_camel:install` <br>
 Then visit generated initializer at config/initializers/can_camel.rb
 <pre>
-# CanCamel::Filters.include AbilityFilters
 CanCamel::TABLE_NAME = "can_camel_nodes"
 CanCamel::GROUP_METHOD = :group
 </pre>
-First line describes how to use you own filters. You may prefer `prepend` over `include`
-here. You can also specify table name, if you want. Third line describes a symbol, which references for
+In first line you can specify table name or use default. Second line describes a symbol, which references for
 user model method, returning user group. Group should be a symbol. Visit spec/dummy/app/models/user.rb
-for example. When you sure with this file, run generated migration.
-Remember, that migration installs 'hstore' plugin, on which relies,
+for example. When you sure with this file, run generated migrations.
+Remember, that migrations installs 'hstore' plugin, on which relies,
 but does not remove it. If you want to revert it, you may want to remove plugin too
 
 Step 2. Database structure
@@ -34,29 +32,39 @@ Database consists of nodes. Primary nodes (WHERE parent_id IS NULL) are called s
 Their children are called actions, and actions' children are called groups. Groups' children
 are called garbage and never used. Any node can have conditions and results. Conditions' syntax is
 <pre>
-[
-  { method: :day_of_week, allow: %w(saturday sunday) }
-]
+ { at_day: { wdays: [6] } }
 </pre>
-It means, that :day_of_week will be called with `allow: {"saturday", "sunday}"` argument
+It means, that :at_day will be called with `wdays: [6]` argument
 
 Step 3. Linting
 ===============
+_I suggest to call `CanCamel.lint` each time you modifying can_camel objects because it is beta_ <br>
 If you are working primary with database (e.g. in migration), you can call
 `CanCamel.lint` to check is database correct. Best way is to call `CanCamel.lint!` in transaction
-with all changes done and enjoy your exception if need
+with all changes done and enjoy your exception if need.
 
-Step 4. Constrains (Incomplete)
-===============================
-Filters have great powers, and with big power big responsibility comes. For example, you are managing
-statistics access on Users, and your filter scoping them. What if your filter would be called for Blog?
-I think, nothing good. To prevent it, you can write a constraint
-<pre>
-validate :filter_name, subject: :user
-def filter_name
-  #TODO: do something
-end
-</pre>
+Step 4. Custom filters and Constrains
+=====================================
+Filters subsystem relies on a `CanCamel::Filter` module, which automatically inserts
+`register_filter` method when included. This method can take as first argument high variety of things
+1. If it takes a symbol and lambda, it will define a simple filter without argument filtering
+2. If it takes a method or symbol referencing a method, it will register that method as in previous api: as a simple
+filter
+3. If it takes a class respond to `invoke!` and `name` methods, it will register its element
+4. If it takes something else respond to `invoke` and `name` methods, it will register it as is
+
+You can use old style validation or use validate! method in objects passed
+
+Old Style Validation
+--------------------
+Include `CanCamel::Validators` to use validates method. You can add custom validators extending
+this class in initializer. Validation syntax is `validates filter [field] validator: params`
+
+validate! method
+----------------
+define `validate!` method for you filters and place your validators here (mostly for semantic)
+you can access improved `validates` method in classes inherited from `CanCamel::Filters::Base`
+this method requires to specify only validators and optionally field name
 
 Step 5. Human interface (NIY)
 ============================

data/lib/can_camel.rb

@@ -1,7 +1,7 @@
 module CanCamel
   extend ActiveSupport::Autoload
   %i(Base Node SubjectNode ActionNode GroupNode ConcernNode Linter Filters
-     Validators Cache)
+     Validators Cache Filter)
     .each { |x| autoload(x) }
 
   extend CanCamel::Base

data/lib/can_camel/action_node.rb

@@ -1,8 +1,10 @@
 module CanCamel
   class ActionNode < Node
     has_many :groups, foreign_key: :parent_id, class_name: "CanCamel::GroupNode"
-    belongs_to :parent, foreign_key: :parent_id, class_name: "CanCamel::SubjectNode"
-
     validates_presence_of :parent_id
+
+    def rank
+      2
+    end
   end
 end

data/lib/can_camel/base.rb

@@ -3,8 +3,14 @@ module CanCamel
     # don't delegate all, because lint_node designed to be run on same instances of linter
     delegate :lint, :lint!, to: :new_linter
 
+    # returns hash with some return params or nil.
+    # @param user [User] user respond to GROUP_METHOD
+    # @param action [Symbol] symbol relied to action node name
+    # @param subject [Symbol] symbol relied to subject node name
+    # @return [Hash, nil] hash with specific params or nil
     def can?(user, action, subject, **args)
-      Cache[[user.send(GROUP_METHOD), action, subject]].try(:can?, args)
+      Cache[[user.send(GROUP_METHOD).to_sym, action, subject]]
+        .try(:can?, user: user, **args)
     end
 
     private

data/lib/can_camel/cache.rb

@@ -5,27 +5,45 @@ module CanCamel
 
       def reload!
         @cache = build_cache
+        inherit_all!
+      end
+
+      def children_of(node)
+        cache.select do |path, _value|
+          _, *subpath = path
+          node.path == subpath
+        end.values
+      end
+
+      def append(node, path)
+        path = [node.name, *path]
+        @cache[path] = node
+        children_of(node).each { |child| append child, path }
       end
 
       private
 
+      # def subpath?(path, subpath)
+      #   return if path.empty?
+      #   return true if subpath.empty?
+      #   return unless path[-1] == subpath[-1]
+      #   subpath?(path[0...-1], subpath[0...-1])
+      # end
+
       def cache
-        @cache ||= build_cache
+        @cache || (reload!; @cache)
       end
 
       def build_cache
-        SubjectNode.all.each_with_object({}) do |subject_node, object|
-          subject_name = subject_node.name
-          subject_node.actions.each do |action_node|
-            action_name = action_node.name
-            action_node.groups.each do |group_node|
-              group_name = group_node.name
-              group_node.inherit!
-              object[[group_name, action_name, subject_name]] = group_node
-            end
-          end
+        Node.all.each_with_object({}) do |node, object|
+          object[node.path] = node
         end
       end
+
+      def inherit_all!
+        local_cache = cache.dup
+        local_cache.each { |_path, node| node.inherit! }
+      end
     end
   end
 end

data/lib/can_camel/concern_node.rb

@@ -2,4 +2,8 @@ module CanCamel
   class ConcernNode < Node
     validates :parent_id, absence: true
   end
+
+  def rank
+    0
+  end
 end

data/lib/can_camel/filter.rb

@@ -0,0 +1,40 @@
+module CanCamel
+  module Filter
+    def self.included(base)
+      base.define_singleton_method(:register_filter) { |*args| CanCamel::Filter.register_filter(*args) }
+    end
+
+    class <<self
+      def register_filter(x, lambda = nil)
+        case x
+        when Class
+          filter = x.new
+        when Symbol
+          begin
+            filter = Filters::CustomFilter.new(x, lambda || method(x))
+          rescue NameError
+            raise ArgumentError, "no method #{x} defined and lambda not passed"
+          end
+        when Method
+          filter = Filters::CustomFilter.new(x.name, x)
+        else
+          filter = x
+        end
+
+        raise ArgumentError, "#{x} is neither Filter nor Class nor Symbol nor Method" unless filter?(filter)
+        filter.try(:validate!)
+        filters[filter.name] = filter
+      end
+
+      def filters
+        @filters ||= {}
+      end
+
+      private
+
+      def filter?(x)
+        %i(invoke! name).reduce { |a, e| a && x.respond_to?(e) }
+      end
+    end
+  end
+end

data/lib/can_camel/filters.rb

@@ -1,19 +1,12 @@
 require 'can_camel/validators'
 module CanCamel::Filters
   include CanCamel::Validators
-  ArgSyntaxError = Class.new(StandardError)
+  include CanCamel::Filter
+  extend ActiveSupport::Autoload
 
-  module_function
+  ABSTRACT_FILTERS = %i(Base CustomFilter)
+  FILTERS = %i(AtTime AtDay)
 
-  validates :at_time, :hours, presence: {}
-  def at_time(hours:, **_)
-    hours.include?(Time.now.hour) && {}
-  end
-
-  validates :at_day, presence_of: { fields: [:days, :wdays], any: true }
-  def at_day(days: nil, wdays: nil, **_)
-    return if days && !days.include?(Time.now.day)
-    return if wdays && !wdays.include?(Time.now.wday)
-    {}
-  end
+  (ABSTRACT_FILTERS + FILTERS).each { |x| autoload x }
+  FILTERS.each { |x| register_filter const_get(x) }
 end

data/lib/can_camel/filters/at_day.rb

@@ -0,0 +1,20 @@
+module CanCamel::Filters
+  class AtDay < Base
+    def catch_args
+      %i(days wdays)
+    end
+
+    def validate!
+      validates presence_of: {
+        fields: %i(days wdays),
+        any: true,
+      }
+    end
+
+    def filter(days: nil, wdays: nil)
+      return if days && !days.include?(Time.now.day)
+      return if wdays && !wdays.include?(Time.now.wday)
+      {}
+    end
+  end
+end

data/lib/can_camel/filters/at_time.rb

@@ -0,0 +1,19 @@
+module CanCamel::Filters
+  class AtTime < AtDay
+    def catch_args
+      %i(hours days wdays)
+    end
+
+    def validate!
+      validates presence_of: {
+        fields: %i(hours days wdays),
+        any: true,
+      }
+    end
+
+    def filter(hours: nil, days: nil, wdays: nil)
+      return if hours && !hours.include?(Time.now.hour)
+      super days: days, wdays: wdays
+    end
+  end
+end

data/lib/can_camel/filters/base.rb

@@ -0,0 +1,42 @@
+module CanCamel::Filters
+  class Base
+    def initialize(*)
+    end
+
+    def name
+      self.class.to_s.demodulize.underscore.to_sym
+    end
+
+    def catch_args
+      nil
+    end
+
+    def catch_result
+      []
+    end
+
+    def filter(**_)
+      {}
+    end
+
+    def lint!
+      raise CanCamel::Linter::LintingError if (catch_args & catch_result).try(:any?)
+    end
+
+    def invoke!(args: {}, result: {})
+      args = my_slice(args, catch_args) if catch_args
+      args.merge! my_slice(result, catch_result) { |l, r, _k| r || l }
+      filter(**args)
+    end
+
+    def validates(*args)
+      CanCamel::Validators.validates(name, *args)
+    end
+
+    private
+
+    def my_slice(hash, args)
+      args.each_with_object({}) { |x, object| object[x] = hash[x]  }
+    end
+  end
+end

data/lib/can_camel/filters/custom_filter.rb

@@ -0,0 +1,17 @@
+module CanCamel::Filters
+  class CustomFilter
+    attr_reader :name
+
+    def initialize(name, lambda)
+      @name, @lambda = name, lambda
+    end
+
+    def invoke!(**args)
+      lambda.call(**args)
+    end
+
+    private
+
+    attr_reader :lambda
+  end
+end

data/lib/can_camel/group_node.rb

@@ -1,16 +1,18 @@
 module CanCamel
   class GroupNode < Node
-    belongs_to :parent, foreign_key: :parent_id, class_name: "CanCamel::ActionNode"
-
     validates_presence_of :parent_id
 
     def can?(**additional_params)
-      condition.each_with_object(result.dup) do |(method, args), result|
+      condition.each_with_object(result.dup.merge(additional_params)) do |(method, args), result|
         args = args.symbolize_keys
-        filtered = Filters.send(method, **args.merge(additional_params))
+        filtered = Filter.filters[method].invoke!(args: args.merge(additional_params), result: result)
         return unless filtered
         result.merge! filtered
       end || result
     end
+
+    def rank
+      3
+    end
   end
 end

data/lib/can_camel/linter.rb

@@ -3,7 +3,8 @@ module CanCamel
     LintingError = Class.new(StandardError)
 
     def lint
-      %i(lint_inheritance lint_nodes).reduce(true) { |base, x| base && send(x) }
+      Cache.reload! rescue return
+      %i(lint_nodes lint_filters).reduce(true) { |base, x| base && send(x) }
     end
 
     def lint!
@@ -16,11 +17,18 @@ module CanCamel
       %i(validate_node).reduce(true) { |base, x| base && send(x, node) }
     end
 
+    def lint_filters
+      CanCamel::Filter.filters.values.flatten.uniq.each { |filter| !filter.respond_to?(:lint!) || filter.lint! }
+      true
+    rescue CanCamel::Linter::LintingError
+      false
+    end
+
     private
 
     def validate_node(node)
       node.condition.each do |method, args|
-        Validators.validate!(filter: method, args: args.symbolize_keys)
+        Validators.validate!(filter: method, args: args.symbolize_keys, path: node.path)
       end
       true
     rescue Validators::ValidationError, LintingError
@@ -30,21 +38,5 @@ module CanCamel
     def lint_nodes
       CanCamel::Node.all.reduce(true) { |base, x| base && lint_node(x) }
     end
-
-    def lint_inheritance
-      CanCamel::Node.with_parents.where(<<-SQL).empty?
-        (
-          #{TABLE_NAME}.type = 'CanCamel::ActionNode'
-          AND
-          parents.type != 'CanCamel::SubjectNode'
-        )
-        OR
-        (
-          #{TABLE_NAME}.type = 'CanCamel::GroupNode'
-          AND
-          parents.type != 'CanCamel::ActionNode'
-        )
-      SQL
-    end
   end
 end

data/lib/can_camel/node.rb

@@ -2,19 +2,43 @@ module CanCamel
   class Node < ActiveRecord::Base
     self.table_name = TABLE_NAME
     self.inheritance_column = 'type'
+
+    belongs_to :parent, foreign_key: :parent_id, class_name: "CanCamel::Node"
+    has_many :children, foreign_key: :parent_id, class_name: "CanCamel::Node"
+
+    has_many :actions, foreign_key: :parent_id, class_name: "CanCamel::ActionNode"
+    has_many :groups, foreign_key: :parent_id, class_name: "CanCamel::GroupNode"
+
     belongs_to :inherited_node, foreign_key: :inherit_id, class_name: "CanCamel::Node"
 
+    def cached_parent
+      Cache[path[1..-1]]
+    end
+
+    def rank
+      raise "inheriting invalid node"
+    end
+
+    def cached_inherited_node
+      return unless inherit_id
+      @inherited_path ||= inherited_node.path
+      Cache[@inherited_path]
+    end
+
     def self.with_parents
       joins("LEFT JOIN #{TABLE_NAME} AS parents ON #{TABLE_NAME}.parent_id = parents.id")
     end
 
     def inherit!(source = nil)
       return if inherited
+
+      raise 'inherit nodes only after cache built' unless Cache[path]
+
       @inherited = true
       return inherit_source! source if source
 
-      inherit_source! parent if respond_to? :parent
-      inherit_source! inherited_node
+      inherit_source! cached_parent
+      inherit_source! cached_inherited_node
     end
 
     validates! :inherited, absence: { message: "You should not save inherited nodes!" }
@@ -27,6 +51,12 @@ module CanCamel
       super.symbolize_keys
     end
 
+    attr_writer :path
+
+    def path
+      @path ||= parent ? [name] + parent.path  : [name]
+    end
+
     private
 
     attr_reader :inherited
@@ -36,6 +66,12 @@ module CanCamel
 
       source.inherit!
 
+      Cache.children_of(source).each do |child|
+        next unless child.rank > rank
+        next if child == self
+        Cache.append child, path
+      end
+
       inherit_field(source, :description) { |x| self.description ||= x }
       inherit_field(source, :result) { |x| result.merge!(x) { |_k, l, _r| l } }
       inherit_field(source, :condition) { |x| self.condition = x.merge(condition) }

data/lib/can_camel/subject_node.rb

@@ -1,7 +1,9 @@
 module CanCamel
   class SubjectNode < Node
-    has_many :actions, foreign_key: :parent_id, class_name: "CanCamel::ActionNode"
-
     validates :parent_id, absence: true
+
+    def rank
+      1
+    end
   end
 end

data/lib/can_camel/validators.rb

@@ -2,6 +2,12 @@ module CanCamel::Validators
   ValidationError = Class.new(StandardError)
   UnknownFilter = Class.new(ValidationError)
 
+  extend ActiveSupport::Autoload
+  SUBMODULES = %i(GeneralValidators PathValidators)
+  SUBMODULES.each { |x| autoload x }
+  autoload :ValidatorsHelper
+  SUBMODULES.each { |x| extend const_get(x) }
+
   class <<self
     def included(base)
       base.define_singleton_method(:validates) { |*args| CanCamel::Validators.validates *args }
@@ -20,13 +26,13 @@ module CanCamel::Validators
       end
     end
 
-    def validate!(filter:, args:)
+    def validate!(filter:, args:, path: nil)
       filter = filter.to_sym
       unless validators[filter]
-        raise UnknownFilter unless CanCamel::Filters.respond_to? filter
+        raise UnknownFilter unless CanCamel::Filter.filters.include? filter
         return
       end
-      validators[filter].each { |x| x.call(args) }
+      validators[filter].each { |x| x.call(path: path, **args) }
     end
 
     private
@@ -34,27 +40,5 @@ module CanCamel::Validators
     def validators
       @validators ||= {}
     end
-
-    def presence(field:)
-      raise ValidationError unless field.present?
-    end
-
-    def presence_of(fields:, args:, any: false)
-      condition = fields.map { |x| args[x].present? }.reduce { |base, x| any ? (base || x) : (base && x) }
-      return if condition
-      raise ValidationError
-    end
-
-    def in(field:, array: [], empty: false)
-      return if array.include? field
-      return if empty && !field.present?
-      raise ValidationError
-    end
-
-    def custom(field:, lambda:, empty: false)
-      return if empty && !field.present?
-      return if lambda.call(field)
-      raise ValidationError
-    end
   end
 end

data/lib/can_camel/validators/general_validators.rb

@@ -0,0 +1,44 @@
+module CanCamel::Validators
+  module GeneralValidators
+    def presence(field:)
+      raise ValidationError unless field.present?
+    end
+
+    def absence(field:)
+      raise ValidationError if field.present?
+    end
+
+    def presence_of(fields:, args:, any: false, only: false, none: false)
+      if [any, only, none].select(&:presence).count > 1
+        raise ValidationError, 'only one of [any, only, none] could be supplied to presence_of'
+      end
+
+      only = 0 if none
+      only = 1 if only && !only.is_a?(Fixnum)
+
+      fields_present = fields.select { |x| args[x].present? }
+
+      case
+      when only
+        return if fields_present.count == only
+      when any
+        return if fields_present.count > 0
+      else
+        return if fields_present.count == fields.count
+      end
+      raise ValidationError
+    end
+
+    def in(field:, array: [], empty: false)
+      return if array.include? field
+      return if empty && !field.present?
+      raise ValidationError
+    end
+
+    def custom(field:, lambda:, empty: false)
+      return if empty && !field.present?
+      return if lambda.call(field)
+      raise ValidationError
+    end
+  end
+end

data/lib/can_camel/validators/path_validators.rb

@@ -0,0 +1,20 @@
+module CanCamel::Validators
+  module PathValidators
+    include ValidatorsHelper
+
+    def path(path:, action: nil, subject: nil, group: nil)
+      raise ValidationError unless action || subject || group
+      unless path && path.length == 3
+        raise ValidationError, 'trying to validate not a group node or invalid node structure'
+      end
+
+      validate_element(element: path[0], value: group) if group
+      validate_element(element: path[1], value: action) if action
+      validate_element(element: path[2], value: subject) if subject
+    end
+
+    alias_method :action, :path
+    alias_method :subject, :path
+    alias_method :group, :path
+  end
+end

data/lib/can_camel/validators/validators_helper.rb

@@ -0,0 +1,11 @@
+module CanCamel::Validators
+  module ValidatorsHelper
+    def validate_element(element:, value:)
+      if value.is_a? Proc
+        raise ValidationError unless value.call element
+        return
+      end
+      raise ValidationError unless element.to_s == value.to_s
+    end
+  end
+end

data/lib/can_camel/version.rb

@@ -1,3 +1,3 @@
 module CanCamel
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/lib/generators/can_camel/config/initializers/can_camel.rb

@@ -1,5 +1,4 @@
-# include custom ability filters
-# require 'can_camel/filters'
-# CanCamel::Filters.include AbilityFilters
+# include custom validators
+# CanCamel::Validators.extend AbilityFiltersValidators
 CanCamel::TABLE_NAME = "can_camel_nodes"
 CanCamel::GROUP_METHOD = :group

data/lib/generators/can_camel/db/migrate/00000000000001_create_can_camel_nodes.rb

@@ -1,18 +1,14 @@
 class CreateCanCamelNodes < ActiveRecord::Migration
   def change
-    reversible do |d|
-      d.up { execute 'CREATE extension IF NOT EXISTS hstore;' }
-    end
-
     create_table CanCamel::TABLE_NAME do |t|
       t.column :name, :string, index: true
       t.column :description, :text, null: true
       t.column :parent_id, :integer, null: true
       t.column :inherit_id, :integer, null: true
       t.column :type, :string
-      t.column :override_fields, :string, array: true, default: []
-      t.column :condition, :hstore, array: true, default: []
-      t.column :result, :hstore, default: {}
+      t.column :override_fields, :json, default: []
+      t.column :condition, :json, default: {}
+      t.column :result, :json, default: {}
     end
   end
 end

data/lib/generators/can_camel/install_generator.rb

@@ -4,6 +4,5 @@ class CanCamel::InstallGenerator < Rails::Generators::Base
   def install
     copy_file 'config/initializers/can_camel.rb'
     copy_file 'db/migrate/00000000000001_create_can_camel_nodes.rb'
-    copy_file 'db/migrate/00000000000002_hstore_to_json.rb'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: can_camel
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Alexander Smirnov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-09 00:00:00.000000000 Z
+date: 2015-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '4'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '4'
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -54,16 +54,23 @@ files:
 - lib/can_camel/base.rb
 - lib/can_camel/cache.rb
 - lib/can_camel/concern_node.rb
+- lib/can_camel/filter.rb
 - lib/can_camel/filters.rb
+- lib/can_camel/filters/at_day.rb
+- lib/can_camel/filters/at_time.rb
+- lib/can_camel/filters/base.rb
+- lib/can_camel/filters/custom_filter.rb
 - lib/can_camel/group_node.rb
 - lib/can_camel/linter.rb
 - lib/can_camel/node.rb
 - lib/can_camel/subject_node.rb
 - lib/can_camel/validators.rb
+- lib/can_camel/validators/general_validators.rb
+- lib/can_camel/validators/path_validators.rb
+- lib/can_camel/validators/validators_helper.rb
 - lib/can_camel/version.rb
 - lib/generators/can_camel/config/initializers/can_camel.rb
 - lib/generators/can_camel/db/migrate/00000000000001_create_can_camel_nodes.rb
-- lib/generators/can_camel/db/migrate/00000000000002_hstore_to_json.rb
 - lib/generators/can_camel/install_generator.rb
 - lib/tasks/can_camel_tasks.rake
 homepage: https://github.com/JelF/can_camel
@@ -91,3 +98,4 @@ signing_key:
 specification_version: 4
 summary: CanCamel is a cancan style access controll library
 test_files: []
+has_rdoc: 

data/lib/generators/can_camel/db/migrate/00000000000002_hstore_to_json.rb

@@ -1,14 +0,0 @@
-class HstoreToJson < ActiveRecord::Migration
-  def change
-    unless ENV['RAILS_ENV'] == 'test' || ENV['FORCE_CAN_CAMEL_WIPE'] == 'true'
-      puts "Attention! This migration will wipe can_camel data. Continue? (Y/n)"
-      puts "Set FORCE_CAN_CAMEL_WIPE=true to automaticaly accept"
-      res = STDIN.gets
-      raise unless res =~ /\A[Yy]/
-    end
-    CanCamel::Node.delete_all
-    remove_column CanCamel::TABLE_NAME, :condition, :hstore, array: true, default: []
-    add_column CanCamel::TABLE_NAME, :condition, :json, default: {}
-    CanCamel::Node.delete_all
-  end
-end