frigate 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c31f5d170fc9bb2a589fc06611dd6f216706562a
+  data.tar.gz: 2e1b8d78dbe0ef524c4a92390af756f23115f242
+SHA512:
+  metadata.gz: 0eb87b749cda6c1f3cf39d60b6066be1e3eca7d81a1c262b0a3f6ad79cecbb8ccde1bd001def5288dde2c978cb5dfea080d8773996e85ecf1cf1b5caae075fea
+  data.tar.gz: b0ddf19c44b1794f463217bef7747655502b218f5217d44fe3e3a49b79e9f7199a38da64da291e48768bac2146279db29576b05ec9372b4f763ba20e95005e7c

data/.gitignore

@@ -0,0 +1,19 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.rvmrc
+.ruby-version
+.ruby-gemset
+*.log
+.keep

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 2.1.5
+  - 2.0.0
+  - 1.9.3
+gemfile:
+  - Gemfile

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+
+gem 'rails', '~> 4.1'
+gem 'sqlite3', '~> 1.3.10'
+gem 'database_cleaner', '~> 1.3.0'
+gem 'rspec', '~> 3.1.0'
+gem 'guard-rspec', '~> 4.4.2'
+
+# Specify your gem's dependencies in frigate.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,67 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %(app lib config test spec feature)
+
+## Uncomment to clear the screen before every task
+# clearing :on
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+	require "ostruct"
+
+	# Generic Ruby apps
+	rspec = OpenStruct.new
+	rspec.spec = ->(m) { "spec/#{m}_spec.rb" }
+	rspec.spec_dir = "spec"
+	rspec.spec_helper = "spec/spec_helper.rb"
+
+	watch(%r{^spec/.+_spec\.rb$})
+	watch(%r{^lib/(.+)\.rb$}) { |m| rspec.spec.("lib/#{m[1]}") }
+	watch(rspec.spec_helper) { rspec.spec_dir }
+
+	# # Rails example
+	# rails = OpenStruct.new
+	# rails.app = %r{^app/(.+)\.rb$}
+	# rails.views_n_layouts = %r{^app/(.*)(\.erb|\.haml|\.slim)$}
+	# rails.controllers = %r{^app/controllers/(.+)_controller\.rb$}
+	# rails.routes = "config/routes.rb"
+	# rails.app_controller = "app/controllers/application_controller.rb"
+	# rails.spec_helper = "spec/rails_helper.rb"
+	# rails.spec_support = %r{^spec/support/(.+)\.rb$}
+	# rails.views = %r{^app/views/(.+)/.*\.(erb|haml|slim)$}
+	#
+	# watch(rails.app) { |m| rspec.spec.(m[1]) }
+	# watch(rails.views_n_layouts) { |m| rspec.spec.("#{m[1]}#{m[2]}") }
+	# watch(rails.controllers) do |m|
+	#   [
+	#     rspec.spec.("routing/#{m[1]}_routing"),
+	#     rspec.spec.("controllers/#{m[1]}_controller"),
+	#     rspec.spec.("acceptance/#{m[1]}")
+	#   ]
+	# end
+
+	# watch(rails.spec_support)    { rspec.spec_dir }
+	# watch(rails.spec_helper)     { rspec.spec_dir }
+	# watch(rails.routes)          { "spec/routing" }
+	# watch(rails.app_controller)  { "spec/controllers" }
+
+	# Capybara features specs
+	# watch(rails.views)     { |m| rspec.spec.("features/#{m[1]}") }
+
+	# Turnip features and steps
+	watch(%r{^spec/acceptance/(.+)\.feature$})
+	watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
+		Dir[File.join("**/#{m[1]}.feature")][0] || "spec/acceptance"
+	end
+
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 BroderickBrockman
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+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 OR COPYRIGHT HOLDERS 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.

data/README.md

