json-spec 0.1.0

data/lib/cabeza-de-termo/json-spec/value-holders/accessors-chain.rb

@@ -0,0 +1,27 @@
+module CabezaDeTermo
+	module JsonSpec
+		#
+		# Models the chain of accessors to get to a value in a json tree.
+		# For instance, something like
+		#
+		#		['users', '[3]', 'addresses', '[0]', 'street']
+		#
+		class AccessorsChain
+			def initialize(accessors = ['@'])
+				@accessors = accessors
+			end
+
+			def accessors()
+				@accessors
+			end
+
+			def append_accessor(accessor)
+				self.class.new( accessors + [accessor] )
+			end
+
+			def to_s()
+				accessors.join('.')
+			end
+		end
+	end
+end

data/lib/cabeza-de-termo/json-spec/value-holders/missing-value.rb

@@ -0,0 +1,21 @@
+module CabezaDeTermo
+	module JsonSpec
+		#
+		# This object only purpose is to model a missing value from a json field or index.
+		# For instance, if we have the following Json:
+		#
+		# <code>
+		# {
+		#		"id": 123,
+		# }
+		# </code>
+		#
+		# and we ask for the field 'name', the answer will be a ValueHolder holding a MissingValue.
+		#
+		class MissingValue
+			def to_s()
+				'Missing value'
+			end
+		end
+	end
+end

data/lib/cabeza-de-termo/json-spec/value-holders/value-holder.rb

@@ -0,0 +1,135 @@
+require_relative "missing-value"
+require_relative "accessors-chain"
+require "cabeza-de-termo/json-spec/errors/unkown-json-type-error"
+
+module CabezaDeTermo
+	module JsonSpec
+		#
+		# The value holder is passed though the ExpressionWalker during the processing of 
+		# a json object.
+		#
+		class ValueHolder
+			#
+			# Answer a new ValueHolder on a MissingValue.
+			#
+			def self.new_value_holder_with_missing_value(accessors_chain = nil)
+				self.new(MissingValue.new, accessors_chain)
+			end
+
+			def initialize (value, accessors_chain = nil)
+				@value = value
+				@accessors_chain = accessors_chain.nil? ? AccessorsChain.new : accessors_chain
+			end
+
+			# Accessing
+
+			def value()
+				@value
+			end
+
+			def accessors_chain()
+				@accessors_chain
+			end
+
+			def value_holder_on_field_named(name)
+				return new_value_holder(value[name], name) if can_access_field_named?(name)
+				new_missing_value_holder(name)
+			end
+
+			def value_holder_at_index(i)
+				name = '[' + i.to_s + ']'
+
+				return new_value_holder(value[i], name) if can_access_field_at_index?(i)
+				new_missing_value_holder(name)
+			end
+
+			def field_names()
+				return value.keys if is_object?
+				[]
+			end
+
+			#
+			# Answer the length of the value.
+			# For {} is the number of fields.
+			# For []  the number of elements.
+			# For strings its length.
+			# And for any other type, it throws an UnkownJsonTypeError.
+			#
+			def length()
+				return value.length if is_object?
+				return value.length if is_list?
+				return value.length if is_string?
+				return 0 if is_missing_value?
+
+				raise UnkownJsonTypeError.new('Can not get the length of an unknown type')
+			end
+
+			# Asking
+
+			def is_missing_value?()
+				value.kind_of?(MissingValue)
+			end
+
+			def not_missing_value?()
+				!is_missing_value?
+			end
+
+			#
+			# Answer whether the value is empty or not.
+			# For {} to be empty means not to have any field.
+			# For [], not to have any element.
+			# For strings, to be ''.
+			# And for any other type, it throws an UnkownJsonTypeError.
+			#
+			def is_empty?()
+				length == 0
+			end
+
+			# Instance creation
+
+			#
+			# Answer a new ValueHolder on the value and with the name added to its accessors_chain.
+			#
+			def new_value_holder(value, accessor)
+				new_nccessors_chain = accessors_chain.append_accessor(accessor)
+				ValueHolder.new(value, new_nccessors_chain)
+			end
+
+			#
+			# Answer a new ValueHolder on a MissingValue and with the name added to its accessors_chain.
+			#
+			def new_missing_value_holder(accessor)
+				new_nccessors_chain = accessors_chain.append_accessor(accessor)
+				self.class.new_value_holder_with_missing_value(new_nccessors_chain)
+			end
+
+			protected
+
+			#
+			# Answer true if the value is a stdClass and has a property named name.
+			#
+			def can_access_field_named?(name)
+				is_object? && value.has_key?(name)
+			end
+
+			#
+			# Answer true if the value is an array and has an index i defined.
+			#
+			def can_access_field_at_index?(i)
+				is_list? && i.between?(0, length - 1)
+			end
+
+			def is_object?()
+				value.kind_of?(::Hash)
+			end
+
+			def is_list?()
+				value.kind_of?(::Array)
+			end
+
+			def is_string?()
+				value.kind_of?(::String)
+			end
+		end
+	end
+end

data/lib/cabeza-de-termo/json-spec/version.rb

@@ -0,0 +1,5 @@
+module CabezaDeTermo
+	module JsonSpec
+		VERSION = "0.1.0"
+	end
+end

data/lib/cabeza-de-termo/json-spec/walkers/expression-walker.rb

@@ -0,0 +1,66 @@
+module CabezaDeTermo
+	module JsonSpec
+		class ExpressionWalker
+			def walk_on(json_walkable)
+				json_walkable.accept_walker(self)
+			end
+
+			def walk_json_spec(json_spec)
+				raise 'Subclass responsibility'
+			end
+
+			def walk_json_object(json_object)
+				raise 'Subclass responsibility'
+			end
+
+			def walk_json_each_field(json_each_field)
+				raise 'Subclass responsibility'
+			end
+
+			def walk_json_field_name(json_field_name)
+				raise 'Subclass responsibility'
+			end
+
+			def walk_json_list(json_list)
+				raise 'Subclass responsibility'
+			end
+
+			def walk_json_each(json_each)
+				raise 'Subclass responsibility'
+			end
+
+			def walk_json_field(json_field)
+				raise 'Subclass responsibility'
+			end
+
+			def walk_json_scalar(json_scalar)
+				raise 'Subclass responsibility'
+			end
+
+			def walk_json_any_of(json_any_of)
+				raise 'Subclass responsibility'
+			end
+
+			def walk_json_anything(json_anything)
+				raise 'Subclass responsibility'
+			end
+
+			def walk_expectation_runner(expectation_runner)
+				raise 'Subclass responsibility'
+			end
+
+			def walk_expectation(expectation)
+				raise 'Subclass responsibility'
+			end
+
+			# Error handling
+			def supressing(error_class, &block)
+				begin
+					block.call
+				rescue error_class
+				end
+			end
+
+		end
+	end
+end

data/lib/cabeza-de-termo/json-spec/walkers/json-expectations-runner.rb

@@ -0,0 +1,214 @@
+require_relative "expression-walker"
+require_relative "value-holders-stack-behaviour"
+require "cabeza-de-termo/json-spec/errors/validation-error"
+require 'cabeza-de-termo/json-spec/signals/skip-branch-signal'
+
+module CabezaDeTermo
+	module JsonSpec
+		class JsonExpectationsRunner < ExpressionWalker
+			include ValueHoldersStackBehaviour
+
+			# Asking
+
+			#
+			# Answer true if all the walked Expectations was satisfied.
+			#
+			# @return boolean
+			#
+			def no_errors?()
+				raise 'Subclass responsibility'
+			end
+
+			def has_errors?()
+				!no_errors?
+			end
+
+
+			# Hooks
+			def on_unwalked_field(field_name, value_holder)
+				raise 'Subclass responsibility'
+			end
+
+			def on_json_any_of_was_satisfied_with_runner(expectations_runner)
+				raise 'Subclass responsibility'
+			end
+
+			def on_json_any_of_failed_with_all_runners(expectations_runners)
+				raise 'Subclass responsibility'
+			end
+
+			def on_walked_expectation(expectation, value_holder, was_satisfied)
+				raise 'Subclass responsibility'
+			end
+
+			# Instance creation
+
+			def new_json_expectations_runner()
+				raise 'Subclass responsibility'
+			end
+
+			# Walking expressions
+
+			def in_isolation(&block)
+				supressing ValidationError, &block
+			end
+
+			def in_isolation_walk_on(json_walkable)
+				in_isolation do
+					walk_on(json_walkable)
+				end
+			end
+
+			def walk_on(json_walkable)
+				supressing SkipBranchSignal do
+					super(json_walkable)
+				end
+			end
+
+			def walk_json_spec(json_spec)
+				in_isolation_walk_on(json_spec.root_expression)
+			end
+
+			def walk_json_object(json_object)
+				walk_expectations_of(json_object)
+
+				walked_fields = walk_each_defined_field_of(json_object)
+
+				if( json_object.has_each_field? )
+					more_walked_fields = walk_json_each_field(json_object.each_field_expression)
+					walked_fields = walked_fields + more_walked_fields
+				end
+
+				unexpected_fields_from_current_value_holder(walked_fields).each do |field_name|
+					on_unwalked_field(field_name, @value_holder)
+				end
+			end
+
+			def walk_each_defined_field_of(json_object)
+				walked_fields = []
+
+				json_object.fields.each do |field|
+					with_value_holder( @value_holder.value_holder_on_field_named(field.name) ) do
+						in_isolation_walk_on(field)
+					end
+
+					walked_fields << field.name
+				end
+
+				walked_fields
+			end
+
+			def walk_each_field_name(json_each_field, field_name)
+				with_value_holder( @value_holder.new_value_holder(field_name, ':' + field_name) ) do
+					walk_on(json_each_field.name_expression)
+				end
+			end
+
+			def walk_each_field_value(json_each_field, field_name)
+				with_value_holder( @value_holder.value_holder_on_field_named(field_name) ) do
+					in_isolation_walk_on(json_each_field.value_expression)
+				end
+			end
+
+			def walk_json_each_field(json_each_field)
+				walked_fields = []
+
+				@value_holder.field_names.each do |field_name|
+					walked_fields << field_name
+					in_isolation_walk_each_field(json_each_field, field_name)
+				end
+
+				walked_fields
+			end
+
+			def in_isolation_walk_each_field(json_each_field, field_name)
+				in_isolation do
+					walk_each_field_name(json_each_field, field_name)
+					walk_each_field_value(json_each_field, field_name)
+				end
+			end
+
+			def walk_json_field_name(json_field_name)
+				walk_expectations_of(json_field_name)
+			end
+
+			def walk_json_list(json_list_expression)
+				walk_expectations_of(json_list_expression)
+
+				walk_on(json_list_expression.each_expression)
+			end
+
+			def walk_json_each(json_each)
+				walk_expectations_of(json_each)
+
+				return if json_each.no_each_item_expression?
+
+				(0...@value_holder.length).each do |i|
+					with_value_holder( @value_holder.value_holder_at_index(i) ) do
+						in_isolation_walk_on(json_each.each_item_expression)
+					end
+				end
+			end
+
+			def walk_json_field(json_field)
+				walk_on(json_field.value_expression)
+			end
+
+			def walk_json_anything(json_anything)
+				walk_expectations_of(json_anything)
+			end
+
+			def walk_json_scalar(json_scalar)
+				walk_expectations_of(json_scalar)
+			end
+
+			def walk_json_any_of(any_of)
+				sub_walkers = []
+				any_of.possible_expressions.each do |possible_expression|
+					sub_walkers << walk_with_new_walker(possible_expression)
+				end
+
+				sub_walkers.each do |each_sub_walker|
+					return on_json_any_of_was_satisfied_with_runner(each_sub_walker) if each_sub_walker.no_errors?
+				end
+
+				on_json_any_of_failed_with_all_runners(sub_walkers)
+			end
+
+			def walk_expectations_of(expression)
+				# Intentionaly dont go through :walk_on to let the SkipBranchException errors bubble up
+				walk_expectation_runner( expression.expectations_runner )
+			end
+
+			def walk_expectation_runner(expectation_runner)
+				expectation_runner.accept_walker_with_value_holder(self, @value_holder)
+			end
+
+			def walk_expectation(expectation)
+				was_satisfied = expectation.is_satisfied_by?(@value_holder)
+				on_walked_expectation(expectation, @value_holder, was_satisfied)
+
+				raise_validation_error(expectation) unless was_satisfied
+			end
+
+			# Helpers
+
+			def walk_with_new_walker(expression)
+				expectations_runner = new_json_expectations_runner
+				in_isolation do
+					expectations_runner.walk_with_value_holder(expression, @value_holder)
+				end
+
+				expectations_runner
+			end
+
+			def raise_validation_error(expectation)
+				raise ValidationError.new( expectation.failed_message_on(@value_holder) )
+			end
+
+			def unexpected_fields_from_current_value_holder(walked_fields)
+				@value_holder.field_names.reject { |field| walked_fields.include?(field) }
+			end
+		end
+	end
+end