frigate 0.0.1

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

@@ -0,0 +1,17 @@
+module Frigate
+	module Form
+		# Serves for synchronization form properties with model attributes/properties
+		module Synchronizer
+			# An abstract syncronizator, needs to be as superclass
+			class Fundamental
+				attr_reader :form
+
+				# initializes class, rly?????
+				# @param [Frigate::Form] form
+				def initialize(form)
+					@form = form
+				end
+			end
+		end
+	end
+end

data/lib/frigate/form/synchronizer.rb

@@ -0,0 +1,14 @@
+module Frigate
+	module Form
+		# Serves for synchronization form properties with model attributes/properties
+		module Synchronizer
+			# code; mb some configs
+		end
+	end
+end
+#
+require 'frigate/form/synchronizer/fundamental'
+require 'frigate/form/synchronizer/base'
+require 'frigate/form/synchronizer/basic'
+require 'frigate/form/synchronizer/form'
+require 'frigate/form/synchronizer/contract'

data/lib/frigate/form.rb

@@ -0,0 +1,16 @@
+#
+# Is used for model validation outside of model
+#
+# @author Vladislav Pauk <vladislavpauk@gmail.com>
+#
+require 'active_support/core_ext/module/delegation'
+#
+module Frigate
+	# It's a form.
+	# @see Frigate::Form::Base
+	module Form
+		# code, mb some configuration
+	end
+end
+#
+require 'frigate/form/base'

data/lib/frigate/function.rb

@@ -0,0 +1,41 @@
+# @example
+# 	class Song::AddArtistService < Frigate::Service
+# 		property :song
+# 		property :artist
+#
+# 		def function
+# 			song.artists << artist
+# 		end
+# 	end
+#
+# 	Song::AddArtistService[song: song, artist: artist]
+class Frigate::Function
+	class << self
+		# @param [Symbol] name
+		def property(name)
+			class_eval { attr_reader name }
+		end
+
+		# @param [Hash] attrs
+		def run(attrs)
+			new(attrs).run
+		end
+
+		alias_method :[], :run
+	end
+
+	# @param [Hash] attrs
+	def initialize(attrs)
+		attrs.each { |key, val| instance_variable_set("@#{key}", val) }
+	end
+
+	# to perform/run the service actions\tasks
+	def run
+		function
+	end
+
+	#  here you should write your function code =)
+	def function
+		raise NotImplemented
+	end
+end

data/lib/frigate/operation/action/base.rb

@@ -0,0 +1,65 @@
+module Frigate
+	module Operation
+		module Action
+			# Base class is an abstact class
+			# @abstract
+			class Base
+				class << self
+					# Initializes action class and pass args to instance run method
+					# @param [Frigate::Operation] operation receives an instace of subclass of Frigate::Operation
+					# @param [Hash] params
+					# @param [Hash] opts
+					def run(operation, params, opts={})
+						new(operation, opts).run(params)
+					end
+				end
+
+				attr_reader :opts, :operation, :model, :model_form, :action_result, :params
+
+				# @param [Frigate::Operation] operation
+				# @param [Hash] opts
+				def initialize(operation, opts={})
+					@operation = operation
+					@opts = opts
+				end
+
+				# Runs action's mechanism
+				def run(params)
+					(@params = params); action; model_form
+				end
+
+				# You should define an action in here
+				def action
+					raise NotImplementedError
+				end
+
+				protected
+
+				# Gets a model class of defined model class for operation
+				def model_klass
+					operation.class.model_klass
+				end
+
+				# Creates an instance of operation subclass of Frigate::Form for given model
+				def create_form(model)
+					operation.class.form_class.new(model)
+				end
+
+				# A getter/caller of operation_block from an operation class variable *operation_block*
+				# @note if no args passed then return the value of class variable *operation_block*
+				# @note if args passed then class variable *operation_block* is going to be called with these args
+				def operation_block(*args)
+					if args.empty?
+						operation.class.operation_block
+					else
+						if operation_block.nil?
+							raise StandardError.new('operation_block is nil')
+						else
+							operation.class.operation_block.call(*args)
+						end
+					end
+				end
+			end
+		end
+	end
+end

data/lib/frigate/operation/action/create.rb

@@ -0,0 +1,21 @@
+module Frigate
+	module Operation
+		module Action
+			# Is here to perform create action of operation
+			class Create < Base
+				# An create action is defined in here
+				def action
+					@model = model_klass.new
+					@model_form = create_form(model)
+					if model_form.validate(params)
+						if operation_block
+							operation_block(model, params)
+						else
+							model_form.sync_with_model(save: true)
+						end
+					end
+				end
+			end
+		end
+	end
+end