@@ -0,0 +1,31 @@
+# Frigate
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'frigate'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install frigate
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/frigate/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+# require 'rake/testtask'
+require 'rspec/core/rake_task'
+
+task :default => :spec
+RSpec::Core::RakeTask.new
+
+# task :default => [:test]
+# Rake::TestTask.new(:test) do |test|
+# 	test.libs << 'test'
+# 	test.test_files = FileList['test/*_test.rb']
+# 	test.verbose = true
+# end

data/frigate.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'frigate/version'
+
+Gem::Specification.new do |spec|
+	spec.name = "frigate"
+	spec.version = Frigate::VERSION
+	spec.authors = ['Vladislav Pauk']
+	spec.email = ['vladislavpauk@gmail.com']
+	spec.summary = %q{ thinking about it }
+	spec.description = %q{still thinking about it}
+	spec.homepage = ''
+	spec.license = 'MIT'
+
+	spec.files = `git ls-files -z`.split("\x0")
+	spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+	spec.test_files = spec.files.grep(%r{^(test|spec|features)/})
+	spec.require_paths = ['lib']
+
+	spec.add_development_dependency 'bundler', '~> 1.7'
+	spec.add_development_dependency 'rake', '~> 10.0'
+	# spec.add_development_dependency 'rspec', '~> 3.1.0'
+	# spec.add_development_dependency 'guard-rspec', '~> 4.4.2'
+	# spec.add_development_dependency 'rails', '~> 4.1'
+	# spec.add_development_dependency 'sqlite3', '~> 1.3.10'
+	# spec.add_development_dependency 'database_cleaner', '~> 1.3.0'
+	spec.add_dependency 'activemodel', '~> 4.1'
+	spec.add_dependency 'activesupport', '~> 4.1'
+	spec.add_dependency 'hashie', '~> 3.3.2'
+end

data/lib/frigate/form/association.rb

@@ -0,0 +1,94 @@
+module Frigate
+	module Form
+		# Uses to define a form association with properties as Frigate::Form::Property
+		class Association
+			class << self
+				# defines property for association
+				# @param [Symbol] name
+				# @param [Hash] options
+				def property(name, options={})
+					@properties ||= {}
+					@properties[name.to_sym] = options
+				end
+
+				# defines association (kinda property with properties) for association
+				# @param [Symbol] name
+				# @param [Hash] options
+				# @param [Proc] block
+				def has_one(name, options={}, &block)
+					@associations ||= {}
+					@associations[name.to_sym] = options.merge({ block: block })
+				end
+
+				# gets just options for defined properties
+				# @example properties hash
+				#    { skype: { validates: { presence: true }, another_option: another_option_hash } }
+				def properties
+					@properties.deep_dup || {}
+				end
+
+				# gets just options for defined associations
+				# @example associations hash
+				#     { some_name: { block: <Proc.new instance> }
+				def associations
+					@associations.deep_dup || {}
+				end
+			end
+
+			attr_reader :name, :opts, :properties, :associations, :root, :parent
+			# @param [Symbol] name
+			# @param [Hash] opts
+			def initialize(name, root, parent, opts = {})
+				@name, @root, @parent, @opts = name, root, parent, opts
+				@properties, @associations = [], []
+
+				exec_opts_block
+				process_properties
+				process_associations
+			end
+
+			# gets errors of association
+			# @return [ActiveModel::Errors]
+			def errors
+				@errors ||= ActiveModel::Errors.new(self)
+			end
+
+			# checks validness of association properties
+			def valid?
+				errors.messages.empty?
+			end
+
+			# validates association properties
+			def validate
+				properties.each { |_prop| errors.add(_prop.name, _prop.errors[:value]) unless _prop.valid? }
+			end
+
+			private
+
+			# exec_opts_block
+			def exec_opts_block
+				singleton_class.instance_exec &@opts.delete(:block)
+			end
+
+			# initializes declared associations
+			def process_associations
+				singleton_class.associations.each do |_assoc_name, _assoc_options|
+					_assoc = Association.new(_assoc_name, root, self, _assoc_options)
+					@associations << _assoc
+					define_singleton_method(_assoc.name) { _assoc }
+				end
+			end
+
+			# initializes declared properties
+			def process_properties
+				singleton_class.properties.each do |_prop_name, _prop_options|
+					_prop = Property.new(_prop_name, root, self, _prop_options)
+					@properties << _prop
+					define_singleton_method(_prop.name) { _prop }
+				end
+			end
+
+			# TODO add am::verifications
+		end
+	end
+end

