introspective_grape 0.6.1 → 0.7.0

data/spec/dummy/app/api/error_handlers.rb

@@ -2,27 +2,27 @@ require 'pundit'
 module ErrorHandlers
   def self.included(m)
     m.rescue_from ActiveRecord::RecordInvalid do |e|
-      error_response message: e.record.errors.to_a.uniq.join(', '), status: 400
+      error! e.record.errors.to_a.uniq.join(', '), 400
     end
 
     m.rescue_from Grape::Exceptions::ValidationErrors do |e|
-      error_response message: e.message, status: 400
+      error! e.message, 400
     end
 
     m.rescue_from ActiveRecord::RecordNotFound do |e|
-      error_response message: "Record not found! #{e.message}", status: 404
+      error! "Record not found! #{e.message}", 404
     end
 
     m.rescue_from ActiveRecord::InvalidForeignKey do |e|
-      error_response message: "Join record not found! #{e.message}", status: 404
+      error! "Join record not found! #{e.message}", 404
     end
 
     m.rescue_from Pundit::NotAuthorizedError do
-      error_response message: "Forbidden", status: 403
+      error! "Forbidden", 403
     end
 
     m.rescue_from Pundit::NotDefinedError do
-      error_response message: "Policy not implemented", status: 501
+      error! "Policy not implemented", 501
     end
   end
 end

data/spec/dummy/app/api/permissions_helper.rb

@@ -1,7 +1,7 @@
-require 'pundit'
-module PermissionsHelper
-  # Pundit won't import it's methods unless it sees a stub of ActionController's hide_action.
-  def hide_action; end
-  include Pundit::Authorization
-
-end
+require 'pundit'
+module PermissionsHelper
+  # Pundit won't import it's methods unless it sees a stub of ActionController's hide_action.
+  def hide_action; end
+  include Pundit::Authorization
+
+end

data/spec/dummy/app/helpers/current.rb

@@ -1,3 +1,3 @@
-module Current
-    thread_mattr_accessor :user
-end
+module Current
+    thread_mattr_accessor :user
+end

data/spec/dummy/app/models/abstract_adapter.rb

@@ -1,13 +1,16 @@
 class AbstractAdapter < ActiveRecord::Base
-  self.abstract_class = true
+  primary_abstract_class
 
-  class << self
-    def human_attribute_name(attr, options = {})
-      # The default formatting of validation errors sucks, this helps a little syntatically:
-      super.titleize+":"
-    end
-
-  end
+	class << self
+		def inherited(klass)
+			super
+			klass.validates_by_schema
+		end
 
+		def human_attribute_name(attr, options = {})
+			# The default formatting of validation errors sucks, this helps a little syntatically:
+			super.titleize+":"
+		end
+	end
 end
 

data/spec/dummy/app/models/chat_message.rb

