can_camel 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 19f8ade41da75b5b9b3beb17bc729b62fae529e3
+  data.tar.gz: 44fd15e4109320bc9143dd4acb992bed642955b3
+SHA512:
+  metadata.gz: f02195d10717ac041a2e64df9b893d8f2d14a91051bdaa87a3b5e4cc668dda8f4e8dc932744330d982905e8a2b216fbebc7ec7d033b02549dd3287b88e6638c2
+  data.tar.gz: 590a5bd7ec97794d11638630d45561b496f3279428ab8dadb83078b12b65437d6ca859de64694fe0a3ce30c7b2c6a869116f6f5c0de87bdd1e607e4b76878504

data/LICENSE

@@ -0,0 +1,13 @@
+           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+                   Version 2, December 2004
+
+Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+
+Everyone is permitted to copy and distribute verbatim or modified
+copies of this license document, and changing it is allowed as long
+as the name is changed.
+
+           DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+  TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+ 0. You just DO WHAT THE FUCK YOU WANT TO.

data/Rakefile

@@ -0,0 +1,17 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'CanCamel'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks

data/lib/can_camel.rb

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

data/lib/can_camel/action_node.rb

@@ -0,0 +1,8 @@
+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
+  end
+end

data/lib/can_camel/base.rb

@@ -0,0 +1,16 @@
+module CanCamel
+  module Base
+    # don't delegate all, because lint_node designed to be run on same instances of linter
+    delegate :lint, :lint!, to: :new_linter
+
+    def can?(group, action, subject, **args)
+      Cache[[group, action, subject]].try(:can?, args)
+    end
+
+    private
+
+    def new_linter
+      CanCamel::Linter.new
+    end
+  end
+end

data/lib/can_camel/cache.rb

@@ -0,0 +1,31 @@
+module CanCamel
+  module Cache
+    class <<self
+      delegate :[], to: :cache
+
+      def reload!
+        @cache = build_cache
+      end
+
+      private
+
+      def cache
+        @cache ||= build_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
+        end
+      end
+    end
+  end
+end

data/lib/can_camel/concern_node.rb

@@ -0,0 +1,5 @@
+module CanCamel
+  class ConcernNode < Node
+    validates :parent_id, absence: true
+  end
+end

data/lib/can_camel/filter_helper.rb

@@ -0,0 +1,15 @@
+# Holds functions to parse params from strings
+module CanCamel
+  module FilterHelper
+    def from_int_array(str)
+      from_array(str).map(&:to_i)
+    rescue
+      raise Filters::ArgSyntaxError
+    end
+
+    def from_array(str)
+      raise Filters::ArgSyntaxError unless /\A\[(?<els>.+)\]\z/ =~ str
+      els.split ','
+    end
+  end
+end

data/lib/can_camel/filters.rb

@@ -0,0 +1,21 @@
+require 'can_camel/validators'
+module CanCamel::Filters
+  include CanCamel::Validators
+  extend CanCamel::FilterHelper
+  ArgSyntaxError = Class.new(StandardError)
+
+  module_function
+
+  validates :at_time, :hours, presence: {}
+  def at_time(hours:, **_)
+    hours = from_int_array 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 && !from_int_array(days).include?(Time.now.day)
+    return if wdays && !from_int_array(wdays).include?(Time.now.wday)
+    {}
+  end
+end

data/lib/can_camel/group_node.rb

@@ -0,0 +1,17 @@
+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 |hash, result|
+        hash.symbolize_keys!
+        raise Linter::LintingError unless hash[:method]
+        filtered = Filters.send(hash[:method], **hash.merge(additional_params))
+        return unless filtered
+        result.merge! filtered
+      end || result
+    end
+  end
+end

data/lib/can_camel/linter.rb

@@ -0,0 +1,52 @@
+module CanCamel
+  class Linter
+    LintingError = Class.new(StandardError)
+
+    def lint
+      %i(lint_inheritance lint_nodes).reduce(true) { |base, x| base && send(x) }
+    end
+
+    def lint!
+      raise LintingError unless lint
+    end
+
+    def lint_node(node)
+      node = node.dup
+      node.inherit!
+      %i(validate_node).reduce(true) { |base, x| base && send(x, node) }
+    end
+
+    private
+
+    def validate_node(node)
+      node.condition.each do |hash|
+        hash.symbolize_keys!
+        raise LintingError unless hash[:method]
+        Validators.validate!(filter: hash[:method], args: hash)
+      end
+      true
+    rescue Validators::ValidationError, LintingError
+      false
+    end
+
+    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