data/lib/frigate/form/base.rb

@@ -0,0 +1,141 @@
+require 'frigate/form/property'
+require 'frigate/form/association'
+require 'frigate/form/synchronizer'
+module Frigate
+	module Form
+		#
+		# Is used for model validation outside of model
+		#
+		# @example A form for User class
+		# 	class UserForm < Frigate::Form::Base
+		# 		property :email, validates: { presence: true }
+		# 		has_one :user_profile do
+		# 			property :first_name, validates: { presence: true }
+		# 			property :last_name
+		# 			property :skype
+		# 		end
+		# 	end
+		#
+		# 	class UserFormCustom < Frigate::Form::Base
+		# 		property :email, validates: { presence: true },
+		# 			validate: [
+		# 				Proc.new { error(:invalid) unless value =~ /\A([\w+\-].?)+@[a-z\d\-]+(\.[a-z]+)*\.[a-z]+\z/i },
+		# 			]
+		# 		has_one :user_profile do
+		# 			property :first_name, validates: { presence: true }
+		# 			property :last_name
+		# 			property :skype
+		# 		end
+		# 	end
+		#
+		# 	class UserFormTree < Frigate::Form::Base
+		# 		property :email
+		# 		has_one :user_profile do
+		# 			property :first_name
+		# 			property :last_name
+		# 			property :skype
+		# 			has_one :user_profile_passport do
+		# 				property :number
+		# 				property :country
+		# 				property :city
+		# 			end
+		# 		end
+		# 	end
+		#
+		# 	user = User.new
+		# 	user.build_user_profile
+		# 	user_form = UserForm.new(user)
+		# 	user_form.valid? # returns false
+		# 	user_form.validate({email: 'z1@zzz.zz', user_profile: {first_name:'Alpha', last_name:'Omega'}}) # returns true
+		# 	user_form.valid? # returns true
+		#
+		# @author Vladislav Pauk <vladislavpauk@gmail.com>
+		#
+		class Base
+			class << self
+				# gets just options for defined properties
+				# @example properties hash
+				#    { skype: { validates: { presence: true }, another_option: another_option_hash } }
+				def properties
+					@properties.deep_dup || {}
+				end
+
+				# gets just options for defined associations
+				# @example associations hash
+				#     { some_name: { block: <Proc.new instance> }
+				def associations
+					@associations.deep_dup || {}
+				end
+
+				# defines property (root) of form/base
+				# @param [Symbol] name
+				# @param [Hash] options
+				def property(name, options={})
+					@properties ||= {}
+					@properties[name.to_sym] = options
+				end
+
+				# defines association (kinda property with properties)(root as well) of form/base
+				# @param [Symbol] name
+				# @param [Hash] options
+				# @param [Proc] block
+				def has_one(name, options={}, &block)
+					@associations ||= {}
+					@associations[name.to_sym] = options.merge({ block: block })
+				end
+			end
+
+			attr_reader :model, :properties, :associations
+			delegate :sync_with_model, :sync_properties_with_model_or_params, :sync_errors, to: :@syncronizator
+
+			# Method of initialization of Frigate::Form class
+			# @param [Object] model
+			def initialize(model, opts={})
+				@syncronizator = opts[:contract] ? Synchronizer::Contract.new(self) : Synchronizer::Form.new(self)
+				@model, @properties, @associations = model, [], []
+
+				process_properties
+				process_associations
+			end
+
+			# Initializes errors instance variable of ActiveModel::Errors type
+			# @return [ActiveModel::Errors] return errors
+			def errors
+				@errors ||= ActiveModel::Errors.new(self)
+			end
+
+			# Validates form with params or model properties
+			def validate(*args)
+				sync_properties_with_model_or_params(*args)
+				sync_errors
+				valid?
+			end
+
+			# returns true if are there any errors messages in form errors
+			# @return [Boolean] return true if form model is valid
+			def valid?
+				errors.messages.empty?
+			end
+
+			private
+
+			# initializes declared associations
+			def process_associations
+				self.class.associations.each do |_assoc_name, _assoc_options|
+					_assoc = Association.new(_assoc_name, self, self, _assoc_options)
+					@associations << _assoc
+					define_singleton_method(_assoc.name) { _assoc }
+				end
+			end
+
+			# initializes declared properties
+			def process_properties
+				self.class.properties.each do |_prop_name, _prop_options|
+					_prop = Property.new(_prop_name, self, self, _prop_options)
+					@properties << _prop
+					define_singleton_method(_prop.name) { _prop }
+				end
+			end
+		end
+	end
+end

