admission 0.4.5 → 0.4.6

data/spec/spec_helper.rb

@@ -1,28 +0,0 @@
-require_relative 'rspec_config'
-
-require 'byebug'
-
-def with_bug
-  $bug = true
-  yield
-ensure
-  $bug = false
-end
-
-RSpec::Matchers.define :have_inst_vars do |expected|
-  match do |object|
-    expected.to_a.all? do |var_name, value|
-      var = object.instance_variable_get "@#{var_name}"
-      var == value
-    end
-  end
-end
-
-require 'simplecov'
-SimpleCov.start do
-  add_filter %r~^(?!/lib/)~
-end
-
-require_relative '../lib/admission'
-require_relative '../lib/admission/rails'
-require_relative './test_context/index'

data/spec/test_context/country.rb

@@ -1,24 +0,0 @@
-# COUNTRIES = [
-#     :czech,
-#     :deutschland,
-#     :taiwan,
-#     :russia,
-#     :australia,
-#     :moon
-# ]
-#
-# class << COUNTRIES
-#
-#   def europe? country
-#     %i[czech deutschland russia].include? country
-#   end
-#
-#   def safe? country
-#     %i[czech deutschland taiwan].include? country
-#   end
-#
-#   def are_you_dispensable? person
-#     not (%i[russia] & person.countries).empty?
-#   end
-#
-# end

data/spec/test_context/index.rb

@@ -1,5 +0,0 @@
-require_relative 'country'
-require_relative 'person'
-
-require_relative 'privileges_and_rules'
-require_relative 'persons_fixtures'

data/spec/test_context/person.rb

@@ -1,31 +0,0 @@
-
-class Person
-
-  attr_reader :name, :sex, :countries
-  attr_reader :privileges, :rules
-
-  FEMALE            = 0
-  MALE              = 1
-  APACHE_HELICOPTER = 2
-
-  def initialize name, sex, countries
-    @name = name
-    @sex = sex
-    @countries = countries
-  end
-
-
-  # privileges per country
-
-  def not_woman?
-    @sex != FEMALE
-  end
-
-  def person
-    self
-  end
-
-  # def self.reduce_privileges **per_country
-  # end
-
-end

data/spec/test_context/persons_fixtures.rb

@@ -1,43 +0,0 @@
-
-fixtures = {
-
-    peasant_girl: [
-        Person::FEMALE,
-        []
-    ],
-
-    napoleon: [
-        Person::MALE,
-        []
-        # {all: 'harambe'}
-    ],
-
-    franz_joseph: [
-        Person::MALE,
-        [:czech, :australia]
-        # {czech: 'supernatural-primordial', taiwan: 'supernatural-god'}
-    ]
-
-}
-
-privileges_data_reducer = -> (privileges_data) {
-  privileges_data.to_a.reduce [] do |list, per_country_definition|
-    country, privileges_names = per_country_definition
-    raise "bad country #{country}" unless COUNTRIES.include? country
-    privileges_names = [privileges_names] unless privileges_names.is_a? Array
-
-    privileges = privileges_names.map do |name|
-      privilege = Admission::Privilege.get_from_order PRIVILEGES_ORDER, *name.split('-')
-      privilege.dup_with_context country
-    end
-
-    list + privileges
-  end
-}
-
-Person::FIXTURES = ->(name) {
-  *attrs, privileges = fixtures[name]
-  person = Person.new name, *attrs
-  person.instance_variable_set :@privileges, privileges_data_reducer.(privileges)
-  person
-}

data/spec/test_context/privileges_and_rules.rb

