json-spec 0.1.0

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

@@ -0,0 +1,43 @@
+require_relative 'abstract-expectations-runner'
+
+module CabezaDeTermo
+	module JsonSpec
+		class ExpectationsRunner < AbstractExpectationsRunner
+			def initialize()
+				@expectations = []
+			end
+
+			# Adding
+
+			def add(expectation)
+				@expectations << expectation
+			end
+
+			# Accessing
+
+			def expectations
+				@expectations
+			end
+
+			# Walking
+
+			def accept_walker(expression_walker)
+				expression_walker.walk_expectation_runner(self)
+			end
+
+			def accept_walker_with_value_holder(expression_walker, value_holder)
+				expectations.each do |each_expectation|
+					each_expectation.accept_walker(expression_walker)
+				end
+			end
+
+			# Explaining
+
+			def explain_with(expression_walker)
+				expectations.each do |each_expectation|
+					expression_walker.walk_expectation(each_expectation)
+				end
+			end
+		end
+	end
+end

data/lib/cabeza-de-termo/json-spec/expressions/json-any-of.rb

@@ -0,0 +1,62 @@
+require_relative "json-expression"
+
+module CabezaDeTermo
+	module JsonSpec
+		#
+		# A JsonExpression that represents the expectations of several possible expressions to expect.
+		#
+		class JsonAnyOf < JsonExpression
+			#
+			# The expression that holds the expectations of each item in a json list.
+			#
+			# @param JsonExpression parent_expression The parent expression in the parse tree.
+			#
+			def initialize(parent_expression)
+				super(parent_expression)
+
+				@possible_expressions = []
+			end
+
+			def possible_expressions()
+				@possible_expressions
+			end
+
+			# Expectations
+
+			def expect(type, &block)
+				expect_a(type, &block)
+			end
+
+			def expect_an(type, &block)
+				expect_a(type, &block)
+			end
+
+			def expect_a(type, &block)
+				expression = add_posibble_expression( new_expression_for(type) )
+
+				Bind.evaluation of: block, to: self unless block.nil?
+
+				expression
+			end
+
+			def add_posibble_expression(expression)
+				possible_expressions << expression
+
+				expression
+			end
+
+			# 
+			# Some intention revealing sugar to make the spec building clearer.
+			#
+			def or_also()
+				self
+			end
+
+			# Walking expressions
+
+			def accept_walker(expression_walker)
+				expression_walker.walk_json_any_of(self)
+			end
+		end
+	end
+end

data/lib/cabeza-de-termo/json-spec/expressions/json-anything.rb

@@ -0,0 +1,16 @@
+require_relative "json-expression"
+
+module CabezaDeTermo
+	module JsonSpec
+		#
+		# A JsonExpression that represents any expression
+		#
+		class JsonAnything < JsonExpression
+			# Walking expressions
+
+			def accept_walker(expression_walker)
+				expression_walker.walk_json_anything(self)
+			end
+		end
+	end
+end

data/lib/cabeza-de-termo/json-spec/expressions/json-each-field.rb

@@ -0,0 +1,58 @@
+require_relative "json-expression"
+
+module CabezaDeTermo
+	module JsonSpec
+		#
+		# A JsonExpression that represents what each item in a JsonList must expect.
+		#
+		class JsonEachField < JsonExpression
+			def initialize(parent_expression)
+				super(parent_expression)
+
+				@name_expression = new_json_field_name_expression
+				@value_expression = nil
+			end
+
+			# Accessing
+
+			def name_expression()
+				@name_expression
+			end
+
+			def value_expression()
+				@value_expression
+			end
+
+			# Expectations
+
+			#
+			# Answer the [JsonFieldName] so it can receive expectations.
+			#
+			def expect_name()
+				@name_expression
+			end
+
+			def expect(type, &block)
+				expect_a(type, &block)
+			end
+
+			def expect_an(type, &block)
+				expect_a(type, &block)
+			end
+
+			def expect_a(type, &block)
+				@value_expression = new_expression_for(type)
+
+				Bind.evaluation of: block, to: @value_expression unless block.nil?
+
+				@value_expression
+			end
+
+			# Walking expressions
+
+			def accept_walker(expression_walker)
+				expression_walker.walk_json_each_field(self)
+			end
+		end
+	end
+end

data/lib/cabeza-de-termo/json-spec/expressions/json-each.rb

