oo 0.9.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b7bda95102461e464f995d2967a3364bbbb1acd9
-  data.tar.gz: 6dcc0fdea18c8d6932acc63c3b6e2211335815bf
+  metadata.gz: 2378fbd29161d5abb1d0a5915f9b364d8e38d8e2
+  data.tar.gz: 7a6f4c6d27bf5c82494bdf7e0991870d98249de4
 SHA512:
-  metadata.gz: 3429777334a53028a83e808f004b46adeeac45d44ccf53ba8b7517fb4128789e9d0047f1a53b2a88de5df14ce4a9c7c7e976421d82341ca64b5333832740cdb7
-  data.tar.gz: fbb5e2d95222646a67d08c281b5d233034a54fcd297310e93e823f04b7c02c7df3a30c6d322bd81f2eab35d961a95373534e5113022060e9b6ebce281d3bf0f4
+  metadata.gz: 4f890c497ef66f8618238591e2c686f5d32a03d093674b227eb6617838f488ae004814441b6e45d3ca350e7093091511fdbf46c84f1c3952833c324c50c9f93a
+  data.tar.gz: fd692c1c7373d8057f9c60e3ab8452dc7b2c6c9dcf4f6183baea89ded6fcb62fb9faa18ff16d94ca1edcd4eddc3e7a40fd9fff94f9a58f41ea9efd06e91cc203

data/Gemfile

@@ -1,4 +1,3 @@
 source 'https://rubygems.org'
 
-# Specify your gem's dependencies in licence.gemspec
 gemspec

data/README.md

@@ -1,40 +1,170 @@
 # OO
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/oo`. To experiment with that code, run `bin/console` for an interactive prompt.
-
-TODO: Delete this and the text above, and describe your gem
+Simple Activity Based Authorization provider for Rails projects using `mongoid`.
 
 ## Installation
 
-Add this line to your application's Gemfile:
-
+1. Add to your Gemfile
 ```ruby
 gem 'oo'
 ```
 
-And then execute:
+2. Execute
+```
+$ bundle
+```
+
+3. Run
+```
+$ rails g oo:install
+```
+
+## Concept
+
+The gem is based on following concept:
+- licenses are permissions for activities,
+- license key is n-deep, separated with dot, e.g. `admins.edit.iban`,
+- license key allows using `*` for "all permissions in this scope", e.g:
+  - `admins.*` means that user can perform every activity that needs
+  permission `admins.[something]`, so having such a permission user can
+  perform `admins.edit`, can perform `admins.delete` but cannot
+  `admins.edit.iban`,
+  - `admins.*.*` means that user can perform every activity that needs
+  permission `admins.[something].[something_else]`, so having such a permission
+  user can `admins.edit`, can `admins.delete`, can `admins.edit.iban`
+  but cannot e.g. `admins.edit.iban.set_nil`
+  - etc.
+- license keys without `*` shall be understood literally: `admins` does not
+give access to `admins.edit` even though it's parent
+
+## Configuration and Usage
+
+### LicenseUser Module
+
+Add `OO::LicenseUser` to your user model.
+
+```ruby
+class User
+  include OO::LicenseUser
+
+  # ...
+end
+```
+Ready?
+
+If so, user class has been just extended with:
+- field `license_keys` (of type array),
+- method `licensed?`.
+
+You can now assign permissions for user and use `licensed?` method to check them, like in the example below.
+
+```ruby
+user = User.first
+user.licensed?(to: 'admins_users.edit')
+
+# true if user has permission 'admins_users.edit'
+# or any wider permission:
+# - `admins_users.*.*.*`, `admins_users.*.*`, `admins_users.*`
+# - `*.*.*.*`, `*.*.*`, `*.*`
+# otherwise: false
+```
+### LicenseCheckers Module
+
+Add `OO::LicenseCheckers` to your controller.
+
+```ruby
+class ApplicationController < ActionController::Base
+  include OO::LicenseCheckers
+
+  # ...
+end
+```
+
+Done?
 
-    $ bundle
+Therefore, your controller can be sent:
+- method `licensed?`,
+- method `check_license!`.
 
-Or install it yourself as:
+Please find attached examples.
 
-    $ gem install oo
+```ruby
+module Admins
+  class UsersController < ApplicationController
+    include OO::LicenseCheckers
 
-## Usage
 
-TODO: Write usage instructions here
+    def edit
+      check_license!(user: current_user, to: 'admins_users.edit')
+      # this will check whether user can perform 'admins_users.edit' or not
+      # if he can't then license_missing_reaction will be raised
+      # license_missing_reaction can be customized in initializer
 
