vinyl 0.0.1

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+*.gem

data/Gemfile

@@ -0,0 +1,3 @@
+group :test do
+  gem 'rspec'
+end

data/README.md

@@ -0,0 +1,144 @@
+# Vinyl
+**_Access Level for him and her_**
+
+_by: Federico Saravia Barrantes [@fsaravia](https://github.com/fsaravia) and Lautaro Orazi [@tarolandia](https://github.com/tarolandia)_
+
+## Introduction
+
+"Vinyl" is a simple gem that allows developer to define different access levels for a resource and a serie of local and global validators to gain access to those levels.
+It works by analizing a series of validators defined by you and returning a number representing the access level a particular request is able to reach.
+
+## What is it useful for?
+
+This gem is useful when you need to control the output depending on who wants to access to a resource.
+
+For example: user A wants to get user B's profile.
+
+1. If A == B, A have full access to data
+2. If A is friend of B, A can see private data but not config data
+3. If A is not friend of B, A only can see public data
+
+In the example we have 3 different levels of access to B information.
+
+## Basic Config
+
+```ruby
+  Vinyl::configure do |config|
+    config.api_acl_mode = Vinyl::Configuration::STRATEGY_DESCENDING
+    config.force_access_control = true 
+    config.warn_on_missing_validators = true 
+  end
+```
+
+__:api_acl_mode can take two values:__
+
+  1. Vinyl::Configuration::STRATEGY_DESCENDING, Check for validators starting on the highest access level
+  2. Vinyl::Configuration::STRATEGY_ASCENDING, Check for validators starting on the lowest access level
+
+__:force_access_control true/false__
+
+Deny access if no validators are given for a route/method combination and no global validators exist
+
+__:warn_on_missing_validators true/false__
+
+Display a warning on STDOUT when calling a missing validator
+
+
+## Defining Rules
+
+A rule defines the access level and the validators for a route/method combination:
+
+```ruby
+Vinyl.when_route 
+  '/api/route', 
+  :with_method => 'POST|GET|PUT|DELETE',
+  :get_access_level => 1...n,
+  :if_pass => ['validator1', 'validator2', …, 'validatorn']
+```
+
+__Example:__
+```ruby
+Vinyl.when_route '/profiles.json', 
+  :with_method => 'GET', 
+  :get_access_level => 1, 
+  :if_pass => ['is_user']
+
+Vinyl.when_route '/profiles.json', 
+  :with_method => 'GET', 
+  :get_access_level => 2, 
+  :if_pass => ['is_admin']
+```
+
+
+## Defining validators
+
+There are two kind of validators: global and normal validators. All validators you define must return true or false.
+
+Global validators will be applied to all rules defined. You can add a global validator using add_global_validator method:
+
+```ruby
+Vinyl.add_global_validator("name_of_global_validator", lambda {
+  # your code here
+  return true/false
+})
+```
+
+Normal validators will be applied when a rule includes it into its validators list. Validators can be added using add_validator method:
+
+```ruby
+Vinyl.add_validator("name_of_validator", lambda {
+  # your code here
+  return true/false
+})
+```
+
+
+## Defining Variables
+
+Inside validators you can use your models, classes and whatever. If you want a custom variable to be available in the scope of the validators, add it this way:
+
+```ruby
+Vinyl.my_variable = variable_value
+```
+
+Inside your validator:
+
+```ruby
+Vinyl.add_validator("my_validator", lambda {
+  puts my_variable # will output variable_value
+  return true/false
+})
+```
+
+__Clearing Variables__
+
+If you need to reset previously defined variables to avoid validation errors just call:
+
+```ruby
+Vinyl.reset_variables
+```
+## Getting Access Level
+
+At this point you had defined your rules, validators and variables. Now you are ready to get call access level.
+
+```ruby
+access_level = Vinyl.check_level('/call/route','call_method')
+```
+
+If you need to avoid a global validator you can use bypass method:
+
+```ruby
+access_level = Vinyl.bypass("global_validator_name").check_level('/call/route','call_method')
+```
+
+or a list of them
+
+```ruby
+access_level = Vinyl.bypass(["global_1","global_2"]).check_level('/call/route','call_method')
+```
+
+Using bypass means exclude the validators only for the current check.
+
+## License
+
+See the `UNLICENSE` file included with this gem distribution.

data/UNLICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>

data/examples/usage_example.rb

@@ -0,0 +1,30 @@
+require 'vinyl'
+#Configuration:
+Vinyl::configure do |config|
+  config.api_acl_mode = Vinyl::Configuration::STRATEGY_DESCENDING
+  config.force_access_control = true #Deny access if no validators are given for a route/method combination and no global validators exist
+  config.warn_on_missing_validators = true #Display a warning on STDOUT when calling a missing validator
+end
+
+#Clear previous registered variables
+Vinyl::reset_variables
+#Define variables
+Vinyl::some_arbitrary_value = true
+
+#Define some validators:
+#Global
+Vinyl.add_global_validator("global_validator",lambda{return true}) #Global validators are executed for every route
+#
+Vinyl::add_validator("validator",lambda{return some_arbitrary_value})
+Vinyl::add_validator("another_validator",lambda{return false})
+
+#Define routes
+Vinyl::when_route 'test', :with_method => 'POST', :get_access_level => 1, :if_pass => ['validator']
+Vinyl::when_route 'test', :with_method => 'POST', :get_access_level => 2, :if_pass => ['validator', 'another_validator']
+Vinyl::when_route 'test', :with_method => 'GET', :get_access_level => 1, :if_pass => ['another_validator']
+Vinyl::when_route 'test', :with_method => 'GET', :get_access_level => 2, :if_pass => []
+
+access_level = Vinyl::check_level('test','POST')
+puts access_level
+access_level = Vinyl::check_level('test','GET')
+puts access_level

data/lib/vinyl.rb

@@ -0,0 +1,4 @@
+require 'vinyl/base'
+require 'vinyl/validator'
+require 'vinyl/variables'
+require 'vinyl/rule'

data/lib/vinyl/base.rb

@@ -0,0 +1,68 @@
+module Vinyl
+
+  def self.configure
+    yield config
+  end
+
+  def self.config=(config)
+    @config = config
+  end
+
+  def self.config
+    @config ||=Configuration.new
+  end
+
+  def self.check_level(route,method)
+    required_route = Vinyl::acl_routes_collection[route]
+    required_route = Hash.new if required_route.nil?
+    validators_to_call = required_route[method]
+    if (validators_to_call.nil? || validators_to_call.empty?) then
+      if (global_validators.empty?) then
+        return Vinyl.config.force_access_control ? 0 : 1
+      else
+        validators_to_call = {1 => []} #No access level defined but global validators must be called
+      end
+    end
+    keys = validators_to_call.keys.sort
+    highest_level = 0
+    keys.send("#{Vinyl::config.validators_iterate_strategy}") do |access_level|
+      pass = Vinyl::Validators.run_validators(validators_to_call[access_level])
+      if (pass==true) then
+        highest_level = access_level
+        break if Vinyl::config.api_acl_mode == Vinyl::Configuration::STRATEGY_DESCENDING #Already on the highest level
+      elsif (pass==false)
+        break if Vinyl::config.api_acl_mode == Vinyl::Configuration::STRATEGY_ASCENDING #Do not check for higher levels
+      end
+    end
+    return highest_level
+  end
+
+  class Configuration
+
+    attr_accessor :api_acl_mode, :force_access_control, :warn_on_missing_validators
+    STRATEGY_DESCENDING = 1 #Check for validators starting on the highest access level
+    STRATEGY_ASCENDING = 2  #Check for validators starting on the lowest access level
+
+    @@defaults = {
+      :api_acl_mode => STRATEGY_DESCENDING,
+      :force_access_control => false,
+      :warn_on_missing_validators => true
+    }
+
+    def validators_iterate_strategy
+      if(@api_acl_mode == STRATEGY_DESCENDING) then
+        return 'reverse_each'
+      else
+        return 'each'
+      end
+    end
+
+    def self.defaults
+      @@defaults
+    end
+
+    def initialize
+      @@defaults.each_pair{|k,v| self.send("#{k}=",v)}
+    end
+  end
+end

data/lib/vinyl/rule.rb

@@ -0,0 +1,88 @@
+module Vinyl
+
+  def self.when_route(route, *args)
+    Rule.add(route, args[0])
+  end
+
+  def self.acl_routes_collection
+    Rule.acl_routes_collection
+  end
+
+  class Rule
+
+    class RegExpHash < Hash
+      def [](a)
+        return super a if a.class == Regexp
+        self.keys.each do |pattern|
+          return super pattern if a.respond_to?(:match) && a.match(pattern)
+        end
+        return nil
+      end
+    end
+
+    @@acl_routes_collection = RegExpHash.new
+
+    def self.add(route, *args) 
+      begin
+        method = args[0][:with_method]
+        access_level = args[0][:get_access_level]
+        validators = args[0][:if_pass]
+        if(route.empty? || method.empty? || access_level.to_s.empty?) then
+          raise InvalidAclRule, "Vinyl.rule is invalid"
+        end
+      rescue NoMethodError => e
+        raise InvalidAclRule, "Vinyl.rule is invalid"
+      rescue InvalidAclRule => e
+        puts e.message
+        puts e.backtrace
+      end
+      pattern = generate_pattern(route)
+      @@acl_routes_collection[pattern] ||= Hash.new
+      @@acl_routes_collection[pattern][method] ||= Hash.new
+      @@acl_routes_collection[pattern][method][access_level] = validators
+    end
+
+    def self.generate_pattern(path)
+      if path.respond_to? :to_str
+        ignore = ""
+        pattern = path.to_str.gsub(/[^\?\%\\\/\:\*\w]/) do |c|
+          ignore << escaped(c).join if c.match(/[\.@]/)
+          encoded(c)
+        end
+        pattern.gsub!(/((:\w+)|\*)/) do |match|
+          if match == "*"
+            "(.*?)"
+          else
+            "([^#{ignore}/?#]+)"
+          end
+        end
+        /\A#{pattern}\z/
+      elsif path.respond_to?(:keys) && path.respond_to?(:match)
+        path
+      elsif path.respond_to?(:names) && path.respond_to?(:match)
+        path
+      elsif path.respond_to? :match
+        path
+      else
+        raise TypeError, path
+      end
+    end
+
+    def self.escaped(char, enc = URI.escape(char))
+      [Regexp.escape(enc), URI.escape(char, /./)]
+    end
+
+    def self.encoded(char)
+      enc = URI.escape(char)
+      enc = "(?:#{escaped(char, enc).join('|')})" if enc == char
+      enc = "(?:#{enc}|#{encoded('+')})" if char == " "
+      enc
+    end
+
+    def self.acl_routes_collection
+        @@acl_routes_collection
+    end
+  end
+
+  class InvalidAclRule < StandardError; end
+end

data/lib/vinyl/validator.rb

@@ -0,0 +1,72 @@
+module Vinyl
+
+  def self.add_validator(name,block)
+    Validators.module_eval{define_singleton_method(Validators.prefix + name,block)}
+  end
+
+  def self.add_global_validator(name,block)
+    Validators.module_eval{define_singleton_method(Validators.prefix + name,block)}
+    global_validators << name
+  end
+
+  def self.execute(name)
+    Validators.send(Validators.prefix + name)
+  end
+
+  def self.bypass(names)
+    Validators.exclude_global_validator(names)
+    self
+  end
+
+  def self.global_validators
+    Validators.global_validators
+  end
+
+  module Validators
+    
+    @@prefix = "validator_"#use prefixs to avoid collisions betweeen variables and methods names
+    @@exclusion_list = []
+    
+    def self.prefix
+      @@prefix
+    end
+    
+    def self.global_validators
+      @@global_validators ||= Array.new
+    end
+
+    def self.exclude_global_validator(name)
+      name = ["#{name}"] if name.instance_of? String
+      @@exclusion_list |= name
+    end
+
+
+    def self.clean_exclusion_list
+      @@exclusion_list = Array.new
+    end
+
+    def self.run_validators(validators)
+      validators = validators + (Vinyl.global_validators - @@exclusion_list)
+      clean_exclusion_list
+      if validators.nil? || validators.empty? then
+        return !Vinyl.config.force_access_control
+      end
+      validators.each do |method_name|
+        pass = Vinyl::Validators.send(prefix + method_name)
+        if(pass == false) then
+          return false
+        end
+      end
+      return true
+    end
+
+    def self.method_missing(*args) #Return false if no validator exists
+      if (Vinyl::controller.variables.include?(args[0])) then
+        return Vinyl::get(args[0])
+      else
+        STDOUT.puts "Warning: missing method #{args[0]}, Validator defaults to false" if Vinyl.config.warn_on_missing_validators
+        return false
+      end
+    end
+  end
+end

data/lib/vinyl/variables.rb

@@ -0,0 +1,41 @@
+module Vinyl
+
+  def self.put(variable)
+    controller.put(variable)
+    return self
+  end
+
+  def self.get(value)
+    controller.variables[value]
+  end
+
+  def self.reset_variables
+    controller.variables.clear
+  end
+
+  def self.controller
+    @@user_variables ||=UserVariables.new
+  end
+
+  def self.method_missing(*args)
+    if args.length == 2 then #set value
+      Vinyl::put ({args[0].to_s.chomp('=').to_sym => args[1]})
+    elsif args.length == 1 #return value
+      return Vinyl::get(args.first)
+    else
+      super
+    end
+  end
+
+  class UserVariables
+    attr_reader :variables
+
+    def initialize
+      @variables = Hash.new 
+    end
+
+    def put(variable)
+      @variables.merge!(variable)
+    end
+  end
+end

data/lib/vinyl/version.rb

@@ -0,0 +1,4 @@
+module Vinyl
+  VERSION = "0.0.1"
+end
+  

data/tests/gem_spec.rb

@@ -0,0 +1,5 @@
+require_relative 'spec_helper'
+require_relative 'rules_spec'
+require_relative 'variables_spec'
+require_relative 'validators_spec'
+require_relative 'vinyl_spec'

data/tests/rules_spec.rb

@@ -0,0 +1,32 @@
+describe Vinyl::Rule do
+
+  it "should add route to Vinyl" do
+    Vinyl::when_route 'test', :with_method => 'POST', :get_access_level => 1, 
+      :if_pass => ['validator']
+
+    Vinyl.acl_routes_collection.should_not be_empty  
+    Vinyl.acl_routes_collection.length.should == 1
+  end
+
+  it "should add multiple access level to route" do
+    Vinyl::when_route 'test', :with_method => 'POST', :get_access_level => 1, 
+      :if_pass => ['validator','bad_guy']
+    Vinyl::when_route 'test', :with_method => 'POST', :get_access_level => 2, 
+      :if_pass => ['validator']
+    Vinyl::when_route 'test', :with_method => 'POST', :get_access_level => 3, 
+      :if_pass => []
+    
+    Vinyl.acl_routes_collection['test'].should_not be_empty  
+    Vinyl.acl_routes_collection.length.should == 1
+    Vinyl.acl_routes_collection['test'].should include("POST")
+    Vinyl.acl_routes_collection['test']['POST'].length.should == 3
+  end
+
+  it "should add a route with a non-existent validator" do
+    Vinyl::when_route 'test', :with_method => 'GET', :get_access_level => 1, 
+      :if_pass => ['fake_validator']
+    Vinyl.acl_routes_collection['test'].should include("GET")
+    Vinyl.acl_routes_collection['test']['GET'].length.should == 1
+    Vinyl.execute('fake_validator').should be_false
+  end
+end

data/tests/spec_helper.rb

@@ -0,0 +1,15 @@
+ENV['RACK_ENV'] = "test"
+require 'bundler/setup'
+#require 'rack/test'
+
+require 'vinyl'
+
+RSpec.configure do |config|
+  #config.include Rack::Test::Methods
+end
+
+Vinyl::configure do |config|
+  config.api_acl_mode = Vinyl::Configuration::STRATEGY_DESCENDING
+  config.force_access_control = true #Deny access if no validators are given for a route/method combination and no global validators exist
+  config.warn_on_missing_validators = false
+end

data/tests/validators_spec.rb

@@ -0,0 +1,19 @@
+describe "Validators" do
+
+  it "should add some validators to Vinyl" do
+    Vinyl.add_validator('validator', lambda{
+      return some_arbitrary_value && hash_value == Hash.new
+      })
+    Vinyl.execute('validator').should be_true
+    Vinyl.add_validator('bad_guy', lambda{
+      return false
+      })
+    Vinyl.execute('bad_guy').should be_false
+  end
+
+  it "should return nil if there has been defined a variable with nil value" do
+    Vinyl.some_nil_variable = nil
+    Vinyl::Validators.some_nil_variable.should be_nil
+    Vinyl::Validators.non_set_value.should be_false
+  end
+end

data/tests/variables_spec.rb

@@ -0,0 +1,35 @@
+describe Vinyl::UserVariables do
+
+  before do
+    $string_variable = "Test string"
+    $hash_variable = Hash.new
+  end
+
+  it "should define some variables and reset them all" do
+    Vinyl.here_is_one_variable = "Some value"
+    Vinyl.some_arbitrary_value = true
+    Vinyl.string_value = $string_variable
+    Vinyl.hash_value = $hash_variable
+    Vinyl.controller.variables.length.should == 4
+    Vinyl.reset_variables
+    Vinyl.controller.variables.length.should == 0
+  end
+
+  it "should add some variables to be used by validators" do
+    Vinyl.some_arbitrary_value = true
+    Vinyl.string_value = $string_variable
+    Vinyl.hash_value = $hash_variable
+    Vinyl.controller.variables.length.should == 3
+  end
+
+  it "should be able to access to previous defined variables"  do
+    Vinyl.some_arbitrary_value.should be_true
+    Vinyl.string_value.should eq $string_variable
+    Vinyl.hash_value.should == $hash_variable
+  end
+
+  it "should be able to assign and retrieve null values" do
+    Vinyl.variable_im_setting_nil = nil
+    Vinyl.variable_im_setting_nil.should be_nil
+  end
+end

data/tests/vinyl_spec.rb

@@ -0,0 +1,65 @@
+describe "Vinyl.Access control" do
+
+  it "should deny access to non configured routes if force_access_control is enabled" do
+    Vinyl::configure do |config|
+      config.force_access_control = false
+    end    
+    access_level = Vinyl.check_level('fake_route','GET')
+    access_level.should == 1
+    Vinyl::configure do |config|
+      config.force_access_control = true
+    end    
+    access_level = Vinyl.check_level('fake_route','GET')
+    access_level.should == 0
+  end
+
+  it "should force access control in abscence of validators" do
+    access_level = Vinyl.check_level('test','POST')
+    access_level.should == 2
+    Vinyl::configure do |config|
+      config.force_access_control = false
+    end    
+    access_level = Vinyl.check_level('test','POST')
+    access_level.should == 3
+  end
+
+  it "should add a global validator to Vinyl" do
+    global_validator_name = "global_validator"
+    Vinyl.add_global_validator(global_validator_name,lambda{return true})
+    result = Vinyl.execute(global_validator_name)
+    result.should be_true
+  end
+
+  it "should fail with global validator" do
+    Vinyl::global_validator_return = false
+    Vinyl.add_global_validator("global_validator_name2",lambda{return global_validator_return})
+    access_level = Vinyl.check_level('test','POST')
+    access_level.should == 0
+  end
+  
+  it "should bypass global validator" do
+    access_level = Vinyl.bypass("global_validator_name2").check_level('test','POST')
+    access_level.should == 3
+    access_level = Vinyl.check_level('test','POST')
+    access_level.should == 0
+    Vinyl::global_validator_return = true
+  end
+  
+  it "should return grant access levels according to validators" do
+    access_level = Vinyl.check_level('test','POST')
+    access_level.should == 3
+  end
+
+  it "should deny access to routes with non-existent validators" do
+    access_level = Vinyl.check_level('test','GET')
+    access_level.should == 0
+  end
+
+  it "should deny access after changing strategy" do
+    Vinyl::configure do |config|
+      config.api_acl_mode = Vinyl::Configuration::STRATEGY_ASCENDING
+    end
+    access_level = Vinyl.check_level('test','POST')
+    access_level.should == 0
+  end
+end

data/vinyl.gemspec

@@ -0,0 +1,19 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "vinyl/version"
+
+Gem::Specification.new do |gem|
+  gem.name          = "vinyl"
+  gem.authors       = ["Federico Saravia Barrantes", "Lautaro Orazi"]
+  gem.email         = ["vinyl.dev@gmail.com"]
+  gem.description   = %q{Custom access level for resources}
+  gem.summary       = %q{Custom access level for resources}
+  gem.homepage      = "http://tarolandia.github.com/vinyl/"
+  gem.version       = Vinyl::VERSION
+
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.require_paths = ["lib"]
+
+  gem.add_development_dependency 'rspec', '~> 2.7'
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: vinyl
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Federico Saravia Barrantes
+- Lautaro Orazi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.7'
+description: Custom access level for resources
+email:
+- vinyl.dev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- UNLICENSE
+- examples/.gitkeep
+- examples/usage_example.rb
+- lib/vinyl.rb
+- lib/vinyl/.gitkeep
+- lib/vinyl/base.rb
+- lib/vinyl/rule.rb
+- lib/vinyl/validator.rb
+- lib/vinyl/variables.rb
+- lib/vinyl/version.rb
+- tests/.gitkeep
+- tests/gem_spec.rb
+- tests/rules_spec.rb
+- tests/spec_helper.rb
+- tests/validators_spec.rb
+- tests/variables_spec.rb
+- tests/vinyl_spec.rb
+- vinyl.gemspec
+homepage: http://tarolandia.github.com/vinyl/
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Custom access level for resources
+test_files: []
+has_rdoc: