data_guru 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8c8667440f7886044b541e700f46712c984955f9
+  data.tar.gz: 744434dea8207c0c22e68762f7e47414ce2cd518
+SHA512:
+  metadata.gz: c4d50f066499af43eb6aaba731c66b8c129462469248e9a33d25384bf189af9545f3f07f19a62f5da48d700fed8648b7090f9e097c2a6d0fbb1d799ded36f902
+  data.tar.gz: 984c11f90833f18b5ce17fae93e813a7613df62fbe6ac295fd4e9c8217dfd0ae057567a4060ee1ffa275d77df1ee2acacf6b6ed6bc142ff0a39969bd0827b2a7

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--order rand

data/.rubocop.yml

@@ -0,0 +1,10 @@
+Metrics/LineLength:
+  Exclude:
+    - '*.gemspec'
+Documentation:
+  Enabled: false
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+Style/TrailingComma:
+  EnforcedStyleForMultiline: comma
+  Enabled: true

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.10.6

data/Gemfile

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

data/README.md

@@ -0,0 +1,133 @@
+# DataGuru
+
+Manage configuration stored as JSON data in DataGuru-API server.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'data_guru'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install data_guru
+
+## Configuration
+
+Create config file in your app:
+
+```ruby
+# app/config/initializers/data_guru.rb
+DataGuru.configure do |config|
+  config.api_url      = 'url of api server'
+  config.access_token = 'access token'
+end
+```
+
+Possible configuration values:
+
+`api_url` - *[mandatory]* api server where data from Permissions is stored
+
+`access_token` - *[mandatory]* token needed for verifying access to api server
+
+## Usage
+
+If you use default config files (see Permissions section below) you can simply do:
+
+```ruby
+data = DataGuru::Client.new
+
+# get collections
+data.users.all
+data.projects.all
+data.github_teams.all
+data.google_groups.all
+data.rollbar_teams.all
+data.toggl_teams.all
+
+# find in collections by attribute
+data.projects.find{ |project| project.display_name == 'Some project' }
+data.users.find{ |user| user.github == 'example' }
+
+# filter through collections by attributes
+data.users.select{ |user| user.external }
+data.users.select{ |user| user.public_key.nil? }.count
+
+# select key names of all github teams user belongs to
+user = data.users.first
+data.github_teams.select{ |team| team.members.include?(user.id) }.map(&:id)
+```
+
+The collections have `Enumerable` module included so you can filter models by attributes easily (`data.users.select{ |user| user.some_method }`)
+
+You can refresh repo and storage at any time, just do:
+
+```ruby
+data = DataGuru::Client.new
+data.refresh
+```
+
+On a single model you can do:
+
+```ruby
+data = DataGuru::Client.new
+user = data.users.all.first
+
+# to get list of user attributes
+user.attributes
+
+# to get list of permitted and required attributes (see Permisions section below)
+user.permitted_attributes
+user.required_attributes
+
+# check if user has all required attributes set
+user.valid?
+user.missing_attributes
+```
+
+Each model has a set of getter methods (permitted_attributes) so you can for example do `user.github` to get just the github username of the user.
+Each model also has `id` method which returns the name of the file, for example for the user in a file `john.doe.yml` will return `john.doe`.
+
+You can check whether configuration (in your rails app) and model configuration (in your permissions repo) is valid by running `DataGuru::Client.new.errors`.
+
+### Permissions
+
+A sample permissions repo contains a `config` directory with files like `user.yml`, `project.yml`, `github_team.yml`. In these files you specify attributes for each model with information about whether they are required, what is the default value and what type of value it is.
+
+```
+---
+name:
+  required: true
+  default_value:
+  value_type: string
+emails:
+  required: true
+  default_value:
+  value_type: array
+external:
+  required: false
+  default_value: false
+  value_type: boolean
+```
+
+The methods `permitted_attributes` and `required_attributes` returns the array of specified attributes.
+
+All the files should be under the appropriate directory, for example all users under `users` directory, they can be nested if you want.
+
+For more information see the [permissions template repo](https://github.com/ardhena/permissions-template).
+
+## Development
+
+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.
+
+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).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/netguru/data_guru.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "data_guru"
+require "pry"
+
+Pry.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/data_guru.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "data_guru/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "data_guru"
+  spec.version       = DataGuru::VERSION
+  spec.authors       = ["Adam Nowak", "Katarzyna Jaskólska", "Jacek Adamek"]
+  spec.email         = ["adam.nowak@netguru.co", "katarzyna.jaskolska@netguru.co", "jacek.adamek@netguru.co"]
+
+  spec.summary       = "Wrapper for data stored in YAML files"
+  spec.homepage      = "https://github.com/netguru/data_guru"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport"
+  spec.add_dependency "git"
+  spec.add_dependency "httparty"
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rubocop"
+end