@@ -1,34 +1,34 @@
-class ChatMessage < AbstractAdapter
-  belongs_to :chat
-  belongs_to :author, class_name: 'User'
-
-  has_many :chat_users, through: :chat
-  has_many :recipients, lambda {|message|  where(':created_at >= chat_users.created_at and (chat_users.departed_at IS NULL OR :created_at <= chat_users.departed_at)', created_at: message.created_at ) }, through: :chat_users, source: :user, class_name: 'User'
-
-  # Create ChatUserMessage records for each recipient to track read status
-  has_many :chat_message_users, dependent: :destroy
-
-  validate :author_in_chat
-
-  def author_in_chat
-    errors.add(:base, 'User not in chat session.') unless chat.active_users.include? author
-  end
-
-  before_save :create_message_users, if: :new_record?
-  def create_message_users
-    chat_users.merge(ChatUser.current).each do |cu|
-      chat_message_users.build(user: cu.user)
-    end
-  end
-
-  def read_by?(user)
-    chat_message_users.merge(ChatMessageUser.read).map(&:user_id).include?(user.id)
-  end
-
-  def self.find_chat_for_users(users)
-    # presumably much more efficient ways to run an intersecton, we want to find the last
-    # exact match with the users being messaged to append to the existing chat.
-    Chat.eager_load(:chat_users).where("chat_users.departed_at IS NULL").order('chats.created_at desc').detect {|c| c.chat_users.map(&:user_id).uniq.sort == users.map(&:id).sort }
-  end
-
-end
+class ChatMessage < AbstractAdapter
+  belongs_to :chat
+  belongs_to :author, class_name: 'User'
+
+  has_many :chat_users, through: :chat
+  has_many :recipients, lambda {|message|  where(':created_at >= chat_users.created_at and (chat_users.departed_at IS NULL OR :created_at <= chat_users.departed_at)', created_at: message.created_at ) }, through: :chat_users, source: :user, class_name: 'User'
+
+  # Create ChatUserMessage records for each recipient to track read status
+  has_many :chat_message_users, dependent: :destroy
+
+  validate :author_in_chat
+
+  def author_in_chat
+    errors.add(:base, 'User not in chat session.') unless chat.active_users.include? author
+  end
+
+  before_save :create_message_users, if: :new_record?
+  def create_message_users
+    chat_users.merge(ChatUser.current).each do |cu|
+      chat_message_users.build(user: cu.user)
+    end
+  end
+
+  def read_by?(user)
+    chat_message_users.merge(ChatMessageUser.read).map(&:user_id).include?(user.id)
+  end
+
+  def self.find_chat_for_users(users)
+    # presumably much more efficient ways to run an intersecton, we want to find the last
+    # exact match with the users being messaged to append to the existing chat.
+    Chat.eager_load(:chat_users).where("chat_users.departed_at IS NULL").order('chats.created_at desc').detect {|c| c.chat_users.map(&:user_id).uniq.sort == users.map(&:id).sort }
+  end
+
+end

data/spec/dummy/app/models/chat_user.rb

@@ -1,16 +1,16 @@
-class ChatUser < AbstractAdapter
-  belongs_to :chat
-  belongs_to :user
-
-  alias_attribute :joined_at, :created_at
-  alias_attribute :left_at,   :departed_at
-
-  scope :current, ->{ where(departed_at: nil) }
-
-  validate :user_not_already_active, on: :create
-
-  def user_not_already_active
-    errors.add(:base, "#{user.name} is already present in this chat.") if chat.chat_users.where(user_id: user.id, departed_at: nil).count > 0 && user.persisted?
-  end
-
-end
+class ChatUser < AbstractAdapter
+  belongs_to :chat
+  belongs_to :user
+
+  alias_attribute :joined_at, :created_at
+  alias_attribute :left_at,   :departed_at
+
+  scope :current, ->{ where(departed_at: nil) }
+
+  validate :user_not_already_active, on: :create
+
+  def user_not_already_active
+    errors.add(:base, "#{user.name} is already present in this chat.") if chat.chat_users.where(user_id: user.id, departed_at: nil).count > 0 && user.persisted?
+  end
+
+end

data/spec/dummy/app/models/company.rb

@@ -9,8 +9,9 @@ class Company < AbstractAdapter
 
   has_many :projects, foreign_key: :owner_id, dependent: :destroy, inverse_of: :owner
 