@@ -1,119 +0,0 @@
-
-
-PRIVILEGES_ORDER = Admission::Privilege.define_order do
-  privilege :vassal,   levels: %i[lord]
-  privilege :human,    levels: %i[count king]
-  privilege :emperor,  inherits: %i[vassal human]
-end
-
-
-ACTIONS_RULES = Admission::Arbitration.define_rules PRIVILEGES_ORDER do
-
-  privilege :human do
-    allow_all{ not_woman? }
-    forbid :raise_taxes
-    forbid :impose_corvee
-
-    forbid :impose_draft
-    forbid :act_as_god
-  end
-
-  privilege :human, :count do
-    allow_all do |country|
-      countries.include? country
-    end
-    allow :impose_corvee do |country|
-      countries.include? country
-    end
-  end
-
-  privilege :human, :king do
-    allow_all
-    allow :raise_taxes
-  end
-
-  privilege :vassal, :lord do
-    allow :impose_draft
-  end
-
-  privilege :emperor do
-    allow :act_as_god
-  end
-
-end
-
-
-RESOURCE_RULES = Admission::ResourceArbitration.define_rules PRIVILEGES_ORDER do
-
-  # `allow_all` & inheriting `:forbidden`
-
-  privilege :human do
-    allow_all(:actions){ not_woman? }
-    forbid :actions, :raise_taxes
-    forbid :actions, :impose_corvee
-
-    forbid :actions, :impose_draft
-    forbid :actions, :act_as_god
-  end
-
-  privilege :human, :count do
-    allow_all :actions do |country|
-      countries.include? country
-    end
-    allow :actions, :impose_corvee do |country|
-      countries.include? country
-    end
-  end
-
-  privilege :human, :king do
-    allow_all :actions
-    allow :actions, :raise_taxes
-  end
-
-  privilege :vassal, :lord do
-    allow :actions, :impose_draft
-  end
-
-  privilege :emperor do
-    allow :actions, :act_as_god
-  end
-
-  # `allow_resource` scoping & inheritance
-
-  privilege :vassal do
-
-    allow_resource Person, :show do |person, *|
-      raise 'person is nil' unless person
-      self == person
-    end
-
-    allow :persons, :index do |country|
-      countries.include? country
-    end
-
-  end
-
-  privilege :vassal, :lord do
-
-    allow_resource(Person, :show){ true }
-
-    allow_resource Person, %i[index update] do |person, country|
-      allowance = countries.include? country
-      next allowance unless person
-
-      allowance && person.countries.include?(country)
-    end
-
-    allow_resource Person, :destroy do |person, country|
-      person.countries.include?(country) &&
-          person.sex != Person::APACHE_HELICOPTER
-    end
-
-    allow Admission::ResourceArbitration.nested_scope(Person, :possessions), :index
-    allow_resource [Person, :possessions], :update do |person, country|
-      person.countries.include?(country)
-    end
-
-  end
-
-end

data/spec/unit/arbitration_spec.rb

@@ -1,33 +0,0 @@
-require_relative '../spec_helper'
-
-RSpec.describe Admission::Arbitration do
-
-  describe 'RulesBuilder' do
-
-    describe 'fails when given reserved action name' do
-
-      let(:builder){
-        builder = Admission::Arbitration::RulesBuilder.new nil
-        builder.instance_variable_set '@privilege', 'privilege'
-        builder
-      }
-
-      it '#allow' do
-        expect{ builder.allow '', :allow }.not_to raise_exception
-        expect{ builder.allow '', Admission::ALL_ACTION }.to(
-            raise_exception("reserved action name #{Admission::ALL_ACTION}")
-        )
-      end
-
-      it '#forbid' do
-        expect{ builder.forbid '', :forbid }.not_to raise_exception
-        expect{ builder.forbid '', Admission::ALL_ACTION }.to(
-            raise_exception("reserved action name #{Admission::ALL_ACTION}")
-        )
-      end
-
-    end
-
-  end
-
-end

data/spec/unit/index_spec.rb