data/lib/frigate/operation/action/update.rb

@@ -0,0 +1,24 @@
+module Frigate
+	module Operation
+		module Action
+			# Is here to perform update action of operation
+			class Update < Base
+				# An update action is defined in here
+				def action
+					@model = model_klass.find_by_id(params[:id]) # TODO: add id verification
+					@model_form = create_form(model)
+					if model_form.validate(params)
+						if operation_block
+							operation_block(model, params)
+						else
+							model_form.sync_with_model(save: true)
+						end
+					else
+						exception = InvalidParamsError.new('invalid params in %s' % operation.class.name)
+						raise (exception.tap { |e| e.errors = model_form.errors })
+					end
+				end
+			end
+		end
+	end
+end

data/lib/frigate/operation/action.rb

@@ -0,0 +1,12 @@
+module Frigate
+	module Operation
+		# This module consists action classes for operation
+		module Action
+			# code; mb some configs
+		end
+	end
+end
+#
+require 'frigate/operation/action/base'
+require 'frigate/operation/action/create'
+require 'frigate/operation/action/update'

data/lib/frigate/operation/base.rb

@@ -0,0 +1,79 @@
+module Frigate
+	module Operation
+		# Is here initialize the whole operation class
+		# A bigger description will be available soon
+		class Base
+			ALLOWED_ACTIONS = [:create, :update]
+
+			class << self
+				# Initializes form class and serves as a getter method
+				def form_class
+					@form_class ||= Class.new(Frigate::Form::Base)
+				end
+
+				# Serves as a getter method for *model_klass* class variable
+				def model_klass
+					@model_klass ? @model_klass : (raise StandardError.new('@model_klass nil'))
+				end
+
+				# Serves as a getter method for *operation_action* class variable
+				def operation_action
+					@operation_action ? @operation_action : (raise StandardError.new('@operation_action nil'))
+				end
+
+				# Serves as a getter method for *operation_block* class variable
+				def operation_block
+					# @operation_block.is_a?(Proc) ? @operation_block : (raise StandardError.new('operation block is not a Proc'))
+					@operation_block
+				end
+
+				# @param [Class] model_klass
+				def model(model_klass)
+					@model_klass = model_klass
+				end
+
+				# @param [Symbol] action
+				def action(action)
+					ALLOWED_ACTIONS.include?(action) ? (@operation_action = action.to_sym) : (raise ArgumentError.new('action is invalid'))
+				end
+
+				# @param [Proc] block
+				def operation(&block)
+					@operation_block = block
+				end
+
+				delegate :property, :has_one, to: :form_class
+
+				# @param [Hash] params
+				# @param [Hash] opts
+				def run(params, opts={})
+					new(opts).run(params)
+				end
+			end
+
+			attr_reader :params, :opts, :model_form
+
+			delegate :errors, :model, to: :model_form
+
+			# @param [Hash] opts
+			def initialize(opts={})
+				@opts = opts
+			end
+
+			# Runs the whole operation mechanism
+			# @param [Hash] params
+			# @return [Frigate::Operations] returns self
+			def run(params)
+				@params = Hashie::Mash.new(params)
+				# running actions
+				case self.class.operation_action
+				when :update
+					@model_form = Action::Update.run(self, params)
+				else
+					@model_form = Action::Create.run(self, params)
+				end
+				self # return self
+			end
+		end
+	end
+end

data/lib/frigate/operation/controller.rb

@@ -0,0 +1,42 @@
+require 'active_support/concern'
+module Frigate
+	module Operation
+		# Some stuff for controllers
+		module Controller
+			# Helpers for rails controllers
+			module Helpers
+				extend ActiveSupport::Concern
+
+				included do
+					rescue_from InvalidParamsError, with: :invalid_params_error
+
+					def invalid_params_error(exception)
+						respond_to do |f|
+							f.json do
+								render status: 400, json: {
+										status: 'error',
+										data: exception.errors.messages
+									}
+							end
+						end
+					end
+				end
+
+				# run-operation helps to run operation elegantly
+				# @param [Frigate::Operation] klass
+				# @param [Hash] params
+				def run_operation(klass, params)
+					klass.run(params)
+				end
+
+				# render-operation helps to render operation data
+				# @param [Frigate::Operation] klass
+				# @param [Hash] params
+				def render_operation(*args)
+					run_operation(*args).render(self)
+					# raise run_operation(*args).errors.messages.inspect
+				end
+			end
+		end
+	end
+end

data/lib/frigate/operation/invalid_params_error.rb

@@ -0,0 +1,7 @@
+module Frigate
+	module Operation
+		class InvalidParamsError < StandardError
+			attr_accessor :errors
+		end
+	end
+end

data/lib/frigate/operation/renderable.rb

@@ -0,0 +1,52 @@
+module Frigate
+	module Operation
+		# allows operation to be rendered as json for now))
+		module Renderable
+			def self.included(base)
+				base.extend(ClassMethods)
+			end
+
+			module ClassMethods
+				def render_block
+					@render_block
+				end
+
+				def render(render_block)
+					if render_block.is_a?(Proc)
+						@render_block ||= render_block
+					else
+						raise StandardError.new('render_block is not a Proc')
+					end
+				end
+			end
+
+			# @param [ActionController::Base] ctrl An Instance of subclass of ActionController::Base
+			def render(ctrl)
+				ctrl.respond_to do |f|
+					f.json do
+						ctrl.render status: (model_form.valid? ? 200 : 400), json: build_json(ctrl)
+					end
+				end
+			end
+
+			private
+
+			# @param [ActionController::Base] ctrl An Instance of subclass of ActionController::Base
+			def build_json(ctrl)
+				if model_form.valid?
+					Jbuilder.new { |_j| _j.status 'success'; _j.data { render_op(_j, self, ctrl) } }.target!
+				else
+					Jbuilder.new do |_j|
+						_j.status 'error'
+						_j.errors errors.messages
+					end.target!
+				end
+
+			end
+
+			def render_op(*args)
+				self.class.render_block.call(*args) if self.class.render_block.is_a?(Proc)
+			end
+		end
+	end
+end

data/lib/frigate/operation/worker.rb

@@ -0,0 +1,50 @@
+module Frigate
+	module Operation
+# A module that allows operation to perform as a background job, using Sidekiq as BJ for now
+		module Worker
+			# Included hook
+			def self.included(base)
+				base.send(:include, Sidekiq::Worker) # TODO: this will work with any background gem.
+				base.extend(ClassMethods)
+			end
+
+			# Class methods of class that includes *Worker* module
+			module ClassMethods
+				# Overrides standard *run* method in order to run an operation as a background job
+				# @param [Hash] params
+				# @param [Hash] options
+				def run(params, options = {})
+					serialized_params = serialize_params(params)
+					is_background? ? perform_async(serialized_params) : new.perform(serialized_params)
+				end
+
+				# Whether or not operation is background
+				# @return [Boolean] either background or not
+				def is_background?
+					!(Rails.env.test? || Rails.env.cucumber?) ||
+						(!ENV['FRIGATE_WORKER'].nil? || ENV['FRIGATE_WORKER'].downcase == 'true')
+				end
+
+				private
+				# serializes params
+				# @param [Hash] params
+				def serialize_params(params)
+					params # TODO: serialize AR for e.g.
+				end
+			end
+
+			# Method that runs operation mechanism. It's here because of Sidekiq::Worker needs it
+			# @param [Hash] params income parameters
+			def perform(params)
+				run(deserialize_params(params))
+			end
+
+			private
+			# deserializes params
+			# @param [Hash] params
+			def deserialize_params(params)
+				Hashie::Mash.new(params) # TODO: deserialize AR for e.g.
+			end
+		end
+	end
+end

data/lib/frigate/operation.rb

@@ -0,0 +1,16 @@
+require 'hashie/mash'
+#
+# This class serves as an abstact layer between model and controller
+#
+module Frigate
+	module Operation
+		# code; mb some configs
+	end
+end
+#
+require 'frigate/operation/invalid_params_error'
+require 'frigate/operation/worker'
+require 'frigate/operation/controller'
+require 'frigate/operation/renderable'
+require 'frigate/operation/action'
+require 'frigate/operation/base'

data/lib/frigate/version.rb

@@ -0,0 +1,3 @@
+module Frigate
+	VERSION = "0.0.1" # the version of gem
+end

data/lib/frigate.rb

@@ -0,0 +1,61 @@
+require "frigate/version"
+require 'active_support/core_ext/object/duplicable'
+require 'active_support/core_ext/object/deep_dup'
+require 'active_support/concern'
+require 'active_model'
+require 'hashie/mash'
+#
+# Description of this module is going to be relised soon
+#
+module Frigate
+end
+#
+# Requiring Frigate's modules
+#
+require 'frigate/form'
+require 'frigate/operation'
+require 'frigate/function'
+#
+# Typecaster for boolean values. Source: http://drawingablank.me/blog/ruby-boolean-typecasting.html
+#
+class String
+	def to_bool
+		return true if self == true || self =~ (/^(true|t|yes|y|1)$/i)
+		return false if self == false || self.blank? || self =~ (/^(false|f|no|n|0)$/i)
+		raise ArgumentError.new("invalid value for Boolean: \"#{self}\"")
+	end
+end
+#
+class Fixnum
+	def to_bool
+		return true if self == 1
+		return false if self == 0
+		raise ArgumentError.new("invalid value for Boolean: \"#{self}\"")
+	end
+end
+#
+class TrueClass
+	def to_i;
+		1;
+	end
+
+	def to_bool;
+		self;
+	end
+end
+#
+class FalseClass
+	def to_i;
+		0;
+	end
+
+	def to_bool;
+		self;
+	end
+end
+#
+class NilClass
+	def to_bool;
+		false;
+	end
+end

data/spec/fixtures/user_form.rb

@@ -0,0 +1,34 @@
+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

data/spec/frigate/form/base_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+RSpec.describe Frigate::Form::Base do
+	let(:params) { { email: 'z1@zzz.zz', user_profile: { first_name: 'John', last_name: 'Doe', skype: 'johndoe' } } }
+	let(:tree_params) { params.tap { |_p| _p[:user_profile][:user_profile_passport] = { number: 'KL1234', country: 'Ukraine', city: 'Kiev' } } }
+	let(:user_model) { User.new.tap { |user| user.build_user_profile } }
+	let(:user_model_tree) { User.new.tap { |user| user.build_user_profile; user.profile.build_user_profile_passport } }
+
+	before(:example) do
+		@user_model = user_model
+		@user_model_tree = user_model_tree
+		@user_form = UserForm.new(@user_model)
+		@user_form_custom = UserFormCustom.new(@user_model)
+		@user_form_tree = UserFormTree.new(@user_model_tree)
+	end
+
+	context '#valid?' do
+		it 'returns true' do
+			@user_form.validate(params)
+			expect(@user_form.valid?).to be_truthy
+		end
+		it 'returns false' do
+			@user_form.validate({})
+			expect(@user_form.valid?).to be_falsey
+		end
+	end
+
+	context '#errors' do
+		it 'messages should not be empty' do
+			@user_form.validate({})
+			expect(@user_form.errors.messages).not_to be_empty
+		end
+	end
+
+	context '#sync_with_model' do
+		it 'should sync params with model' do
+			@user_form.validate(params)
+			@user_form.sync_with_model
+			expect(@user_model.email).to eq(params[:email])
+			expect(@user_model.user_profile.first_name).to eq(params[:user_profile][:first_name])
+		end
+	end
+
+	context 'contract' do
+		before(:example) do
+			@user_form = UserForm.new(@user_model, contract: true)
+			@user_form.validate
+		end
+
+		context '#valid?' do
+			it 'returns false' do
+				expect(@user_form.valid?).to be_falsey
+			end
+		end
+
+		context '#errors' do
+			it 'messages should not be empty' do
+				expect(@user_form.errors.messages).not_to be_empty
+			end
+		end
+	end
+
+	context 'custom validations' do
+		context '#valid?' do
+			it 'return true' do
+				@user_form_custom.validate(params)
+				expect(@user_form_custom.valid?).to be_truthy
+			end
+			it 'return false' do
+				params[:email] = 'bad-email.com'
+				@user_form_custom.validate(params)
+				expect(@user_form_custom.valid?).to be_falsey
+			end
+		end
+	end
+
+	context 'long tree' do
+		context '#sync_with_model' do
+			it 'should sync params with model' do
+				@user_form_tree.validate(tree_params)
+				@user_form_tree.sync_with_model
+				expect(@user_model_tree.profile.passport.number).to eq(params[:user_profile][:user_profile_passport][:number])
+			end
+		end
+	end
+
+	context 'delegation' do
+		before(:example) do
+			@user_form.validate(params)
+		end
+
+		it 'properties' do
+			expect(@user_form.email).to be_a(::Frigate::Form::Property)
+		end
+
+		it 'associations' do
+			expect(@user_form.user_profile).to be_a(::Frigate::Form::Association)
+			expect(@user_form.user_profile.first_name).to be_a(::Frigate::Form::Property)
+		end
+	end
+
+	describe Frigate::Form::Property do
+		context '#root' do
+			it 'should be instance of Frigate::Form::Base' do
+				@user_form.validate(params)
+				expect(@user_form.email.root).to be_a(Frigate::Form::Base)
+				expect(@user_form.user_profile.first_name.root).to be_a(Frigate::Form::Base)
+			end
+		end
+	end
+
+	describe Frigate::Form::Association do
+		context '#root' do
+			it 'should be instance of Frigate::Form::Base' do
+				@user_form.validate(params)
+				expect(@user_form.user_profile.root).to be_a(Frigate::Form::Base)
+			end
+		end
+	end
+end