data/lib/frigate/form/property.rb

@@ -0,0 +1,40 @@
+module Frigate
+	module Form
+		# Uses to define a form property
+		class Property
+			attr_accessor :name, :options, :value, :root, :parent
+
+			include ActiveModel::Validations
+
+			# @param [Symbol] name
+			# @param [Hash] options
+			def initialize(name, root, parent, options)
+				@name, @root, @parent, @options = name, root, parent, options
+
+				set_validations
+				set_custom_validations
+			end
+
+			private
+
+			def set_validations
+				validations = options.delete(:validates)
+				singleton_class.class_eval { validates :value, validations } if validations
+				true
+			end
+
+			def set_custom_validations
+				validations = options.delete(:validate)
+				validations.is_a?(Array) and validations.each do |validation|
+					singleton_class.class_eval { validate &validation }
+				end
+			end
+
+			def add_error(name)
+				errors.add(:value, name)
+			end
+
+			alias_method :error, :add_error
+		end
+	end
+end

data/lib/frigate/form/synchronizer/base.rb

@@ -0,0 +1,22 @@
+module Frigate
+	module Form
+		# Serves for synchronization form properties with model attributes/properties
+		module Synchronizer
+			# Base class for Frigate::Form::Base synchronizations
+			# It justs abstract class which has two methods
+			# * sync form with model
+			# * sync properties errors into form errors
+			class Base < Fundamental
+				# synchronizes form with model
+				def sync_with_model
+					raise NotImplementedError
+				end
+
+				# synchronizes form properties (associations:properties) errors with general form errors
+				def sync_errors
+					raise NotImplementedError
+				end
+			end
+		end
+	end
+end

data/lib/frigate/form/synchronizer/basic.rb

@@ -0,0 +1,75 @@
+module Frigate
+	module Form
+		# Serves for synchronization form properties with model attributes/properties
+		module Synchronizer
+			# A syncronizator between form properties and model properties
+			class Basic < Base
+				# A class for synchronization model with params
+				class ModelSynchronizer < Fundamental
+					# Synchronizes given model with form properties and associations:properties
+					# @param [Hash] ops
+					def sync_with_model(opts={})
+						sync_properties
+						sync_associations
+						save_model if opts[:save]
+					end
+
+					private
+
+					def save_model
+						form.model.save!
+					end
+
+					def sync_associations
+						_sync_associations(form, form.model)
+					end
+
+					def sync_properties
+						_sync_properties(form, form.model)
+					end
+
+					def _sync_associations(f_ctx, m_ctx)
+						f_ctx.associations.each do |_assoc|
+							n_m_ctx = m_ctx.send(_assoc.name.to_sym)
+							if m_ctx.is_a?(ActiveRecord::Base) and n_m_ctx.nil?
+								m_ctx.send("build_#{_assoc.name}")
+							end
+							_assoc.properties.each do |_prop|
+								_sync_properties(_assoc, n_m_ctx)
+							end
+							_sync_associations(_assoc, n_m_ctx)
+						end
+					end
+
+					def _sync_properties(f_ctx, m_ctx)
+						f_ctx.properties.each do |_prop|
+							m_ctx.send("#{_prop.name}=", _prop.value) unless _prop.value.nil?
+						end
+					end
+				end
+
+				# Synchronizes given params with given model
+				# @param [Hash] opts
+				# @return [Boolean] true
+				def sync_with_model(opts={})
+					ModelSynchronizer.new(form).sync_with_model(opts)
+				end
+
+				# Synchronizes properties errors with form errors
+				# @return [Boolean]
+				def sync_errors
+					form.properties.each { |_prop| form.errors.add(_prop.name, _prop.errors[:value]) unless _prop.valid? }
+					form.associations.each do |_assoc|
+						_assoc.properties.each do |_prop|
+							form.errors.add("#{_assoc.name}.#{_prop.name}", _prop.errors[:value]) unless _prop.valid?
+						end
+					end
+				end
+
+				def sync_properties_with_model_or_params
+					raise NotImplementedError
+				end
+			end
+		end
+	end
+end