@@ -1,144 +0,0 @@
-require_relative '../spec_helper'
-
-RSpec.describe Admission::Index do
-
-  let(:index){ Admission::Index.new }
-
-  def instance_with items=[], children={}
-    index = Admission::Index.new
-    index.instance_variable_set '@items', items
-    index.instance_variable_set '@children', children
-    index
-  end
-
-  describe '#to_a' do
-
-    it 'empty' do
-      expect(instance_with.to_a).to eq([])
-    end
-
-    it 'non-nested' do
-      index = instance_with [:item1, :item2]
-      expect(index.to_a).to eq(
-          [:item1, :item2]
-      )
-    end
-
-    it 'nested one level' do
-      index = instance_with [:item1, :item2], {nested: instance_with([:n1])}
-      expect(index.to_a).to eq(
-          [:item1, :item2, {nested: [:n1]}]
-      )
-    end
-
-    it 'nested two levels' do
-      index = instance_with [:item1, :item2],
-          {
-              nested1a: instance_with([:n1a]),
-              nested1b: instance_with([:n1b, {nested2a: instance_with([:n2a, :n2b])}])
-          }
-      expect(index.to_a).to eq(
-          [:item1, :item2, {nested1a: [:n1a], nested1b: [:n1b, {nested2a: [:n2a, :n2b]}]}]
-      )
-    end
-
-  end
-
-  describe '#==' do
-
-    it 'compares two instances' do
-      instance1 = instance_with
-      expect(instance1).not_to receive(:to_a)
-      instance2 = instance_with
-      expect(instance2).not_to receive(:to_a)
-
-      expect(instance1 == instance2).not_to be_truthy
-      expect(instance2 == instance1).not_to be_truthy
-      expect(instance1 == instance1).to be_truthy
-      expect(instance2 == instance2).to be_truthy
-    end
-
-    it 'compares with an array using conversion' do
-      instance1 = instance_with [:item1]
-      expect(instance1).to receive(:to_a).and_call_original
-      expect(instance1 == [:item1]).to be_truthy
-    end
-
-    it 'tests rspec eq() delegates to #eql?, i.e. #==' do
-      instance1 = instance_with [:item1]
-      expect(instance1).to receive(:==).and_call_original
-      expect(instance1).to eq([:item1])
-    end
-
-  end
-
-  describe '#allow' do
-
-    it 'single' do
-      index.allow :single
-      expect(index).to eq([:single])
-    end
-
-    it 'passed as args' do
-      index.allow :single, :double
-      expect(index).to eq([:single, :double])
-    end
-
-    it 'passed as arrays' do
-      index.allow :single, [:a1, :a2], :double, [:b1, :b2]
-      expect(index).to eq([:single, :a1, :a2, :double, :b1, :b2])
-    end
-
-    it 'convert args to symbols' do
-      index.allow 'single', ['a1', 'a2'], 'double', ['b1', 'b2']
-      expect(index).to eq([:single, :a1, :a2, :double, :b1, :b2])
-    end
-
-    it 'passed as keyword args, nested item' do
-      index.allow :single, nested: :a1
-      expect(index).to eq([:single, {nested: [:a1]}])
-    end
-
-    it 'passed as last position hash' do
-      index.allow :single, {nested: :a1}
-      expect(index).to eq([:single, {nested: [:a1]}])
-    end
-
-    it 'passed as keyword args, nested item list' do
-      index.allow :single, nested: [:a1]
-      expect(index).to eq([:single, {nested: [:a1]}])
-    end
-
-    it 'passed as keyword args, deep nested' do
-      index.allow :single, nested: [:a1, {deep_nested: :b1}]
-      expect(index).to eq([:single, {nested: [:a1, {deep_nested: [:b1]}]}])
-    end
-
-  end
-
-  describe '#allowed?' do
-
-    it 'looks for an item' do
-      index = instance_with [:item1]
-      expect(index.allowed? :item1).to eq(true)
-      expect(index.allowed? :item2).to eq(false)
-    end
-
-    it 'looks for a nested item' do
-      index = instance_with [], {nested: instance_with([:item2])}
-      expect(index.allowed? :item1).to eq(false)
-      expect(index.allowed? :item2).to eq(false)
-      expect(index.allowed? :nested, :item1).to eq(false)
-      expect(index.allowed? :nested, :item2).to eq(true)
-      expect(index.allowed? :non_nested, :item1).to eq(false)
-    end
-
-    it 'converts arguments' do
-      index = instance_with [:item1], {nested: instance_with([:item2])}
-      expect(index.allowed? 'item1').to eq(true)
-      expect(index.allowed? 'nested', 'item2').to eq(true)
-    end
-
-  end
-
-end

data/spec/unit/privilege/order_definer_spec.rb