data/lib/data_guru/client.rb

@@ -0,0 +1,81 @@
+module DataGuru
+  class Client
+    require 'httparty'
+    require 'active_support/core_ext/string'
+
+    def method_missing(name)
+      create_model_class(name) if should_create_class?(name)
+      value = DataGuru::Collection.new(collection_name: name, model: model(name))
+      get_variable(name) || set_variable(name, value)
+    end
+
+    def refresh
+      HTTParty.get(refresh_data_url)
+      wipe_collections_cache
+    end
+
+    def errors
+      DataGuru::Validation.new.errors
+    end
+
+    private
+
+    def should_create_class?(name)
+      name_exists?(name) && !class_exists?(class_name(name))
+    end
+
+    def create_model_class(name)
+      DataGuru.const_set(class_name(name), Class.new { include Model })
+    end
+
+    def class_name(name)
+      name.to_s.camelize.singularize
+    end
+
+    def class_exists?(class_name)
+      eval("defined?(#{class_name}) && #{class_name}.is_a?(Class)")
+    end
+
+    def name_exists?(name)
+      collection_names.include?(name.to_s)
+    end
+
+    def model(name)
+      "data_guru/#{name}".classify.constantize
+    rescue NameError
+      raise "Collection '#{name}' does not exist"
+    end
+
+    def get_variable(name)
+      instance_variable_get("@#{name}")
+    end
+
+    def set_variable(name, value)
+      instance_variable_set("@#{name}", value)
+    end
+
+    def wipe_collections_cache
+      collection_names.each { |name| instance_variable_set("@#{name}", nil) }
+    end
+
+    def access_token
+      DataGuru.config.access_token
+    end
+
+    def api_url
+      DataGuru.config.api_url
+    end
+
+    def refresh_data_url
+      "#{api_url}/refresh?token=#{access_token}"
+    end
+
+    def collection_names
+      HTTParty.get(collection_names_url)
+    end
+
+    def collection_names_url
+      "#{api_url}/?token=#{access_token}"
+    end
+  end
+end

data/lib/data_guru/collection.rb

@@ -0,0 +1,58 @@
+module DataGuru
+  class Collection
+    include Enumerable
+    require 'httparty'
+
+    attr_reader :collection_name, :model, :config
+
+    def initialize(collection_name:, model:, config: default_config(model))
+      @collection_name = collection_name
+      @model = model
+      @config = config
+    end
+
+    def all
+      @all ||= build_models(collection_name)
+    end
+
+    def each(&block)
+      all.each(&block)
+    end
+
+    private
+
+    def default_config(model)
+      DataGuru::ModelConfiguration.new(model: model)
+    end
+
+    def build_models(collection_type)
+      data(collection_type).map do |key, data|
+        model.new(key, data, config, config_data)
+      end
+    end
+
+    def access_token
+      DataGuru.config.access_token
+    end
+
+    def api_url
+      DataGuru.config.api_url
+    end
+
+    def collection_resource_url(collection_type)
+      "#{api_url}/#{collection_type}?token=#{access_token}"
+    end
+
+    def config_resource_url
+      "#{api_url}/config?token=#{access_token}"
+    end
+
+    def config_data
+      @config_data ||= HTTParty.get(config_resource_url)
+    end
+
+    def data(collection_type)
+      HTTParty.get(collection_resource_url(collection_type))
+    end
+  end
+end

data/lib/data_guru/configuration.rb

@@ -0,0 +1,10 @@
+module DataGuru
+  class Configuration
+    attr_accessor :api_url, :access_token
+
+    def initialize
+      @api_url = nil
+      @access_token = nil
+    end
+  end
+end

data/lib/data_guru/model.rb

@@ -0,0 +1,54 @@
+module DataGuru
+  module Model
+    attr_reader :permitted_attributes, :required_attributes, :id
+
+    def initialize(key, attrs, config, config_data)
+      @id = key
+      @permitted_attributes = config.permitted_attributes(config_data)
+      @required_attributes = config.required_attributes(config_data)
+
+      permitted_attributes.each do |attribute|
+        set_attr_getter(attribute)
+        default_value = config.attributes(config_data)[attribute.to_s]["default_value"]
+        set_attr_value(attribute, attrs[attribute.to_s], default_value)
+      end
+    end
+
+    def attributes
+      @attributes ||= all_attributes
+    end
+
+    def valid?
+      present_required_attributes == required_attributes
+    end
+
+    def missing_attributes
+      required_attributes - present_required_attributes
+    end
+
+    private
+
+    def set_attr_getter(attribute)
+      self.class.send(:define_method, attribute) do
+        instance_variable_get("@#{attribute}")
+      end
+    end
+
+    def set_attr_value(attribute, value, default_value)
+      value_to_set = value.nil? ? default_value : value
+      instance_variable_set("@#{attribute}", value_to_set)
+    end
+
+    def present_required_attributes
+      required_attributes.map do |name|
+        !attributes[name].nil? ? name : nil
+      end
+    end
+
+    def all_attributes
+      attrs = permitted_attributes
+        .map{ |name| [name, public_send(name)] } << [:id, id]
+      Hash[attrs]
+    end
+  end
+end