data/lib/frigate/form/synchronizer/contract.rb

@@ -0,0 +1,46 @@
+module Frigate
+	module Form
+		# Serves for synchronization form properties with model attributes/properties
+		module Synchronizer
+			# Synchronizes form properties with model properties
+			class Contract < Basic # TODO: tree-association support, as form does
+				# Synchronizes given model's attributes with form properties and associations:properties
+				def sync_properties_with_model_or_params
+					#
+					# sync model properties with form properties
+					#
+					form.properties.each do |_prop|
+						if form.model.respond_to?(_prop.name.to_sym)
+							_prop.value = form.model.send(_prop.name.to_sym)
+						else
+							raise StandardError.new('form model does not have %s property' % [_prop.name])
+						end
+					end
+					#
+					# sync model associations' properties with form associations' properties
+					#
+					form.associations.each do |_a|
+						if form.model.respond_to?(_a.name.to_sym) and !form.model.send(_a.name.to_sym).nil?
+							_a.properties.each do |_p|
+								if form.model.send(_a.name.to_sym).respond_to?(_p.name.to_sym)
+									_p.value = form.model.send(_a.name.to_sym).send(_p.name.to_sym)
+								else
+									_err_msg = 'form model %s association does not have %s property' % [_a.name, _p.name]
+									raise StandardError.new(_err_msg)
+								end
+							end
+						else
+							if form.model.respond_to?(_a.name.to_sym)
+								_err_msg = 'form model %s association is nil' % [_a.name]
+								raise StandardError.new(_err_msg)
+							else
+								_err_msg = 'form model does not have %s association' % [_a.name]
+								raise StandardError.new(_err_msg)
+							end
+						end
+					end
+				end
+			end
+		end
+	end
+end

data/lib/frigate/form/synchronizer/form.rb

@@ -0,0 +1,40 @@
+module Frigate
+	module Form
+		# Serves for synchronization form properties with model attributes/properties
+		module Synchronizer
+			# Synchronizes form properties with given params
+			class Form < Basic
+				# It's just extracted method *sync_properties_with_model_or_params* into this class
+				class ParamsToPropertiesSynchronizer < Fundamental
+					# Synchronizes given params with form properties and associations:properties
+					# @param [Hash] params
+					def sync_params_with_properties(params)
+						process_params(params, form)
+					end
+
+					private
+
+					def process_params(params, ctx)
+						params.each do |_p_n, _p_v|
+							if _p_v.is_a?(Hash)
+								process_params(_p_v, ctx.send(_p_n.to_sym))
+							else
+								sync_properties(_p_n, _p_v, ctx)
+							end
+						end
+					end
+
+					def sync_properties(p_n, p_v, ctx)
+						ctx.properties.each { |_p| _p.value = p_v if p_n.to_sym == _p.name.to_sym }
+					end
+				end
+
+				# Synchronizes given params with form properties and associations:properties
+				# @param [Hash] params
+				def sync_properties_with_model_or_params(params)
+					ParamsToPropertiesSynchronizer.new(form).sync_params_with_properties(params)
+				end
+			end
+		end
+	end
+end