@@ -1,184 +0,0 @@
-require_relative '../../spec_helper'
-
-RSpec.describe Admission::Privilege::OrderDefiner do
-
-  def define_privileges &block
-    Admission::Privilege::OrderDefiner.define &block
-  end
-
-  def privilege *args, inherits: nil
-    p = Admission::Privilege.new *args
-    p.inherits_from inherits if inherits
-    p
-  end
-
-  let(:definer){ Admission::Privilege::OrderDefiner.new }
-
-
-  describe '.define' do
-
-    it 'builds empty index' do
-      index = define_privileges{}
-      expect(index).to be_a(Hash)
-      expect(index).to be_empty
-      expect(index).to be_frozen
-    end
-
-    it 'builds single privilege' do
-      index = define_privileges{ privilege :man, levels: %i[commoner count] }
-      expect(index.keys).to eq(%i[man])
-      expect(index[:man].keys).to eq(%i[^ base commoner count])
-      expect(index[:man][:base].inherited).to be_nil
-    end
-
-    it 'builds with inheritance' do
-      index = define_privileges do
-        privilege :man
-        privilege :vassal, levels: %i[lord], inherits: :man
-      end
-
-      # structure
-      expect(index.keys).to eq(%i[man vassal])
-      expect(index[:man].keys).to eq(%i[^ base])
-      expect(index[:vassal].keys).to eq(%i[^ base lord])
-
-      # inheritance
-      expect(index[:man][:base].inherited).to be_nil
-      expect(index[:vassal][:base].inherited).to eql([privilege(:man)])
-      expect(index[:vassal][:lord].inherited).to eql([privilege(:vassal)])
-    end
-
-  end
-
-
-  describe '#privilege' do
-
-    it 'adds privilege with no levels' do
-      definer.privilege :man
-      expect(definer.definitions.size).to eq(1)
-      expect(definer.definitions[:man][:inherits]).to be_nil
-      expect(definer.definitions[:man][:levels]).to eql([privilege(:man)])
-    end
-
-    it 'adds privilege with no levels by string' do
-      definer.privilege 'man'
-      expect(definer.definitions.size).to eq(1)
-      expect(definer.definitions[:man][:inherits]).to be_nil
-      expect(definer.definitions[:man][:levels]).to eql([privilege(:man)])
-    end
-
-    it 'adds privilege array of levels' do
-      definer.privilege :man, levels: %i[commoner count]
-      expect(definer.definitions.size).to eq(1)
-      expect(definer.definitions[:man][:inherits]).to be_nil
-      expect(definer.definitions[:man][:levels]).to eql([
-          privilege(:man), privilege(:man, :commoner), privilege(:man, :count)
-      ])
-    end
-
-    it 'adds privilege that inherits single other' do
-      definer.privilege :vassal, inherits: :man
-      expect(definer.definitions.size).to eq(1)
-      expect(definer.definitions[:vassal][:inherits]).to eq([:man])
-    end
-
-    it 'adds privilege that inherits multiple others' do
-      definer.privilege :vassal, inherits: %i[man woman apache-helicopter]
-      expect(definer.definitions.size).to eq(1)
-      expect(definer.definitions[:vassal][:inherits]).to eq([:man, :woman, :'apache-helicopter'])
-    end
-
-    it 'adds multiple privileges' do
-      definer.privilege :man
-      definer.privilege :vassal
-      expect(definer.definitions.keys).to eq(%i[man vassal])
-    end
-
-  end
-
-
-  describe '#setup_inheritance' do
-
-    it 'sets inheritance' do
-      definer.privilege :man
-      definer.privilege :vassal, inherits: :man
-      definer.send :setup_inheritance
-
-      vassal = definer.definitions[:vassal]
-      expect(vassal[:levels]).to eql([privilege(:vassal)])
-      expect(vassal[:levels].first.inherited).to eql([privilege(:man)])
-    end
-
-    it 'sets inheritance to top level' do
-      definer.privilege :man, levels: %i[commoner count]
-      definer.privilege :vassal, inherits: :man
-      definer.send :setup_inheritance
-
-      vassal = definer.definitions[:vassal]
-      expect(vassal[:levels]).to eql([privilege(:vassal)])
-      expect(vassal[:levels].first.inherited).to eql([privilege(:man, :count)])
-    end
-
-    it 'sets inheritance throughout levels' do
-      definer.privilege :man
-      definer.privilege :vassal, inherits: :man, levels: %i[lord]
-      definer.send :setup_inheritance
-
-      vassal = definer.definitions[:vassal]
-      expect(vassal[:levels]).to eql([privilege(:vassal), privilege(:vassal, :lord)])
-      expect(vassal[:levels][0].inherited).to eql([privilege(:man)])
-      expect(vassal[:levels][1].inherited).to eql([privilege(:vassal)])
-    end
-
-  end
-
-
-  describe '#build_index' do
-
-    it 'returns hash with single privileges' do
-      definer.privilege :man
-      index = definer.send :build_index
-      expect(index).to be_a(Hash)
-      expect(index.keys).to eq([:man])
-
-      man = index.values.first
-      expect(man.keys).to eq(%i[^ base])
-      expect(man.values).to eql([privilege(:man), privilege(:man)])
-    end
-
-    it 'builds index for privilege with levels' do
-      definer.privilege :man, levels: %i[commoner count]
-      index = definer.send :build_index
-      expect(index).to be_a(Hash)
-      expect(index.keys).to eq([:man])
-
-      man = index[:man]
-      expect(man.keys).to eq(%i[^ base commoner count])
-      expect(man[:'^']).to eql(privilege :man, :count)
-      expect(man[:base]).to eql(privilege :man)
-      expect(man[:commoner]).to eql(privilege :man, :commoner)
-      expect(man[:count]).to eql(privilege :man, :count)
-    end
-
-    it 'returns hash with more privileges' do
-      definer.privilege :man
-      definer.privilege :vassal, levels: %i[lord]
-      index = definer.send :build_index
-      expect(index).to be_a(Hash)
-      expect(index.keys).to eq([:man, :vassal])
-
-      man = index[:man]
-      expect(man.keys).to eq(%i[^ base])
-      expect(man[:'^']).to eql(privilege :man)
-      expect(man[:base]).to eql(privilege :man)
-
-      vassal = index[:vassal]
-      expect(vassal.keys).to eq(%i[^ base lord])
-      expect(vassal[:'^']).to eql(privilege :vassal, :lord)
-      expect(vassal[:base]).to eql(privilege :vassal)
-      expect(vassal[:lord]).to eql(privilege :vassal, :lord)
-    end
-
-  end
-
-end