@@ -0,0 +1,53 @@
+module CanCamel
+  class Node < ActiveRecord::Base
+    self.table_name = TABLE_NAME
+    self.inheritance_column = 'type'
+    belongs_to :inherited_node, foreign_key: :inherit_id, class_name: "CanCamel::Node"
+
+    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
+      @inherited = true
+      return inherit_source! source if source
+
+      inherit_source! parent if respond_to? :parent
+      inherit_source! inherited_node
+    end
+
+    validates! :inherited, absence: { message: "You should not save inherited nodes!" }
+
+    # accessors
+
+    def name
+      super.to_sym
+    end
+
+    private
+
+    attr_reader :inherited
+
+    def inherit_source!(source)
+      return unless source
+
+      source.inherit!
+
+      inherit_field(source, :description) { |x| self.description ||= x }
+      inherit_field(source, :result) { |x| result.merge!(x) { |_k, l, _r| l } }
+
+      inherit_field(source, :condition) do |new|
+        methods = condition.map { |c| c['method'] }
+        new.each do |x|
+          condition.push(x) unless methods.include? x['method']
+        end
+      end
+    end
+
+    def inherit_field(source, field)
+      return if override_fields.include?(field.to_s)
+      yield source.send(field)
+    end
+  end
+end

data/lib/can_camel/subject_node.rb

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

data/lib/can_camel/validators.rb

@@ -0,0 +1,60 @@
+module CanCamel::Validators
+  ValidationError = Class.new(StandardError)
+  UnknownFilter = Class.new(ValidationError)
+
+  class <<self
+    def included(base)
+      base.define_singleton_method(:validates) { |*args| CanCamel::Validators.validates *args }
+    end
+
+    def validates(filter, field = nil, **args)
+      validators[filter] ||= []
+      args.each do |key, value|
+        validator =
+          if field
+            -> (x) { send(key, field: x[field], **value) }
+          else
+            -> (x) { send(key, args: x, **value) }
+          end
+        validators[filter].push(validator)
+      end
+    end
+
+    def validate!(filter:, args:)
+      filter = filter.to_sym
+      unless validators[filter]
+        raise UnknownFilter unless CanCamel::Filters.respond_to? filter
+        return
+      end
+      validators[filter].each { |x| x.call(args) }
+    end
+
+    private
+
+    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/version.rb

@@ -0,0 +1,3 @@
+module CanCamel
+  VERSION = "0.1.0"
+end

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

@@ -0,0 +1,4 @@
+# include custom ability filters
+# require 'can_camel/filters'
+# CanCamel::Filters.include AbilityFilters
+CanCamel::TABLE_NAME = "can_camel_nodes"

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

@@ -0,0 +1,18 @@
+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: {}
+    end
+  end
+end

data/lib/generators/can_camel/install_generator.rb

@@ -0,0 +1,8 @@
+class CanCamel::InstallGenerator < Rails::Generators::Base
+  desc "Generates initializer and some migrations"
+  source_root(File.expand_path("..", __FILE__))
+  def install
+    copy_file 'config/initializers/can_camel.rb'
+    copy_file 'db/migrate/00000000000001_create_can_camel_nodes.rb'
+  end
+end

data/lib/tasks/can_camel_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :can_camel do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: can_camel
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Alexander Smirnov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |2
+   CanCamel allows to manage access levels with all the power of cancan style (saving semantics). It means, that you can use `can?` method anywhere you want to check privileges of a selected user to access something in some way. See readme file at https://github.com/JelF/can_camel/blob/master/README.md to learn more
+email:
+- begdory4@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- Rakefile
+- lib/can_camel.rb
+- lib/can_camel/action_node.rb
+- lib/can_camel/base.rb
+- lib/can_camel/cache.rb
+- lib/can_camel/concern_node.rb
+- lib/can_camel/filter_helper.rb
+- lib/can_camel/filters.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/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/install_generator.rb
+- lib/tasks/can_camel_tasks.rake
+homepage: https://github.com/JelF/can_camel
+licenses:
+- WTFPL
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: CanCamel is a cancan style access controll library
+test_files: []