-## Development
+      # ...
+    end
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+    # ...
+  end
+end
+```
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+Too verbose?
+
+```ruby
+module Admins
+  class UsersController < ApplicationController
+    include OO::LicenseCheckers
+
+    def edit
+      check_license!
+      # this is equal to previous for by default:
+      # - current_user method is used to inject user
+      # - '[parameterized controller path].[action name]' is used to inject key
+      # this call requires your controller to respond to #current_user
+      # both defaults :user and :to can be customized in initializer
+
+      # ...
+    end
+
+    # ...
+  end
+end
+```
+
+### Configuration
+
+Default configuration was set up in initializer. Please find its description.
+
+```ruby
+OO.configure do |c|
+  # this is about how many nodes (dot-splitted) can have a license key
+  c.license_max_depth = 4
+
+  # here you can change method for default user injected to license checkers
+  c.license_checkers_default_user = ->(base) { base.current_user }
+
+  # here you can change default permission (:to) injected to license checkers
+  c.license_checkers_default_key = lambda do |base|
+    base.controller_path.gsub('/', '_') +
+      OO::License.separator +
+      base.action_name
+  end
+
+  # here you can change default error raised when #check_license! fails
+  c.license_missing_reaction = lambda do |license_key, user|
+    raise OO::Errors::LicenseMissing, license_key: license_key,
+                                      user_data: user.id
+  end
+
+  # here you can set default license keys that user will be initialized with
+  c.default_license_keys = []
+end
+```
 
 ## Contributing
 
 Bug reports and pull requests are welcome.
 
-
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/generators/oo/install_generator.rb

@@ -4,10 +4,10 @@ module OO
   class InstallGenerator < ::Rails::Generators::Base
     namespace 'oo:install'
     source_root File.expand_path('../templates', __FILE__)
-    desc 'Generates OO (licence) gem initializer.'
+    desc 'Generates OO (license) gem initializer.'
 
     def install
-      template 'initializer.rb', 'config/initializers/oo_licence.rb'
+      template 'initializer.rb', 'config/initializers/oo_license.rb'
     end
   end
 end

data/lib/generators/oo/templates/initializer.rb

@@ -1,17 +1,17 @@
 OO.configure do |c|
-  c.licence_max_depth = 4
+  c.license_max_depth = 4
 
-  c.licence_checkers_default_user = ->(base) { base.current_user }
-  c.licence_checkers_default_key = lambda do |base|
+  c.license_checkers_default_user = ->(base) { base.current_user }
+  c.license_checkers_default_key = lambda do |base|
     base.controller_path.gsub('/', '_') +
-      OO::Licence.separator +
+      OO::License.separator +
       base.action_name
   end
 
-  c.licence_missing_reaction = lambda do |licence_key, user|
-    raise OO::Errors::LicenceMissing, licence_key: licence_key,
+  c.license_missing_reaction = lambda do |license_key, user|
+    raise OO::Errors::LicenseMissing, license_key: license_key,
                                       user_data: user.id
   end
 
-  c.default_licence_keys = []
+  c.default_license_keys = []
 end

data/lib/oo.rb

@@ -1,15 +1,15 @@
 require 'oo/version'
 require 'oo/configuration'
-require 'oo/errors/licence_missing'
-require 'oo/errors/licence_max_depth_invalid'
-require 'oo/errors/licence_missing_reaction_invalid'
-require 'oo/errors/licence_checkers_default_user_invalid'
-require 'oo/errors/licence_checkers_default_key_invalid'
-require 'oo/errors/default_licence_keys_invalid'
-require 'oo/licence'
-require 'oo/check_licence'
-require 'oo/licence_user'
-require 'oo/licence_checkers'
+require 'oo/errors/license_missing'
+require 'oo/errors/license_max_depth_invalid'
+require 'oo/errors/license_missing_reaction_invalid'
+require 'oo/errors/license_checkers_default_user_invalid'
+require 'oo/errors/license_checkers_default_key_invalid'
+require 'oo/errors/default_license_keys_invalid'
+require 'oo/license'
+require 'oo/check_license'
+require 'oo/license_user'
+require 'oo/license_checkers'
 
 module OO
   class << self

data/lib/oo/check_license.rb

@@ -0,0 +1,19 @@
+module OO
+  class CheckLicense
+    attr_reader :license_key, :license_keys, :license
+
+    def self.call(attrs = {})
+      new(attrs).call
+    end
+
+    def initialize(attrs = {})
+      @license_key = attrs.fetch(:key)
+      @license_keys = attrs.fetch(:in)
+      @license = License.new(key: license_key)
+    end
+
+    def call
+      license.masks & license_keys
+    end
+  end
+end

data/lib/oo/configuration.rb

@@ -1,46 +1,46 @@
 module OO
   class Configuration
-    attr_reader :licence_max_depth, :default_licence_keys,
-                :licence_missing_reaction, :licence_checkers_default_user,
-                :licence_checkers_default_key
+    attr_reader :license_max_depth, :default_license_keys,
+                :license_missing_reaction, :license_checkers_default_user,
+                :license_checkers_default_key
 
     def initialize
-      @licence_max_depth = 4
-      @default_licence_keys = []
-      @licence_missing_reaction =
-        -> { :licence_missing_reaction_not_configured }
+      @license_max_depth = 4
+      @default_license_keys = []
+      @license_missing_reaction =
+        -> { :license_missing_reaction_not_configured }
 
-      @licence_checkers_default_user =
-        -> { :licence_checkers_default_user_not_configured }
+      @license_checkers_default_user =
+        -> { :license_checkers_default_user_not_configured }
 
-      @licence_checkers_default_key =
-        -> { :licence_checkers_default_key_not_configured }
+      @license_checkers_default_key =
+        -> { :license_checkers_default_key_not_configured }
     end
 
-    def licence_max_depth=(depth)
-      raise Errors::LicenceMaxDepthInvalid unless depth.is_a?(Fixnum) &&
+    def license_max_depth=(depth)
+      raise Errors::LicenseMaxDepthInvalid unless depth.is_a?(Fixnum) &&
                                                   depth > 0
-      @licence_max_depth = depth
+      @license_max_depth = depth
     end
 
-    def default_licence_keys=(licence_keys)
-      raise Errors::DefaultLicenceKeysInvalid unless licence_keys.is_a?(Array)
-      @default_licence_keys = licence_keys
+    def default_license_keys=(license_keys)
+      raise Errors::DefaultLicenseKeysInvalid unless license_keys.is_a?(Array)
+      @default_license_keys = license_keys
     end
 
-    def licence_missing_reaction=(action)
-      raise Errors::LicenceMissingReactionInvalid unless action.is_a?(Proc)
-      @licence_missing_reaction = action
+    def license_missing_reaction=(action)
+      raise Errors::LicenseMissingReactionInvalid unless action.is_a?(Proc)
+      @license_missing_reaction = action
     end
 
-    def licence_checkers_default_user=(action)
-      raise Errors::LicenceCheckersDefaultUserInvalid unless action.is_a?(Proc)
-      @licence_checkers_default_user = action
+    def license_checkers_default_user=(action)
+      raise Errors::LicenseCheckersDefaultUserInvalid unless action.is_a?(Proc)
+      @license_checkers_default_user = action
     end
 
-    def licence_checkers_default_key=(action)
-      raise Errors::LicenceCheckersDefaultKeyInvalid unless action.is_a?(Proc)
-      @licence_checkers_default_key = action
+    def license_checkers_default_key=(action)
+      raise Errors::LicenseCheckersDefaultKeyInvalid unless action.is_a?(Proc)
+      @license_checkers_default_key = action
     end
   end
 end

data/lib/oo/errors/default_license_keys_invalid.rb

@@ -0,0 +1,9 @@
+module OO
+  module Errors
+    class DefaultLicenseKeysInvalid < StandardError
+      def initialize
+        super('OO.configuration.default_license_keys must be an Array.')
+      end
+    end
+  end
+end

data/lib/oo/errors/license_checkers_default_key_invalid.rb

@@ -0,0 +1,9 @@
+module OO
+  module Errors
+    class LicenseCheckersDefaultKeyInvalid < StandardError
+      def initialize
+        super('OO.configuration.license_checkers_default_key must be a Proc.')
+      end
+    end
+  end
+end

data/lib/oo/errors/license_checkers_default_user_invalid.rb

@@ -0,0 +1,9 @@
+module OO
+  module Errors
+    class LicenseCheckersDefaultUserInvalid < StandardError
+      def initialize
+        super('OO.configuration.license_checkers_default_user must be a Proc.')
+      end
+    end
+  end
+end

data/lib/oo/errors/{licence_max_depth_invalid.rb → license_max_depth_invalid.rb}

@@ -1,8 +1,8 @@
 module OO
   module Errors
-    class LicenceMaxDepthInvalid < StandardError
+    class LicenseMaxDepthInvalid < StandardError
       def initialize
-        super('OO.configuration.licence_max_depth must be a Fixnum '\
+        super('OO.configuration.license_max_depth must be a Fixnum '\
               'greater than 0')
       end
     end

data/lib/oo/errors/{licence_missing.rb → license_missing.rb}

@@ -1,11 +1,11 @@
 module OO
   module Errors
-    class LicenceMissing < StandardError
-      attr_reader :user_data, :licence_key
+    class LicenseMissing < StandardError
+      attr_reader :user_data, :license_key
 
       def initialize(attrs = {})
         @user_data = attrs[:user_data]
-        @licence_key = attrs.fetch(:licence_key)
+        @license_key = attrs.fetch(:license_key)
         super(error_message)
       end
 
@@ -14,7 +14,7 @@ module OO
       def error_message
         msg = "User "
         msg << "#{user_data} " unless user_data.nil?
-        msg << "is missing permission '#{licence_key}'. " \
+        msg << "is missing permission '#{license_key}'. " \
                'Therefore he is not allowed to perform this activity.'
       end
     end

data/lib/oo/errors/license_missing_reaction_invalid.rb

@@ -0,0 +1,9 @@
+module OO
+  module Errors
+    class LicenseMissingReactionInvalid < StandardError
+      def initialize
+        super('OO.configuration.license_missing_reaction must be a Proc.')
+      end
+    end
+  end
+end

data/lib/oo/{licence.rb → license.rb}

@@ -1,5 +1,5 @@
 module OO
-  class Licence
+  class License
     class << self
       def separator
         '.'
@@ -10,7 +10,7 @@ module OO
       end
 
       def max_depth
-        OO.configuration.licence_max_depth
+        OO.configuration.license_max_depth
       end
 
       def masks

data/lib/oo/license_checkers.rb

@@ -0,0 +1,34 @@
+module OO
+  module LicenseCheckers
+    def self.included(base)
+      base.class_eval do
+        def licensed?(attrs = {})
+          user = attrs.fetch(:user, license_checkers_default_user)
+          key = attrs.fetch(:to, license_checkers_default_key)
+          user.licensed?(to: key)
+        end
+
+        def check_license!(attrs = {})
+          user = attrs.fetch(:user, license_checkers_default_user)
+          key = attrs.fetch(:to, license_checkers_default_key)
+          license_missing_reaction.call(key, user) unless licensed?(user: user,
+                                                                    to: key)
+        end
+
+        private
+
+        def license_checkers_default_user
+          OO.configuration.license_checkers_default_user.call(self)
+        end
+
+        def license_checkers_default_key
+          OO.configuration.license_checkers_default_key.call(self)
+        end
+
+        def license_missing_reaction
+          OO.configuration.license_missing_reaction
+        end
+      end
+    end
+  end
+end

data/lib/oo/{licence_user.rb → license_user.rb}

@@ -1,13 +1,13 @@
 module OO
-  module LicenceUser
+  module LicenseUser
     def self.included(base)
       base.class_eval do
-        field :licence_keys, type: :array,
-                             default: OO.configuration.default_licence_keys
+        field :license_keys, type: :array,
+                             default: OO.configuration.default_license_keys
 
         def licensed?(attrs = {})
           required_key = attrs.fetch(:to)
-          CheckLicence.call(key: required_key, in: licence_keys).any?
+          CheckLicense.call(key: required_key, in: license_keys).any?
         end
       end
     end

data/lib/oo/version.rb

@@ -1,3 +1,3 @@
 module OO
-  VERSION = '0.9.0'
+  VERSION = '1.0.0'
 end

data/spec/factories/licences.rb

@@ -1,11 +1,11 @@
 FactoryGirl.define do
-  factory :licence, class: OO::Licence do
+  factory :license, class: OO::License do
     key 'action'
 
     initialize_with { new(attributes) }
   end
 
-  factory :glass_take_with_juice, parent: :licence do
+  factory :glass_take_with_juice, parent: :license do
     key 'glass.take.with_juice'
   end
 end

data/spec/oo/check_licence_spec.rb

@@ -1,43 +1,43 @@
 require 'spec_helper'
 
 
-describe OO::CheckLicence do
+describe OO::CheckLicense do
 
   describe '.new(attrs = {})' do
     let(:service_object) { described_class.new(attrs) }
-    let(:licence_key) { 'glass.take' }
+    let(:license_key) { 'glass.take' }
 
     subject { service_object }
 
     context 'when required attrs are missing' do
-      context 'when :key (checked licence key) is missing' do
+      context 'when :key (checked license key) is missing' do
         let(:attrs) { { in: [] } }
         it { expect { subject }.to raise_error(KeyError) }
       end
 
-      context 'when :in (licence keys list) is missing' do
-        let(:attrs) { { key: licence_key } }
+      context 'when :in (license keys list) is missing' do
+        let(:attrs) { { key: license_key } }
         it { expect { subject }.to raise_error(KeyError) }
       end
     end
 
     context 'when all required attrs were passed' do
-      let(:attrs) { { key: licence_key, in: [] } }
+      let(:attrs) { { key: license_key, in: [] } }
 
       it { is_expected.to be_a(described_class) }
 
-      describe 'builds a licence' do
-        let(:licence_class) { OO::Licence }
+      describe 'builds a license' do
+        let(:license_class) { OO::License }
 
-        describe '@licence' do
-          let(:licence) { service_object.instance_variable_get(:@licence) }
+        describe '@license' do
+          let(:license) { service_object.instance_variable_get(:@license) }
 
-          subject { licence }
-          it { is_expected.to be_a(licence_class) }
+          subject { license }
+          it { is_expected.to be_a(license_class) }
 
           describe '#key' do
-            subject { licence.key }
-            it { is_expected.to eq(licence_key) }
+            subject { license.key }
+            it { is_expected.to eq(license_key) }
           end
         end
       end
@@ -45,33 +45,33 @@ describe OO::CheckLicence do
   end
 
   describe '#call' do
-    let(:service_object) { described_class.new(key: licence_key, in: licence_keys) }
-    let(:licence) { OO::Licence.new(key: licence_key) }
-    let(:licence_key) { 'glass.take' }
+    let(:service_object) { described_class.new(key: license_key, in: license_keys) }
+    let(:license) { OO::License.new(key: license_key) }
+    let(:license_key) { 'glass.take' }
 
     subject { service_object.call }
 
     describe 'returns all keys wider or equal to given key found in given list' do
-      context 'when licence key is included in licence keys list' do
+      context 'when license key is included in license keys list' do
         context 'and is an only match' do
-          let(:licence_keys) { [licence_key] }
-          it { is_expected.to eq([licence_key]) }
+          let(:license_keys) { [license_key] }
+          it { is_expected.to eq([license_key]) }
         end
       end
 
-      context 'when exact licence key is missing in given list' do
+      context 'when exact license key is missing in given list' do
         context 'but there are wider keys' do
-          let(:licence_keys) { licence.genre_masks }
-          it { is_expected.to eq(licence.genre_masks) }
+          let(:license_keys) { license.genre_masks }
+          it { is_expected.to eq(license.genre_masks) }
         end
       end
 
-      context 'when licence key is missing in given list' do
-        let(:licence_keys) { %w(a b c d) }
+      context 'when license key is missing in given list' do
+        let(:license_keys) { %w(a b c d) }
         it { is_expected.to eq([]) }
 
         context 'but found parent key' do
-          let(:licence_keys) { [licence.parent.key] }
+          let(:license_keys) { [license.parent.key] }
           it { is_expected.to eq([]) }
         end
       end

data/spec/oo/configuration_spec.rb

@@ -3,119 +3,119 @@ require 'spec_helper'
 describe OO::Configuration do
   describe '.new' do
     let(:configuration) { described_class.new }
-    let(:default_licence_max_depth) { 4 }
-    let(:default_licence_keys) { [] }
-    let(:default_licence_missing_reaction) do
-      -> { :licence_missing_reaction_not_configured }
+    let(:default_license_max_depth) { 4 }
+    let(:default_license_keys) { [] }
+    let(:default_license_missing_reaction) do
+      -> { :license_missing_reaction_not_configured }
     end
 
-    let(:default_licence_checkers_default_user) do
-      -> { :licence_checkers_default_user_not_configured }
+    let(:default_license_checkers_default_user) do
+      -> { :license_checkers_default_user_not_configured }
     end
 
-    let(:default_licence_checkers_default_key) do
-      -> { :licence_checkers_default_key_not_configured }
+    let(:default_license_checkers_default_key) do
+      -> { :license_checkers_default_key_not_configured }
     end
 
     subject { configuration }
 
     it { is_expected.to be_a(described_class) }
     describe 'it is set to default values' do
-      describe 'licence_max_depth' do
-        subject { configuration.licence_max_depth }
-        it { is_expected.to eq(default_licence_max_depth) }
+      describe 'license_max_depth' do
+        subject { configuration.license_max_depth }
+        it { is_expected.to eq(default_license_max_depth) }
       end
 
-      describe 'default_licence_keys' do
-        subject { configuration.default_licence_keys }
-        it { is_expected.to eq(default_licence_keys) }
+      describe 'default_license_keys' do
+        subject { configuration.default_license_keys }
+        it { is_expected.to eq(default_license_keys) }
       end
 
-      describe 'licence_missing_reaction' do
-        let(:licence_missing_reaction) { configuration.licence_missing_reaction }
-        subject { licence_missing_reaction }
+      describe 'license_missing_reaction' do
+        let(:license_missing_reaction) { configuration.license_missing_reaction }
+        subject { license_missing_reaction }
         it { is_expected.to be_a(Proc) }
         describe "#call" do
-          subject { licence_missing_reaction.call }
-          it { is_expected.to eq(:licence_missing_reaction_not_configured) }
+          subject { license_missing_reaction.call }
+          it { is_expected.to eq(:license_missing_reaction_not_configured) }
         end
       end
 
-      describe 'licence_checkers_default_user' do
-        let(:licence_checkers_default_user) { configuration.licence_checkers_default_user }
-        subject { licence_checkers_default_user }
+      describe 'license_checkers_default_user' do
+        let(:license_checkers_default_user) { configuration.license_checkers_default_user }
+        subject { license_checkers_default_user }
         it { is_expected.to be_a(Proc) }
         describe "#call" do
-          subject { licence_checkers_default_user.call }
-          it { is_expected.to eq(:licence_checkers_default_user_not_configured) }
+          subject { license_checkers_default_user.call }
+          it { is_expected.to eq(:license_checkers_default_user_not_configured) }
         end
       end
 
-      describe 'licence_checkers_default_key' do
-        let(:licence_checkers_default_key) { configuration.licence_checkers_default_key }
-        subject { licence_checkers_default_key }
+      describe 'license_checkers_default_key' do
+        let(:license_checkers_default_key) { configuration.license_checkers_default_key }
+        subject { license_checkers_default_key }
         it { is_expected.to be_a(Proc) }
         describe "#call" do
-          subject { licence_checkers_default_key.call }
-          it { is_expected.to eq(:licence_checkers_default_key_not_configured) }
+          subject { license_checkers_default_key.call }
+          it { is_expected.to eq(:license_checkers_default_key_not_configured) }
         end
       end
     end
 
-    describe '#licence_max_depth=(depth)' do
+    describe '#license_max_depth=(depth)' do
       context 'when depth is not a fixnum' do
         let(:depth) { 'a' }
-        let(:error) { OO::Errors::LicenceMaxDepthInvalid }
+        let(:error) { OO::Errors::LicenseMaxDepthInvalid }
 
-        subject { -> { configuration.licence_max_depth = depth } }
+        subject { -> { configuration.license_max_depth = depth } }
         it { is_expected.to raise_error(error) }
       end
 
       context 'when depth is not greater than 0' do
         let(:depth) { 0 }
-        let(:error) { OO::Errors::LicenceMaxDepthInvalid }
+        let(:error) { OO::Errors::LicenseMaxDepthInvalid }
 
-        subject { -> { configuration.licence_max_depth = depth } }
+        subject { -> { configuration.license_max_depth = depth } }
         it { is_expected.to raise_error(error) }
       end
     end
 
-    describe '#licence_missing_reaction=(action)' do
+    describe '#license_missing_reaction=(action)' do
       context 'when action is not a Proc object' do
         let(:action) { :invalid }
-        let(:error) { OO::Errors::LicenceMissingReactionInvalid }
+        let(:error) { OO::Errors::LicenseMissingReactionInvalid }
 
-        subject { -> { configuration.licence_missing_reaction = action } }
+        subject { -> { configuration.license_missing_reaction = action } }
         it { is_expected.to raise_error(error) }
       end
     end
 
-    describe '#licence_checkers_default_user=(action)' do
+    describe '#license_checkers_default_user=(action)' do
       context 'when action is not a Proc object' do
         let(:action) { :invalid }
-        let(:error) { OO::Errors::LicenceCheckersDefaultUserInvalid }
+        let(:error) { OO::Errors::LicenseCheckersDefaultUserInvalid }
 
-        subject { -> { configuration.licence_checkers_default_user = action } }
+        subject { -> { configuration.license_checkers_default_user = action } }
         it { is_expected.to raise_error(error) }
       end
     end
 
-    describe '#licence_checkers_default_key=(action)' do
+    describe '#license_checkers_default_key=(action)' do
       context 'when action is not a Proc object' do
         let(:action) { :invalid }
-        let(:error) { OO::Errors::LicenceCheckersDefaultKeyInvalid }
+        let(:error) { OO::Errors::LicenseCheckersDefaultKeyInvalid }
 
-        subject { -> { configuration.licence_checkers_default_key = action } }
+        subject { -> { configuration.license_checkers_default_key = action } }
         it { is_expected.to raise_error(error) }
       end
     end
 
-    describe '#default_licence_keys=(licence_keys)' do
-      context 'when licence_keys is not an array' do
-        let(:licence_keys) { :invalid }
-        let(:error) { OO::Errors::DefaultLicenceKeysInvalid }
+    describe '#default_license_keys=(license_keys)' do
+      context 'when license_keys is not an array' do
+        let(:license_keys) { :invalid }
+        let(:error) { OO::Errors::DefaultLicenseKeysInvalid }
 
-        subject { -> { configuration.default_licence_keys = licence_keys } }
+        subject { -> { configuration.default_license_keys = license_keys } }
         it { is_expected.to raise_error(error) }
       end
     end

data/spec/oo/licence_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe OO::Licence do
+describe OO::License do
   let(:separator) { described_class.separator }
   let(:mask_mark) { described_class.mask_mark }
 
@@ -17,7 +17,7 @@ describe OO::Licence do
   end
 
   describe '.max_depth' do
-    let(:max_depth) { OO.configuration.licence_max_depth }
+    let(:max_depth) { OO.configuration.license_max_depth }
     subject { described_class.max_depth }
 
     context 'for default configuration' do
@@ -29,7 +29,7 @@ describe OO::Licence do
     subject { described_class.masks }
 
     describe 'returns all possible top-level masks basing on max depth' do
-      before(:each) { OO.configure { |c| c.licence_max_depth = max_depth } }
+      before(:each) { OO.configure { |c| c.license_max_depth = max_depth } }
 
       context 'when max_depth is set to 1' do
         let(:max_depth) { 1 }
@@ -63,22 +63,22 @@ describe OO::Licence do
   end
 
   describe '#separator' do
-    let(:licence) { build(:glass_take_with_juice) }
-    subject { licence.separator }
+    let(:license) { build(:glass_take_with_juice) }
+    subject { license.separator }
     it { is_expected.to eq(described_class.separator) }
   end
 
   describe '#mask_mark' do
-    let(:licence) { build(:glass_take_with_juice) }
-    subject { licence.mask_mark }
+    let(:license) { build(:glass_take_with_juice) }
+    subject { license.mask_mark }
     it { is_expected.to eq(described_class.mask_mark) }
   end
 
   describe '#key' do
     context 'for :glass_take_with_juice factory' do
-      let(:licence) { build(:glass_take_with_juice) }
+      let(:license) { build(:glass_take_with_juice) }
 
-      subject { licence.key }
+      subject { license.key }
 
       it { is_expected.to be_a(String) }
       it { is_expected.to eq('glass.take.with_juice') }
@@ -87,9 +87,9 @@ describe OO::Licence do
 
   describe '#to_s' do
     context 'for :glass_take_with_juice factory' do
-      let(:licence) { build(:glass_take_with_juice) }
+      let(:license) { build(:glass_take_with_juice) }
 
-      subject { licence.to_s }
+      subject { license.to_s }
 
       it { is_expected.to be_a(String) }
       it { is_expected.to eq('glass.take.with_juice') }
@@ -98,9 +98,9 @@ describe OO::Licence do
 
   describe '#to_a' do
     context 'for :glass_take_with_juice factory' do
-      let(:licence) { build(:glass_take_with_juice) }
+      let(:license) { build(:glass_take_with_juice) }
 
-      subject { licence.to_a }
+      subject { license.to_a }
 
       it { is_expected.to be_an(Array) }
       it { is_expected.to eq(%w(glass take with_juice)) }
@@ -109,9 +109,9 @@ describe OO::Licence do
 
   describe '#depth' do
     context 'for :glass_take_with_juice factory' do
-      let(:licence) { build(:glass_take_with_juice) }
+      let(:license) { build(:glass_take_with_juice) }
 
-      subject { licence.depth }
+      subject { license.depth }
 
       it { is_expected.to be_a(Fixnum) }
       it { is_expected.to eq(3) }
@@ -126,18 +126,18 @@ describe OO::Licence do
         depth_3: %W(#{m}#{s}#{m}#{s}#{m} #{m}#{s}#{m}#{s}#{m}#{s}#{m}) }
     end
 
-    subject { licence.genre_masks }
+    subject { license.genre_masks }
 
-    describe 'should return the most general masks for licence' do
+    describe 'should return the most general masks for license' do
       context 'for :glass_take_with_juice factory (depth: 3)' do
-        let(:licence) { build(:glass_take_with_juice) }
+        let(:license) { build(:glass_take_with_juice) }
 
         it { is_expected.to be_an(Array) }
         it { is_expected.to eq(genre_masks[:depth_3]) }
       end
 
-      context 'for :licence factory (depth: 1)' do
-        let(:licence) { build(:licence) }
+      context 'for :license factory (depth: 1)' do
+        let(:license) { build(:license) }
 
         it { is_expected.to be_an(Array) }
         it { is_expected.to eq(genre_masks[:depth_1]) }
@@ -149,44 +149,44 @@ describe OO::Licence do
     let(:m) { mask_mark }
     let(:s) { separator }
 
-    subject { licence.mask_key(mask) }
+    subject { license.mask_key(mask) }
 
-    describe 'for n-deep licence should replace mask\'s n chars with key\'s' do
-      context 'when mask key is deeper than licence' do
+    describe 'for n-deep license should replace mask\'s n chars with key\'s' do
+      context 'when mask key is deeper than license' do
         let(:mask) { "#{m}#{s}#{m}#{s}#{m}#{s}#{m}" }
 
         context 'for :glass_take_with_juice factory' do
-          let(:licence) { build(:glass_take_with_juice) }
+          let(:license) { build(:glass_take_with_juice) }
 
           it { is_expected.to be_a(String) }
-          it { is_expected.to eq(licence.key + "#{s}#{m}") }
+          it { is_expected.to eq(license.key + "#{s}#{m}") }
         end
 
-        context 'for :licence factory' do
-          let(:licence) { build(:licence) }
+        context 'for :license factory' do
+          let(:license) { build(:license) }
 
           it { is_expected.to be_an(String) }
-          it { is_expected.to eq(licence.key + "#{s}#{m}#{s}#{m}#{s}#{m}") }
+          it { is_expected.to eq(license.key + "#{s}#{m}#{s}#{m}#{s}#{m}") }
         end
       end
 
-      context 'when mask depth equals licence depth' do
-        context 'for :licence factory' do
-          let(:licence) { build(:licence) }
+      context 'when mask depth equals license depth' do
+        context 'for :license factory' do
+          let(:license) { build(:license) }
           let(:mask) { "#{m}" }
 
           it { is_expected.to be_an(String) }
-          it { is_expected.to eq(licence.key) }
+          it { is_expected.to eq(license.key) }
         end
       end
 
-      context 'when mask depth is less than licence depth' do
+      context 'when mask depth is less than license depth' do
         context 'for :glass_take_with_juice factory' do
-          let(:licence) { build(:glass_take_with_juice) }
+          let(:license) { build(:glass_take_with_juice) }
           let(:mask) { "#{m}#{s}#{m}" }
 
           it { is_expected.to be_an(String) }
-          it { is_expected.to eq(licence.key) }
+          it { is_expected.to eq(license.key) }
         end
       end
     end
@@ -196,35 +196,35 @@ describe OO::Licence do
     let(:mask_mark) { described_class.mask_mark }
 
     context 'for :glass_take_with_juice factory' do
-      let(:licence) { build(:glass_take_with_juice) }
-      let(:parent_licence) { licence.parent }
+      let(:license) { build(:glass_take_with_juice) }
+      let(:parent_license) { license.parent }
 
-      subject { parent_licence }
+      subject { parent_license }
 
       it { is_expected.to be_a(described_class) }
 
       describe '#key' do
-        subject { parent_licence.key }
+        subject { parent_license.key }
         it { is_expected.to eq('glass.take') }
       end
     end
 
-    context 'for :licence factory' do
-      let(:licence) { build(:licence) }
-      let(:parent_licence) { licence.parent }
+    context 'for :license factory' do
+      let(:license) { build(:license) }
+      let(:parent_license) { license.parent }
 
       describe '#key' do
-        subject { parent_licence.key }
+        subject { parent_license.key }
         it { is_expected.to eq(mask_mark) }
       end
     end
 
     context 'when key equals single mask mark' do
-      let(:licence) { build(:licence, key: mask_mark) }
-      let(:parent_licence) { licence.parent }
+      let(:license) { build(:license, key: mask_mark) }
+      let(:parent_license) { license.parent }
 
       describe '#key' do
-        subject { parent_licence.key }
+        subject { parent_license.key }
         it { is_expected.to eq(mask_mark) }
       end
     end

data/spec/oo_spec.rb

@@ -17,11 +17,11 @@ describe OO do
     context 'when block was given' do
       let(:depth) { 5 }
       before(:each) do
-        described_class.configure { |c| c.licence_max_depth = depth }
+        described_class.configure { |c| c.license_max_depth = depth }
       end
 
       it 'updates configuration' do
-        expect(described_class.configuration.licence_max_depth).to eq(depth)
+        expect(described_class.configuration.license_max_depth).to eq(depth)
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oo
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Krzysztof Buszewicz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-03-02 00:00:00.000000000 Z
+date: 2016-03-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -86,17 +86,17 @@ files:
 - lib/generators/oo/install_generator.rb
 - lib/generators/oo/templates/initializer.rb
 - lib/oo.rb
-- lib/oo/check_licence.rb
+- lib/oo/check_license.rb
 - lib/oo/configuration.rb
-- lib/oo/errors/default_licence_keys_invalid.rb
-- lib/oo/errors/licence_checkers_default_key_invalid.rb
-- lib/oo/errors/licence_checkers_default_user_invalid.rb
-- lib/oo/errors/licence_max_depth_invalid.rb
-- lib/oo/errors/licence_missing.rb
-- lib/oo/errors/licence_missing_reaction_invalid.rb
-- lib/oo/licence.rb
-- lib/oo/licence_checkers.rb
-- lib/oo/licence_user.rb
+- lib/oo/errors/default_license_keys_invalid.rb
+- lib/oo/errors/license_checkers_default_key_invalid.rb
+- lib/oo/errors/license_checkers_default_user_invalid.rb
+- lib/oo/errors/license_max_depth_invalid.rb
+- lib/oo/errors/license_missing.rb
+- lib/oo/errors/license_missing_reaction_invalid.rb
+- lib/oo/license.rb
+- lib/oo/license_checkers.rb
+- lib/oo/license_user.rb
 - lib/oo/version.rb
 - oo.gemspec
 - spec/factories/licences.rb

data/lib/oo/check_licence.rb

@@ -1,19 +0,0 @@
-module OO
-  class CheckLicence
-    attr_reader :licence_key, :licence_keys, :licence
-
-    def self.call(attrs = {})
-      new(attrs).call
-    end
-
-    def initialize(attrs = {})
-      @licence_key = attrs.fetch(:key)
-      @licence_keys = attrs.fetch(:in)
-      @licence = Licence.new(key: licence_key)
-    end
-
-    def call
-      licence.masks & licence_keys
-    end
-  end
-end

data/lib/oo/errors/default_licence_keys_invalid.rb

@@ -1,9 +0,0 @@
-module OO
-  module Errors
-    class DefaultLicenceKeysInvalid < StandardError
-      def initialize
-        super('OO.configuration.default_licence_keys must be an Array.')
-      end
-    end
-  end
-end

data/lib/oo/errors/licence_checkers_default_key_invalid.rb

@@ -1,9 +0,0 @@
-module OO
-  module Errors
-    class LicenceCheckersDefaultKeyInvalid < StandardError
-      def initialize
-        super('OO.configuration.licence_checkers_default_key must be a Proc.')
-      end
-    end
-  end
-end

data/lib/oo/errors/licence_checkers_default_user_invalid.rb

@@ -1,9 +0,0 @@
-module OO
-  module Errors
-    class LicenceCheckersDefaultUserInvalid < StandardError
-      def initialize
-        super('OO.configuration.licence_checkers_default_user must be a Proc.')
-      end
-    end
-  end
-end

data/lib/oo/errors/licence_missing_reaction_invalid.rb

@@ -1,9 +0,0 @@
-module OO
-  module Errors
-    class LicenceMissingReactionInvalid < StandardError
-      def initialize
-        super('OO.configuration.licence_missing_reaction must be a Proc.')
-      end
-    end
-  end
-end

data/lib/oo/licence_checkers.rb

@@ -1,34 +0,0 @@
-module OO
-  module LicenceCheckers
-    def self.included(base)
-      base.class_eval do
-        def licensed?(attrs = {})
-          user = attrs.fetch(:user, licence_checkers_default_user)
-          key = attrs.fetch(:to, licence_checkers_default_key)
-          user.licensed?(to: key)
-        end
-
-        def check_licence!(attrs = {})
-          user = attrs.fetch(:user, licence_checkers_default_user)
-          key = attrs.fetch(:to, licence_checkers_default_key)
-          licence_missing_reaction.call(key, user) unless licensed?(user: user,
-                                                                    to: key)
-        end
-
-        private
-
-        def licence_checkers_default_user
-          OO.configuration.licence_checkers_default_user.call(self)
-        end
-
-        def licence_checkers_default_key
-          OO.configuration.licence_checkers_default_key.call(self)
-        end
-
-        def licence_missing_reaction
-          OO.configuration.licence_missing_reaction
-        end
-      end
-    end
-  end
-end