varia_model 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3-p429

data/.travis.yml

@@ -0,0 +1,7 @@
+script: "bundle exec thor spec"
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - jruby-19mode

data/Gemfile

@@ -0,0 +1,29 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'buff-extensions', path: '~/code/buff-extensions'
+
+group :development do
+  gem 'coolline'
+
+  require 'rbconfig'
+
+  if RbConfig::CONFIG['target_os'] =~ /darwin/i
+    gem 'growl', require: false
+    gem 'rb-fsevent', require: false
+
+    if `uname`.strip == 'Darwin' && `sw_vers -productVersion`.strip >= '10.8'
+      gem 'terminal-notifier-guard', '~> 1.5.3', require: false
+    end rescue Errno::ENOENT
+
+  elsif RbConfig::CONFIG['target_os'] =~ /linux/i
+    gem 'libnotify',  '~> 0.8.0', require: false
+    gem 'rb-inotify', require: false
+
+  elsif RbConfig::CONFIG['target_os'] =~ /mswin|mingw/i
+    gem 'win32console', require: false
+    gem 'rb-notifu', '>= 0.0.4', require: false
+    gem 'wdm', require: false
+  end
+end

data/Guardfile

@@ -0,0 +1,18 @@
+notification :off
+interactor :coolline
+
+guard 'spork' do
+  watch('Gemfile')
+  watch('spec/spec_helper.rb')     { :rspec }
+  watch(%r{^spec/support/.+\.rb$}) { :rspec }
+end
+
+guard 'rspec', version: 2, cli: "--color --drb --format Fuubar", all_on_start: false, all_after_pass: false do
+  watch(%r{^spec/unit/.+_spec\.rb$})
+  watch(%r{^spec/acceptance/.+_spec\.rb$})
+
+  watch(%r{^lib/(.+)\.rb$})                     { |m| "spec/unit/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')                  { "spec" }
+  watch(%r{^spec/support/.+\.rb$})              { "spec" }
+  watch(%r{^spec/shared_examples/(.*)\.rb$})    { |m| ["spec/unit/#{m[1]}_spec.rb", "spec/unit/#{m[1]}"] }
+end

data/LICENSE

@@ -0,0 +1,15 @@
+Copyright 2012-2013 Riot Games
+
+    Jamie Winsor (<reset@riotgames.com>)
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,25 @@
+# VariaModel
+[![Gem Version](https://badge.fury.io/rb/varia_model.png)](http://badge.fury.io/rb/varia_model)
+[![Build Status](https://secure.travis-ci.org/RiotGames/varia_model.png?branch=master)](http://travis-ci.org/RiotGames/varia_model)
+
+A mixin to provide objects with magic attribute reading and writing
+
+## Installation
+
+    $ gem install varia_model
+
+## Usage
+
+    require 'varia_model'
+
+    module MyApp
+      class Config
+        include VariaModel
+      end
+    end
+
+# Authors and Contributors
+
+* Jamie Winsor (<reset@riotgames.com>)
+
+Thank you to all of our [Contributors](https://github.com/RiotGames/buff-extensions/graphs/contributors), testers, and users.

data/Thorfile

@@ -0,0 +1,43 @@
+# encoding: utf-8
+$:.push File.expand_path("../lib", __FILE__)
+
+require 'bundler'
+require 'bundler/setup'
+require 'buff/ruby_engine'
+require 'varia_model'
+
+class Default < Thor
+  extend Buff::RubyEngine
+
+  unless jruby?
+    require 'thor/rake_compat'
+
+    include Thor::RakeCompat
+    Bundler::GemHelper.install_tasks
+
+    desc "build", "Build varia_model-#{VariaModel::VERSION}.gem into the pkg directory"
+    def build
+      Rake::Task["build"].execute
+    end
+
+    desc "install", "Build and install varia_model-#{VariaModel::VERSION}.gem into system gems"
+    def install
+      Rake::Task["install"].execute
+    end
+
+    desc "release", "Create tag v#{VariaModel::VERSION} and build and push varia_model-#{VariaModel::VERSION}.gem to Rubygems"
+    def release
+      Rake::Task["release"].execute
+    end
+  end
+
+  class Spec < Thor
+    namespace :spec
+    default_task :all
+
+    desc "all", "run all tests"
+    def all
+      exec "rspec --color --format=documentation spec"
+    end
+  end
+end

data/lib/varia_model/attributes.rb

@@ -0,0 +1,52 @@
+require 'hashie'
+require 'hashie/hash_extensions'
+require 'hashie/mash'
+
+module VariaModel
+  class Attributes < Hashie::Mash
+    alias_method :old_setter, :[]=
+    alias_method :old_dup, :dup
+
+    attr_writer :coercions
+
+    # @return [Hashie::Mash]
+    def coercions
+      @coercions ||= Hashie::Mash.new
+    end
+
+    def coercion(key)
+      self.coercions[key]
+    end
+
+    def set_coercion(key, fun)
+      self.coercions[key] = fun
+    end
+
+    # Override setter to coerce the given value if a coercion is defined
+    def []=(key, value)
+      coerced_value = coercion(key).present? ? coercion(key).call(value) : value
+      old_setter(key, coerced_value)
+    end
+
+    # Return the containing Hashie::Mash of the given dotted path
+    #
+    # @param [String] path
+    #
+    # @return [Hashie::Mash, nil]
+    def container(path)
+      parts = path.split('.', 2)
+      match = (self[parts[0].to_s] || self[parts[0].to_sym])
+      if !parts[1] or match.nil?
+        self
+      else
+        match.container(parts[1])
+      end
+    end
+
+    def dup
+      mash = old_dup
+      mash.coercions = self.coercions
+      mash
+    end
+  end
+end

data/lib/varia_model/version.rb

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

data/lib/varia_model.rb

@@ -0,0 +1,284 @@
+require 'buff/extensions'
+require 'json'
+
+module VariaModel
+  require_relative 'varia_model/version'
+  require_relative 'varia_model/attributes'
+
+  module ClassMethods
+    ASSIGNMENT_MODES = [
+      :whitelist,
+      :carefree
+    ]
+
+    # @return [VariaModel::Attributes]
+    def attributes
+      @attributes ||= Attributes.new
+    end
+
+    # @return [Hashie::Mash]
+    def validations
+      @validations ||= Hashie::Mash.new
+    end
+
+    # @return [Symbol]
+    def assignment_mode
+      @assignment_mode ||= :whitelist
+    end
+
+    # Set the attribute mass assignment mode
+    #   * :whitelist - only attributes defined on the class will have values set
+    #   * :carefree  - values will be set for attributes that are not explicitly defined
+    #                  in the class definition
+    #
+    # @param [Symbol] mode
+    #   an assignment mode to use @see {ASSIGNMENT_MODES}
+    def set_assignment_mode(mode)
+      unless ASSIGNMENT_MODES.include?(mode)
+        raise ArgumentError, "unknown assignment mode: #{mode}"
+      end
+
+      @assignment_mode = mode
+    end
+
+    # @param [#to_s] name
+    # @option options [Symbol, Array<Symbol>] :type
+    # @option options [Boolean] :required
+    # @option options [Object] :default
+    # @option options [Proc] :coerce
+    def attribute(name, options = {})
+      name = name.to_s
+      options[:type] = Array(options[:type])
+      options[:required] ||= false
+
+      register_attribute(name, options)
+      define_mimic_methods(name, options)
+    end
+
+    # @param [String] name
+    #
+    # @return [Array]
+    def validations_for(name)
+      self.validations[name] ||= Array.new
+    end
+
+    # @param [Constant, Array<Constant>] types
+    # @param [VariaModel] model
+    # @param [String] key
+    #
+    # @return [Array]
+    def validate_kind_of(types, model, key)
+      errors  = Array.new
+      types   = types.uniq
+      matches = false
+
+      types.each do |type|
+        if model.get_attribute(key).is_a?(type)
+          matches = true
+          break
+        end
+      end
+
+      if matches
+        [ :ok, "" ]
+      else
+        types_msg = types.collect { |type| "'#{type}'" }
+        [ :error, "Expected attribute: '#{key}' to be a type of: #{types_msg.join(', ')}" ]
+      end
+    end
+
+    # Validate that the attribute on the given model has a non-nil value assigned
+    #
+    # @param [VariaModel] model
+    # @param [String] key
+    #
+    # @return [Array]
+    def validate_required(model, key)
+      if model.get_attribute(key).nil?
+        [ :error, "A value is required for attribute: '#{key}'" ]
+      else
+        [ :ok, "" ]
+      end
+    end
+
+    private
+
+      def register_attribute(name, options = {})
+        if options[:type] && options[:type].any?
+          unless options[:required]
+            options[:type] << NilClass
+          end
+          register_validation(name, lambda { |object, key| validate_kind_of(options[:type], object, key) })
+        end
+
+        if options[:required]
+          register_validation(name, lambda { |object, key| validate_required(object, key) })
+        end
+
+        class_eval do
+          new_attributes = Attributes.from_dotted_path(name, options[:default])
+          self.attributes.merge!(new_attributes)
+
+          if options[:coerce].is_a?(Proc)
+            register_coercion(name, options[:coerce])
+          end
+        end
+      end
+
+      def register_validation(name, fun)
+        self.validations[name] = (self.validations_for(name) << fun)
+      end
+
+      def register_coercion(name, fun)
+        self.attributes.container(name).set_coercion(name.split('.').last, fun)
+      end
+
+      def define_mimic_methods(name, options = {})
+        fun_name = name.split('.').first
+
+        class_eval do
+          define_method(fun_name) do
+            _attributes_[fun_name]
+          end
+
+          define_method("#{fun_name}=") do |value|
+            value = if options[:coerce].is_a?(Proc)
+              options[:coerce].call(value)
+            else
+              value
+            end
+
+            _attributes_[fun_name] = value
+          end
+        end
+      end
+  end
+
+  class << self
+    def included(base)
+      base.extend(ClassMethods)
+    end
+  end
+
+  # @return [Hashie::Mash]
+  def validate
+    self.class.validations.each do |attr_path, validations|
+      validations.each do |validation|
+        status, messages = validation.call(self, attr_path)
+
+        if status == :error
+          if messages.is_a?(Array)
+            messages.each do |message|
+              self.add_error(attr_path, message)
+            end
+          else
+            self.add_error(attr_path, messages)
+          end
+        end
+      end
+    end
+
+    self.errors
+  end
+
+  # @return [Boolean]
+  def valid?
+    validate.empty?
+  end
+
+  # @return [Hashie::Mash]
+  def errors
+    @errors ||= Hashie::Mash.new
+  end
+
+  # Assigns the attributes of a model from a given hash of attributes.
+  #
+  # If the assignment mode is set to `:whitelist`, then only the values of keys which have a
+  # corresponding attribute definition on the model will be set. All other keys will have their
+  # values ignored.
+  #
+  # If the assignment mode is set to `:carefree`, then the attributes hash will be populated
+  # with any key/values that are provided.
+  #
+  # @param [Hash] new_attrs
+  def mass_assign(new_attrs = {})
+    case self.class.assignment_mode
+    when :whitelist
+      whitelist_assign(new_attrs)
+    when :carefree
+      carefree_assign(new_attrs)
+    end
+  end
+
+  # @param [#to_s] key
+  #
+  # @return [Object]
+  def get_attribute(key)
+    _attributes_.dig(key.to_s)
+  end
+  alias_method :[], :get_attribute
+
+  # @param [#to_s] key
+  # @param [Object] value
+  def set_attribute(key, value)
+    _attributes_.deep_merge!(Attributes.from_dotted_path(key.to_s, value))
+  end
+  alias_method :[]=, :set_attribute
+
+  # @param [#to_hash] hash
+  #
+  # @return [self]
+  def from_hash(hash)
+    mass_assign(hash.to_hash)
+    self
+  end
+
+  # @param [String] data
+  #
+  # @return [self]
+  def from_json(data)
+    mass_assign(JSON.load(data))
+    self
+  end
+
+  # The storage hash containing all of the key/values for this object's attributes
+  #
+  # @return [Hashie::Mash]
+  def _attributes_
+    @_attributes_ ||= self.class.attributes.dup
+  end
+  alias_method :to_hash, :_attributes_
+
+  # @option options [Boolean] :symbolize_keys
+  # @option options [Class, Symbol, String] :adapter
+  #
+  # @return [String]
+  def to_json(options = {})
+    JSON.generate(_attributes_, options)
+  end
+  alias_method :as_json, :to_json
+
+  protected
+
+    # @param [String] attribute
+    # @param [String] message
+    def add_error(attribute, message)
+      self.errors[attribute] ||= Array.new
+      self.errors[attribute] << message
+    end
+
+  private
+
+    def carefree_assign(new_attrs = {})
+      _attributes_.deep_merge!(new_attrs)
+    end
+
+    def whitelist_assign(new_attrs = {})
+      self.class.attributes.dotted_paths.each do |dotted_path|
+        value = new_attrs.dig(dotted_path)
+        next if value.nil?
+
+        set_attribute(dotted_path, value)
+      end
+    end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+
+require 'rspec'
+require 'buff/ruby_engine'
+
+def setup_rspec
+  Dir[File.join(File.expand_path("../../spec/support/**/*.rb", __FILE__))].each { |f| require f }
+
+  RSpec.configure do |config|
+    config.expect_with :rspec do |c|
+      c.syntax = :expect
+    end
+
+    config.mock_with :rspec
+    config.treat_symbols_as_metadata_keys_with_true_values = true
+    config.filter_run focus: true
+    config.run_all_when_everything_filtered = true
+  end
+end
+
+if Buff::RubyEngine.jruby?
+  require 'varia_model'
+  setup_rspec
+else
+  require 'spork'
+
+  Spork.prefork { setup_rspec }
+  Spork.each_run { require 'varia_model' }
+end

data/spec/support/matchers/each.rb

@@ -0,0 +1,12 @@
+RSpec::Matchers.define :each do |check|
+  match do |actual|
+    actual.each_with_index do |index, o|
+      @object = o
+      expect(index).to check
+    end
+  end
+
+  failure_message_for_should do |actual|
+    "at[#{@object}] #{check.failure_message_for_should}"
+  end
+end