@@ -0,0 +1,58 @@
+require_relative "json-expression"
+
+module CabezaDeTermo
+	module JsonSpec
+		#
+		# A JsonExpression that represents what each item in a JsonList must expect.
+		#
+		class JsonEach < JsonExpression
+			#
+			# The expression that holds the expectations of each item in a json list.
+			# @var JsonExpression
+			#
+			def initialize(parent_expression)
+				super(parent_expression)
+
+				@each_item_expression = nil
+			end
+
+			def each_item_expression()
+				@each_item_expression
+			end
+
+			# Asking
+
+			def has_each_item_expression?()
+				!no_each_item_expression?
+			end
+
+			def no_each_item_expression?()
+				@each_item_expression.nil?
+			end
+
+			# Expecting expressions
+
+			def expect(type, &block)
+				expect_a(type, &block)
+			end
+
+			def expect_an(type, &block)
+				expect_a(type, &block)
+			end
+
+			def expect_a(type, &block)
+				@each_item_expression = new_expression_for(type)
+
+				Bind.evaluation of: block, to: @each_item_expression unless block.nil?
+
+				@each_item_expression
+			end
+
+			# Walking expressions
+
+			def accept_walker(expression_walker)
+				expression_walker.walk_json_each(self)
+			end
+		end
+	end
+end

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