data/lib/data_guru/model_configuration.rb

@@ -0,0 +1,32 @@
+module DataGuru
+  class ModelConfiguration
+    attr_reader :model, :model_name
+
+    def initialize(model:, model_name: default_model_name(model))
+      @model = model
+      @model_name = model_name
+    end
+
+    def attributes(config_data)
+      config_data[model_name]
+    end
+
+    def permitted_attributes(config_data)
+      attributes(config_data).map{ |k, _v| k.to_sym }
+    end
+
+    def required_attributes(config_data)
+      attributes(config_data).map{ |k, v| v["required"] ? k.to_sym : nil }.reject(&:nil?)
+    end
+
+    private
+
+    def default_model_name(model)
+      model.name.split('::').last
+        .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        .gsub(/([a-z\d])([A-Z])/,'\1_\2')
+        .tr("-", "_")
+        .downcase
+    end
+  end
+end

data/lib/data_guru/validation.rb

@@ -0,0 +1,51 @@
+module DataGuru
+  class Validation
+    require 'httparty'
+    attr_reader :config, :keys
+
+    TYPES = %w(configuration model_configuration)
+
+    def initialize
+      @config = config_data
+      @keys = keys
+    end
+
+    def errors
+      TYPES.flat_map{ |type| send("#{type}_errors") }
+    end
+
+    private
+
+    def config_data
+      HTTParty.get(config_resource_url)
+    end
+
+    def config_resource_url
+      "#{api_url}/config?token=#{access_token}"
+    end
+
+    def api_url
+      DataGuru.config.api_url
+    end
+
+    def access_token
+      DataGuru.config.access_token
+    end
+
+    def keys
+      HTTParty.get(keys_resource_url)
+    end
+
+    def keys_resource_url
+      "#{api_url}?token=#{access_token}"
+    end
+
+    def configuration_errors
+      DataGuru::ConfigurationValidation.new.errors
+    end
+
+    def model_configuration_errors
+      DataGuru::ModelConfigurationValidation.new(config, keys).errors
+    end
+  end
+end

data/lib/data_guru/validations/configuration.rb

@@ -0,0 +1,37 @@
+module DataGuru
+  class ConfigurationValidation
+    VALIDATIONS = %w(api_url access_token)
+
+    def errors
+      return [] if valid?
+      build_errors
+    end
+
+    private
+
+    def valid?
+      api_url_valid? && access_token_valid?
+    end
+
+    def build_errors
+      VALIDATIONS.flat_map do |name|
+        send("#{name}_valid?") ? [] : send("#{name}_error")
+      end
+    end
+
+    VALIDATIONS.each do |name|
+      # def api_url_valid?, access_token_valid?
+      define_method("#{name}_valid?") do
+        !DataGuru.config.public_send(name).nil?
+      end
+    end
+
+    def api_url_error
+      'Configuration: no api url'
+    end
+
+    def access_token_error
+      'Configuration: no access token'
+    end
+  end
+end

data/lib/data_guru/validations/model_configuration.rb