-  validates_length_of :name, maximum: 256
-  validates_length_of :short_name, maximum: 10
+  # leave these to validates_by_schema:
+  # validates_length_of :name, maximum: 256
+  # validates_length_of :short_name, maximum: 10
 
   def self.grape_validations
     {

data/spec/dummy/app/models/location.rb

@@ -1,26 +1,26 @@
-class Location < AbstractAdapter
-  has_many :locatables, dependent: :destroy
-  has_many :companies, through: :locatables, source: :locatable, source_type: 'Company'
-
-  has_many :beacons, class_name: 'LocationBeacon', dependent: :destroy
-  has_one  :gps,     class_name: 'LocationGps',    dependent: :destroy
-  delegate :lat,:lng,:alt, to: :gps
-
-  belongs_to :parent_location, foreign_key: :parent_location_id, class_name: 'Location', inverse_of: :child_locations, optional: true
-  has_many   :child_locations, foreign_key: :parent_location_id, class_name: 'Location', dependent: :destroy, inverse_of: :parent_location
-
-  has_many :user_locations, dependent: :destroy
-
-  # isn't this list going to be kinda long? are there any reasonable constraints to put
-  # on this random bit of metadata?
-  validates_inclusion_of :kind, in: %w(airport terminal gate plane)
-
-  accepts_nested_attributes_for :child_locations, allow_destroy: true
-  accepts_nested_attributes_for :gps,             allow_destroy: true
-  accepts_nested_attributes_for :beacons,         allow_destroy: true
-
-  def coords
-    [gps.lat, gps.lng, gps.alt]
-  end
-
-end
+class Location < AbstractAdapter
+  has_many :locatables, dependent: :destroy
+  has_many :companies, through: :locatables, source: :locatable, source_type: 'Company'
+
+  has_many :beacons, class_name: 'LocationBeacon', dependent: :destroy
+  has_one  :gps,     class_name: 'LocationGps',    dependent: :destroy
+  delegate :lat,:lng,:alt, to: :gps
+
+  belongs_to :parent_location, foreign_key: :parent_location_id, class_name: 'Location', inverse_of: :child_locations, optional: true
+  has_many   :child_locations, foreign_key: :parent_location_id, class_name: 'Location', dependent: :destroy, inverse_of: :parent_location
+
+  has_many :user_locations, dependent: :destroy
+
+  # isn't this list going to be kinda long? are there any reasonable constraints to put
+  # on this random bit of metadata?
+  validates_inclusion_of :kind, in: %w(airport terminal gate plane)
+
+  accepts_nested_attributes_for :child_locations, allow_destroy: true
+  accepts_nested_attributes_for :gps,             allow_destroy: true
+  accepts_nested_attributes_for :beacons,         allow_destroy: true
+
+  def coords
+    [gps.lat, gps.lng, gps.alt]
+  end
+
+end

data/spec/dummy/app/models/role.rb

@@ -1,30 +1,30 @@
-class Role < AbstractAdapter
-  belongs_to :user
-  belongs_to :ownable, polymorphic: true, optional: true
-
-  validates_uniqueness_of :user_id, scope: [:ownable_type,:ownable_id], unless: Proc.new {|u| u.user_id.nil? }, message: "user has already been assigned that role"
-  OWNABLE_TYPES = %w(Company Project).freeze
-  validates_inclusion_of :ownable_type, in: OWNABLE_TYPES
-
-  delegate :email, to: :user,              allow_nil: true
-  def attributes
-    super.merge(email: email)
-  end
-
-  def self.grape_validations
-    { ownable_type: { values: OWNABLE_TYPES } }
-  end
-
-  def self.ownable_assign_options(_model=nil)
-    (Company.all + Project.all).map { |i| [ "#{i.class}: #{i.name}", "#{i.class}-#{i.id}"] }
-  end
-
-  def ownable_assign
-    ownable.present? ? "#{ownable_type}-#{ownable_id}" : nil
-  end
-
-  def ownable_assign=(value)
-    self.ownable_type,self.ownable_id = value.split('-')
-  end
-
-end
+class Role < AbstractAdapter
+  belongs_to :user
+  belongs_to :ownable, polymorphic: true, optional: true
+
+  validates_uniqueness_of :user_id, scope: [:ownable_type,:ownable_id], unless: Proc.new {|u| u.user_id.nil? }, message: "user has already been assigned that role"
+  OWNABLE_TYPES = %w(Company Project).freeze
+  validates_inclusion_of :ownable_type, in: OWNABLE_TYPES
+
+  delegate :email, to: :user,              allow_nil: true
+  def attributes
+    super.merge(email: email)
+  end
+
+  def self.grape_validations
+    { ownable_type: { values: OWNABLE_TYPES } }
+  end
+
+  def self.ownable_assign_options(_model=nil)
+    (Company.all + Project.all).map { |i| [ "#{i.class}: #{i.name}", "#{i.class}-#{i.id}"] }
+  end
+
+  def ownable_assign
+    ownable.present? ? "#{ownable_type}-#{ownable_id}" : nil
+  end
+
+  def ownable_assign=(value)
+    self.ownable_type,self.ownable_id = value.split('-')
+  end
+
+end

data/spec/dummy/app/models/team.rb

@@ -1,14 +1,14 @@
-class Team < AbstractAdapter
-  belongs_to :project
-  belongs_to :creator, class_name: 'User'
-
-  has_many :team_users, inverse_of: :team
-  has_many :users, through: :team_users
-  accepts_nested_attributes_for :team_users, allow_destroy: true
-
-  before_validation :set_creator
-
-  def set_creator
-    self.creator ||= Current.user
-  end
-end
+class Team < AbstractAdapter
+  belongs_to :project
+  belongs_to :creator, class_name: 'User'
+
+  has_many :team_users, inverse_of: :team
+  has_many :users, through: :team_users
+  accepts_nested_attributes_for :team_users, allow_destroy: true
+
+  before_validation :set_creator
+
+  def set_creator
+    self.creator ||= Current.user
+  end
+end

data/spec/dummy/app/models/user/chatter.rb

@@ -1,79 +1,79 @@
-module User::Chatter
-
-  def message_query(chat_id, new = true)
-    messages.joins(:chat_message_users)
-            .where('chat_message_users.user_id'=> id)
-            .where(new ? {'chat_message_users.read_at'=>nil} : '')
-            .where(chat_id ? {'chat_messages.chat_id'=> chat_id} : '')
-            .order('') # or it will add an order by id clause that breaks the count query.
-  end
-
-  def new_messages?(chat=nil) # returns a hash of chat_ids with new message counts
-    chat_id = chat.kind_of?(Chat) ? chat.id : chat
-    new = message_query(chat_id)
-          .select("chat_messages.chat_id, count(chat_messages.id) as count")
-          .group('chat_id')
-
-    chat ? { chat_id => new.first.try(:count)||0 } : Hash[new.map {|c| [c.chat_id, c.count]} ]
-  end
-
-  def read_messages(chat= nil, mark_as_read= false, new= true)
-    chat_id = chat.kind_of?(Chat) ? chat.id : chat
-    new = message_query(chat_id, new).order('chat_messages.created_at').includes(:author) # :chat?
-    new.map(&:chat).uniq.each {|c| mark_as_read(c) } if mark_as_read
-    new
-  end
-
-  def chat(users, message)
-    users = [users].flatten
-    users = users.first.kind_of?(User) ? users : User.where(id: users)
-    chat  = Chat.create(creator: self)
-    chat.users.push users
-    chat.messages.build(message: message, author: self)
-    chat.save!
-    chat
-  end
-
-  def reply(chat, message)
-    chat = chat.kind_of?(Chat) ? chat : Chat.find(chat)
-    mark_as_read(chat) # a reply implies that the thread has been read
-    chat.messages.build(message: message, author: self)
-    chat.save!
-    chat
-  end
-
-  def add_chatters(chat, users)
-    users = [users].flatten
-    users = users.first.kind_of?(User) ? users : User.where(id: users)
-    chat  = chat.kind_of?(Chat) ? chat : Chat.find(chat)
-
-    if chat.active_users.include?(self) # only current participants can add new users
-      chat.users.push users
-      chat.messages.build(chat: chat, author: self, message: "#{self.name} [[ADDED_USER_MESSAGE]] #{users.map(&:name).join(',')}")
-      chat.save!
-    else
-      chat.errors.add(:base, "Only current chat participants can add users.")
-      raise ActiveRecord::RecordInvalid.new(chat)
-    end
-  end
-
-  def leave_chat(chat)
-    chat = chat.kind_of?(Chat) ? chat : Chat.find(chat)
-
-    if chat.active_users.include?(self)
-      reply(chat, "#{name} [[DEPARTS_MESSAGE]]")
-      chat.chat_users.detect {|cu| cu.user_id == self.id}.update(departed_at: Time.now)
-    else
-      true
-    end
-  end
-
-  def mark_as_read(chat)
-    ChatMessageUser.joins(:chat_message).where('read_at IS NULL AND chat_messages.chat_id = ? AND user_id = ?', chat.id, id).update_all(read_at: Time.now)
-  end
-
-  def mark_messages_as_read(messages)
-    chat_message_users.where("chat_message_id in (?) and read_at IS NULL", messages.map(&:id)).update_all(read_at: Time.now)
-  end
-
-end
+module User::Chatter
+
+  def message_query(chat_id, new = true)
+    messages.joins(:chat_message_users)
+            .where('chat_message_users.user_id'=> id)
+            .where(new ? {'chat_message_users.read_at'=>nil} : '')
+            .where(chat_id ? {'chat_messages.chat_id'=> chat_id} : '')
+            .order('') # or it will add an order by id clause that breaks the count query.
+  end
+
+  def new_messages?(chat=nil) # returns a hash of chat_ids with new message counts
+    chat_id = chat.kind_of?(Chat) ? chat.id : chat
+    new = message_query(chat_id)
+          .select("chat_messages.chat_id, count(chat_messages.id) as count")
+          .group('chat_id')
+
+    chat ? { chat_id => new.first.try(:count)||0 } : Hash[new.map {|c| [c.chat_id, c.count]} ]
+  end
+
+  def read_messages(chat= nil, mark_as_read= false, new= true)
+    chat_id = chat.kind_of?(Chat) ? chat.id : chat
+    new = message_query(chat_id, new).order('chat_messages.created_at').includes(:author) # :chat?
+    new.map(&:chat).uniq.each {|c| mark_as_read(c) } if mark_as_read
+    new
+  end
+
+  def chat(users, message)
+    users = [users].flatten
+    users = users.first.kind_of?(User) ? users : User.where(id: users)
+    chat  = Chat.create(creator: self)
+    chat.users.push users
+    chat.messages.build(message: message, author: self)
+    chat.save!
+    chat
+  end
+
+  def reply(chat, message)
+    chat = chat.kind_of?(Chat) ? chat : Chat.find(chat)
+    mark_as_read(chat) # a reply implies that the thread has been read
+    chat.messages.build(message: message, author: self)
+    chat.save!
+    chat
+  end
+
+  def add_chatters(chat, users)
+    users = [users].flatten
+    users = users.first.kind_of?(User) ? users : User.where(id: users)
+    chat  = chat.kind_of?(Chat) ? chat : Chat.find(chat)
+
+    if chat.active_users.include?(self) # only current participants can add new users
+      chat.users.push users
+      chat.messages.build(chat: chat, author: self, message: "#{self.name} [[ADDED_USER_MESSAGE]] #{users.map(&:name).join(',')}")
+      chat.save!
+    else
+      chat.errors.add(:base, "Only current chat participants can add users.")
+      raise ActiveRecord::RecordInvalid.new(chat)
+    end
+  end
+
+  def leave_chat(chat)
+    chat = chat.kind_of?(Chat) ? chat : Chat.find(chat)
+
+    if chat.active_users.include?(self)
+      reply(chat, "#{name} [[DEPARTS_MESSAGE]]")
+      chat.chat_users.detect {|cu| cu.user_id == self.id}.update(departed_at: Time.now)
+    else
+      true
+    end
+  end
+
+  def mark_as_read(chat)
+    ChatMessageUser.joins(:chat_message).where('read_at IS NULL AND chat_messages.chat_id = ? AND user_id = ?', chat.id, id).update_all(read_at: Time.now)
+  end
+
+  def mark_messages_as_read(messages)
+    chat_message_users.where("chat_message_id in (?) and read_at IS NULL", messages.map(&:id)).update_all(read_at: Time.now)
+  end
+
+end

data/spec/dummy/app/models/user.rb

@@ -5,6 +5,8 @@ class User < AbstractAdapter
   devise :database_authenticatable, :registerable, :confirmable,
          :recoverable, :rememberable, :trackable, :validatable, :lockable
 
+  validates_by_schema except: :encrypted_password
+
   scope :active,   -> { where(:locked_at => nil) }
   scope :inactive, -> { where('locked_at is not null') }
 

data/spec/dummy/bin/bundle

@@ -1,3 +1,3 @@
-#!/usr/bin/env ruby
-ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
-load Gem.bin_path('bundler', 'bundle')
+#!/usr/bin/env ruby
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+load Gem.bin_path('bundler', 'bundle')

data/spec/dummy/bin/rails

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
-APP_PATH = File.expand_path('../config/application', __dir__)
-require_relative '../config/boot'
-require 'rails/commands'
+#!/usr/bin/env ruby
+APP_PATH = File.expand_path('../config/application', __dir__)
+require_relative '../config/boot'
+require 'rails/commands'

data/spec/dummy/bin/setup

@@ -1,36 +1,36 @@
-#!/usr/bin/env ruby
-require 'fileutils'
-include FileUtils
-
-# path to your application root.
-APP_ROOT = File.expand_path('..', __dir__)
-
-def system!(*args)
-  system(*args) || abort("\n== Command #{args} failed ==")
-end
-
-chdir APP_ROOT do
-  # This script is a starting point to setup your application.
-  # Add necessary setup steps to this file.
-
-  puts '== Installing dependencies =='
-  system! 'gem install bundler --conservative'
-  system('bundle check') || system!('bundle install')
-
-  # Install JavaScript dependencies if using Yarn
-  # system('bin/yarn')
-
-  # puts "\n== Copying sample files =="
-  # unless File.exist?('config/database.yml')
-  #   cp 'config/database.yml.sample', 'config/database.yml'
-  # end
-
-  puts "\n== Preparing database =="
-  system! 'bin/rails db:setup'
-
-  puts "\n== Removing old logs and tempfiles =="
-  system! 'bin/rails log:clear tmp:clear'
-
-  puts "\n== Restarting application server =="
-  system! 'bin/rails restart'
-end
+#!/usr/bin/env ruby
+require 'fileutils'
+include FileUtils
+
+# path to your application root.
+APP_ROOT = File.expand_path('..', __dir__)
+
+def system!(*args)
+  system(*args) || abort("\n== Command #{args} failed ==")
+end
+
+chdir APP_ROOT do
+  # This script is a starting point to setup your application.
+  # Add necessary setup steps to this file.
+
+  puts '== Installing dependencies =='
+  system! 'gem install bundler --conservative'
+  system('bundle check') || system!('bundle install')
+
+  # Install JavaScript dependencies if using Yarn
+  # system('bin/yarn')
+
+  # puts "\n== Copying sample files =="
+  # unless File.exist?('config/database.yml')
+  #   cp 'config/database.yml.sample', 'config/database.yml'
+  # end
+
+  puts "\n== Preparing database =="
+  system! 'bin/rails db:setup'
+
+  puts "\n== Removing old logs and tempfiles =="
+  system! 'bin/rails log:clear tmp:clear'
+
+  puts "\n== Restarting application server =="
+  system! 'bin/rails restart'
+end