@@ -0,0 +1,314 @@
+require "cabeza-de-termo/json-spec/expectations/runner/expectations-runner"
+require "cabeza-de-termo/json-spec/walkers/json-expression-explainer"
+require "cabeza-de-termo/json-spec/metaprogramming/object-method"
+
+module CabezaDeTermo
+	module JsonSpec
+		#
+		# Base class for JsonExpression representing nodes in a json parse tree.
+		#
+		class JsonExpression
+			#
+			# @param JsonExpression parent_expression The parent expression in the parse tree.
+			#
+			def initialize(parent_expression)
+				@parent_expression = parent_expression
+				@expectations_runner = new_expectations_runner
+
+				add_default_expectations
+			end
+
+			# Accessing
+
+			#
+			# Get the parent expression in the parse tree.
+			#
+			# @return JsonExpression
+			#
+			def parent_expression()
+				@parent_expression
+			end
+
+			#
+			# Set the parent expression in the parse tree.
+			#
+			def set_parent_expression(parent_expression)
+				@parent_expression = parent_expression
+			end
+
+			#
+			# Get the expectations_runner with the Expectations to run on the value 
+			# coresponding to self expression of a json object.
+			#
+			# @return expectations_runnerInterface
+			#
+			def expectations_runner()
+				@expectations_runner
+			end
+
+			#
+			# Set the expectations_runner with Expectations to run on the value coresponding to self
+			# expression of a json object.
+			#
+			# @param expectations_runnerInterface expectations_runner
+			#
+			def set_expectations_runner(expectations_runner)
+				@expectations_runner = expectations_runner
+			end
+
+			#
+			# Answer the top most JsonSpec expression.
+			# Implemented by bubbling self message up to the JsonSpec object.
+			#
+			# @return JsonSpec
+			#
+			def json_spec()
+				parent_expression.json_spec
+			end
+
+			#
+			# Answer the global ExpectationsLibrary.
+			#
+			# @return JsonSpec
+			#
+			def global_expectations_library()
+				json_spec.global_expectations_library
+			end
+
+			# Error handling
+
+			#
+			# When we receive a message that we don't understand, check if
+			#
+			# - it is an expectation message, then add the expected Expectation to self expression
+			# - it is a modifier message, then run the modifier on self expression
+			# - if none of the above, bubble the message up to the parent expression, so it can handle
+			#   it.
+			#
+			# @param Message message The message that self object does not understand.
+			#
+			# @return mixed Answer whatever the actual handler of the message answered
+			#
+			def method_missing(method_name, *args, &block)
+				message = Message.new(method_name.to_sym, *args, &block)
+
+				return add_expectation_from_library(message) if is_an_expectations_library_method?(message)
+				return perform_modifier_from_library(message) if is_a_modifier_library_method?(message)
+
+				super(method_name, *args, &block)
+			end
+
+			# Asking
+
+			#
+			# Answer true if the Message is an expectation message.
+			#
+			# @param Message message The message that self object does not understood.
+			#
+			# @return boolean
+			#
+			def is_an_expectations_library_method?(message)
+				global_expectations_library.has_expectation_for?(message.method_name)
+			end
+
+			#
+			# Answer true if the Message is a modifier message.
+			#
+			# @param Message message The message that self object does not understood.
+			#
+			# @return boolean
+			#
+			def is_a_modifier_library_method?(message)
+				global_expectations_library.has_modifier_for?(message.method_name)
+			end
+
+			# Defining Expectations
+
+			#
+			# Add the default expectations for this expression.
+			#
+			def add_default_expectations()
+				default_expectations.each do |message|
+					message.send_to(self)
+				end
+			end
+
+			#
+			# Answer the default expectations for this expression.
+			# Subclasses should override self methos accondingly.
+			#
+			def default_expectations()
+				[]
+			end
+
+			#
+			# Create a new Expectation from the ExpectationsLibrary corresponding to the Message
+			# and add it to self expression Expectations.
+			# Answer self expression.
+			#
+			# @param Message message The message that self object does not understood.
+			#
+			# @return JsonExpression
+			#
+			def add_expectation_from_library(message)
+				expectation = global_expectations_library.new_expectation_from_message(message)
+
+				expectation.set_expectation_method(message.method_name)
+				expectation.set_json_spec(json_spec)
+
+				add_expectation(expectation)
+
+				Bind.evaluation of: message.block, to: self unless message.block.nil?
+
+				self
+			end
+
+			#
+			# Create a new modifier from the ExpectationsLibrary corresponding to the Message
+			# and allow it to modify self expression.
+			# Answer self expression.
+			#
+			# @param Message message The message that self object does not understood.
+			#
+			# @return JsonExpression
+			#
+			def perform_modifier_from_library(message)
+				modifier = global_expectations_library
+									.new_modifier_from_message(message)
+
+				run_modifier(modifier)
+
+				Bind.evaluation of: message.block, to: self unless message.block.nil?
+
+				self
+			end
+
+			def run_modifier(modifier)
+				modifier.run_on(self)
+			end
+
+			#
+			# Add an Expectation it to self expression Expectations.
+			# Answer self expression.
+			#
+			# @param Message message The message that self object does not understood.
+			#
+			# @return JsonExpression
+			#
+			def add_expectation(expectation)
+				expectations_runner.add(expectation)
+			end
+
+			#
+			# Send to object a message named method_name with self expression as its parameter
+			# to allow it to add more expectations to self expression.
+			# Answer the same that answers the message sent.
+			#
+			# @param mixed object The object receiving the message.
+			#
+			# @param string method_name The name of the method to invoke on the object.
+			#
+			# @return mixed
+			#
+			def to_be_as_defined_in(object, method_name)
+				to_be_as_defined_by( ObjectMethod.new(object, method_name) )
+			end
+
+			#
+			# Evaluate the Valuable with self expression as its parameter to allow it to add more 
+			# expectations to self expression.
+			# Answer the same that answers the Valuable.
+			#
+			# @param Valuable valuable The object to evaluate with self expression as its parameter.
+			#
+			# @return mixed
+			#
+			def to_be_as_defined_by(callable)
+				callable.call(self)
+			end
+
+			# Default Expectations
+
+			#
+			# Answer a collection of default Expectations to add to a new expression of type 
+			# json_expression_type.
+			#
+			# @param string json_expression_type The type of the expression.
+			#
+			# @return Expectation[]
+			#
+			def default_expectations_for(json_expression_type)
+				json_spec.default_expectations_for(json_expression_type)
+			end
+
+			# Instance creation
+
+			def new_expression_for(type)
+				return new_scalar_expression if type == :scalar
+				return new_object_expression if type == :object
+				return new_list_expression if type == :list
+				return new_any_of_expression if type == :any_of
+				return new_anything_expression if type == :anything
+
+				raise "Invalid expected type: #{type.inspect}"
+			end
+
+			#
+			# Answer an ExpectationInterface to hold the Expectations on this expression.
+			#
+			# @return ExpectationInterface
+			#
+			def new_expectations_runner()
+				ExpectationsRunner.new
+			end
+
+			def new_object_expression()
+				JsonObject.new(self)
+			end
+
+			def new_list_expression()
+				JsonList.new(self)
+			end
+
+			def new_scalar_expression()
+				JsonScalar.new(self)
+			end
+
+			def new_any_of_expression()
+				JsonAnyOf.new(self)
+			end
+
+			def new_json_field_name_expression()
+				JsonFieldName.new(self)
+			end
+
+			def new_json_each_expression()
+				JsonEach.new(self)
+			end
+
+			def new_anything_expression()
+				JsonAnything.new(self)
+			end
+
+			#
+			# Create a new JsonField named field_name.
+			#
+			# @param string field_name The name of the field to create on self JsonObject.
+			#
+			# @return JsonField
+			#
+			def new_named_field_expression(field_name)
+				JsonField.new(self, field_name)
+			end
+
+			#
+			# Create a new JsonEachField.
+			#
+			# @return JsonEachField
+			#
+			def new_each_field()
+				JsonEachField.new(self)
+			end
+		end
+	end
+end