@@ -0,0 +1,139 @@
+module DataGuru
+  class ModelConfigurationValidation
+    attr_reader :config, :keys
+
+    VALIDATIONS = %w(config model_file model_attributes model_attribute_name
+      model_attribute_content)
+    RESERVED_WORDS = %w(id attributes permitted_attributes required_attributes
+      missing_attributes valid?)
+    ATTRIBUTE_TYPES = %w(required default_value value_type)
+
+    def initialize(config, keys)
+      @config = config
+      @keys = keys
+    end
+
+    def errors
+      return [] if valid?
+      build_errors
+    end
+
+    private
+
+    def model_names
+      keys.map(&:singularize) - ['config']
+    end
+
+    def valid?
+      config_valid? && model_file_valid? && model_attributes_valid? &&
+        model_attribute_name_valid? && model_attribute_content_valid?
+    end
+
+    def build_errors
+      VALIDATIONS.flat_map do |name|
+        send("#{name}_valid?") ? [] : send("#{name}_error")
+      end
+    end
+
+    def config_valid?
+      keys.include?('config')
+    end
+
+    def model_file_valid?
+      return false unless config_valid?
+      valid_files = model_names
+        .map{ |name| config.include?(name) }
+        .select{ |name| name }
+      valid_files.size == model_names.size
+    end
+
+    def model_attributes_valid?
+      return false unless model_file_valid?
+      valid_models = model_names
+        .map{ |name| config[name] == false || config[name].nil? }
+        .select{ |name| !name }
+      valid_models.size == model_names.size
+    end
+
+    def model_attribute_name_valid?
+      attributes = present_models.flat_map{ |model| config[model].keys }
+      diff = attributes - RESERVED_WORDS
+      attributes.count == diff.count
+    end
+
+    def model_attribute_content_valid?
+      attributes = present_models.map{ |model| config[model] }
+      invalid_attrs = attributes.flat_map{ |model|
+          model.values.map{ |attributes| attributes.keys.sort == ATTRIBUTE_TYPES.sort }
+        }.select{ |a| !a }
+      invalid_attrs.size == 0
+    end
+
+    def config_error
+      'Model Configuration: no config directory in repo'
+    end
+
+    def model_file_error
+      "Model Configuration: no config file for model - #{missing_models.join(', ')}"
+    end
+
+    def model_attributes_error
+      "Model Configuration: no permitted attributes for model - #{missing_model_contents.join(', ')}"
+    end
+
+    def model_attribute_name_error
+      reserved_model_attributes.map do |model, attrs|
+        "Model Configuration: reserved words used as attributes in model #{model} - #{attrs.join(', ')}"
+      end
+    end
+
+    def model_attribute_content_error
+      missing_model_attributes.flat_map do |model, attrs|
+        attrs.map do |name, type|
+          attributes = "attribute #{name} missing #{type.join(', ')}"
+          "Model Configuration: missing attribute declaration in model #{model} - #{attributes}"
+        end
+      end
+    end
+
+    def missing_models
+      return model_names unless config_valid?
+      model_names.flat_map{ |name| config.include?(name) ? [] : name }
+    end
+
+    def missing_model_contents
+      return model_names unless config_valid?
+      model_names.flat_map do |name|
+        if missing_models.include?(name)
+          name
+        else
+          config[name] == false || config[name].nil? ? name : []
+        end
+      end
+    end
+
+    def present_models
+      model_names - missing_model_contents
+    end
+
+    def reserved_model_attributes
+      wrong_attributes = present_models.map do |model|
+        wrong_attrs = config[model].keys & RESERVED_WORDS
+        [ model, wrong_attrs ]
+      end
+      Hash[wrong_attributes]
+    end
+
+    def missing_model_attributes
+      all = Hash[present_models.map{ |model| [model, config[model]] }]
+      missing = all.map do |model, attributes|
+          attrs = Hash[ attributes.map{ |name, types| [name, ATTRIBUTE_TYPES - types.keys] } ]
+          without_empty = attrs
+            .map{ |name, types| types.empty? ? [] : [name, types] }
+            .reject{ |array| array.empty? }
+          [ model, Hash[without_empty] ]
+        end
+      Hash[missing.reject{ |k, v| v.empty? }]
+    end
+  end
+end

data/lib/data_guru/version.rb

@@ -0,0 +1,3 @@
+module DataGuru
+  VERSION = "0.3.0"
+end

data/lib/data_guru.rb

@@ -0,0 +1,31 @@
+require "data_guru/version"
+require "data_guru/configuration"
+require "data_guru/model_configuration"
+
+require "data_guru/validation"
+require "data_guru/validations/configuration"
+require "data_guru/validations/model_configuration"
+
+require "data_guru/collection"
+
+require "data_guru/model"
+
+require "data_guru/client"
+
+module DataGuru
+  class << self
+    attr_accessor :config
+  end
+
+  def self.config
+    @config ||= Configuration.new
+  end
+
+  def self.configure
+    yield(config)
+  end
+
+  def self.reset
+    @config = Configuration.new
+  end
+end

metadata

@@ -0,0 +1,179 @@
+--- !ruby/object:Gem::Specification
+name: data_guru
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Adam Nowak
+- Katarzyna Jaskólska
+- Jacek Adamek
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-10-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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'
+- !ruby/object:Gem::Dependency
+  name: git
+  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'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  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'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- adam.nowak@netguru.co
+- katarzyna.jaskolska@netguru.co
+- jacek.adamek@netguru.co
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- data_guru.gemspec
+- lib/data_guru.rb
+- lib/data_guru/client.rb
+- lib/data_guru/collection.rb
+- lib/data_guru/configuration.rb
+- lib/data_guru/model.rb
+- lib/data_guru/model_configuration.rb
+- lib/data_guru/validation.rb
+- lib/data_guru/validations/configuration.rb
+- lib/data_guru/validations/model_configuration.rb
+- lib/data_guru/version.rb
+homepage: https://github.com/netguru/data_guru
+licenses: []
+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.8
+signing_key: 
+specification_version: 4
+summary: Wrapper for data stored in YAML files
+test_files: []