neuroncheck 0.1.0

data/lib/neuroncheck/matcher.rb

@@ -0,0 +1,245 @@
+require 'neuroncheck/error'
+require 'neuroncheck/utils'
+require 'neuroncheck/plugin'
+
+module NeuronCheckSystem
+	# 期待する値に対応する、適切なマッチャを取得
+	def self.get_appropriate_matcher(expected, declared_caller_locations)
+		case expected
+		when DeclarationContext # 誤って「self」と記載した場合
+			raise DeclarationError, "`self` cannot be used in declaration - use `:self` instead"
+		when :self # self
+			SelfMatcher.new(declared_caller_locations) # 値がselfであるかどうかチェック
+
+		when String, Symbol, Integer
+			ValueEqualMatcher.new(expected, declared_caller_locations) # 値が等しいかどうかをチェック
+		when true, false, nil
+			ObjectIdenticalMathcer.new(expected, declared_caller_locations) # オブジェクトが同一かどうかをチェック
+		when Class, Module
+			KindOfMatcher.new(expected, declared_caller_locations) # 所属/継承しているかどうかをチェック
+		when Range
+			RangeMatcher.new(expected, declared_caller_locations) # 範囲チェック
+		when Regexp
+			RegexpMatcher.new(expected, declared_caller_locations) # 正規表現チェック
+		# when Encoding
+		# 	EncodingMatcher.new(expected, declared_caller_locations) # エンコーディングチェック
+
+		when Array
+			OrMatcher.new(expected, declared_caller_locations) # ORチェック
+
+		when Plugin::Keyword # プラグインによって登録されたキーワードの場合
+			KeywordPluginMatcher.new(expected, declared_caller_locations)
+
+		else
+			raise DeclarationError, "#{expected.class.name} cannot be usable for NeuronCheck check parameter\n  value: #{expected.inspect}"
+		end
+
+	end
+
+	class MatcherBase
+		attr_accessor :declared_caller_locations
+
+		def initialize(expected, declared_caller_locations)
+			@expected = expected
+			@declared_caller_locations = declared_caller_locations
+		end
+
+		def match?(value, self_object)
+			raise NotImplementedError
+		end
+
+		def get_error_message(signature_decl, context_caption, value, phrase_after_but: 'was')
+			locs = Utils.backtrace_locations_to_captions(@declared_caller_locations)
+
+			ret = ""
+			ret.concat(<<MSG)
+#{context_caption} must be #{expected_caption}, but #{phrase_after_but} #{Utils.truncate(value.inspect, 40)}
+          got: #{value.inspect}
+MSG
+
+			if signature_decl and signature_decl.assigned_method then
+				ret.concat(<<MSG)
+    signature: #{signature_decl.signature_caption}
+MSG
+			end
+
+			if locs.size >= 1 then
+				ret.concat(<<MSG)
+  declared at: #{locs.join("\n" + ' ' * 15)}
+
+MSG
+			end
+
+			ret
+		end
+
+		def expected_caption
+			raise NotImplementedError
+		end
+
+		def expected_short_caption
+			@expected.inspect
+		end
+
+		def meta_info_as_json
+			re = {}
+			re['type'] = self.class.name.split('::')[-1]
+			re['expected'] = @expected
+
+			re
+		end
+	end
+
+	# 値が == で等しいことを判定する
+	class ValueEqualMatcher < MatcherBase
+		def match?(value, self_object)
+			@expected == value
+		end
+
+		def expected_caption
+			@expected.inspect
+		end
+	end
+
+	# オブジェクトとして同一であることを判定する
+	class ObjectIdenticalMathcer < MatcherBase
+		def match?(value, self_object)
+			@expected.equal?(value)
+		end
+
+		def expected_caption
+			@expected.inspect
+		end
+	end
+
+	# 値が指定されたClass / Moduleに所属していることを判定する (kind_of?判定)
+	class KindOfMatcher < MatcherBase
+		def match?(value, self_object)
+			value.kind_of?(@expected)
+		end
+
+		def expected_caption
+			@expected.name
+		end
+
+		def meta_info_as_json
+			super.update('expected' => @expected.name)
+		end
+	end
+
+
+	# 指定した範囲に含まれている値であることを判定する
+	class RangeMatcher < MatcherBase
+		def match?(value, self_object)
+			@expected.include?(value)
+		end
+
+		def expected_caption
+			"included in #{@expected.inspect}"
+		end
+	end
+
+	# 指定した正規表現にマッチする文字列であることを判定する
+	class RegexpMatcher < MatcherBase
+		def match?(value, self_object)
+			(value.kind_of?(String) and @expected =~ value)
+		end
+
+		def expected_caption
+			"String that matches with #{@expected.inspect}"
+		end
+	end
+
+	# # 指定したエンコーディングを持つ文字列であることを判定する
+	# class EncodingMatcher < MatcherBase
+	# 	def match?(value, self_object)
+	# 		(value.kind_of?(String) and Encoding.compatible?(value, @expected))
+	# 	end
+	#
+	# 	def expected_caption
+	# 		"String that is compatible #{@expected.name} encoding"
+	# 	end
+	#
+	# 	def expected_short_caption
+	# 		"String compatible to #{@expected.name}"
+	# 	end
+	#
+	# end
+
+	# OR条件。渡されたマッチャ複数のうち、どれか1つでも条件を満たせばOK
+	class OrMatcher < MatcherBase
+		def initialize(child_expecteds, declared_caller_locations)
+			@child_matchers = child_expecteds.map{|x| NeuronCheckSystem.get_appropriate_matcher(x, declared_caller_locations)}
+			@declared_caller_locations = declared_caller_locations
+		end
+
+		def match?(value, self_object)
+			# どれか1つにマッチすればOK
+			@child_matchers.any?{|x| x.match?(value, self_object)}
+		end
+
+		def expected_caption
+			captions = @child_matchers.map{|x| x.expected_caption}
+
+			Utils.string_join_using_or_conjunction(captions)
+		end
+		def expected_short_caption
+			'[' + @child_matchers.map{|x| x.expected_short_caption}.join(', ') + ']'
+		end
+
+		def meta_info_as_json
+			super.update('child_matchers' => @child_matchers.map{|x| x.meta_info_as_json})
+		end
+	end
+
+
+	# selfであるかどうかを判定 (通常はreturns用)
+	class SelfMatcher < MatcherBase
+		def initialize(declared_caller_locations)
+			@declared_caller_locations = declared_caller_locations
+		end
+
+		def match?(value, self_object)
+			self_object.equal?(value)
+		end
+
+		def expected_caption
+			"self"
+		end
+		def expected_short_caption
+			"self"
+		end
+	end
+
+	# プラグインで追加されたキーワード用
+	class KeywordPluginMatcher < MatcherBase
+		def initialize(keyword, declared_caller_locations)
+			@keyword = keyword
+			@declared_caller_locations = declared_caller_locations
+		end
+
+		def match?(value, self_object)
+			@keyword.api = Plugin::KeywordAPI.new(@declared_caller_locations, self_object)
+			@keyword.match?(value)
+		end
+
+		def expected_caption
+			@keyword.api = Plugin::KeywordAPI.new(@declared_caller_locations)
+			@keyword.expected_caption
+		end
+
+		def expected_short_caption
+			@keyword.api = Plugin::KeywordAPI.new(@declared_caller_locations)
+			@keyword.expected_short_caption
+		end
+
+		def meta_info_as_json
+			@keyword.api = Plugin::KeywordAPI.new(@declared_caller_locations)
+			super.update('keyword' => keyword_name, 'expected_caption' => expected_caption).tap{|x| x.delete('expected')}.update(@keyword.get_params_as_json)
+		end
+
+		def keyword_name
+			(@keyword.class).instance_variable_get(:@keyword_name).to_s
+		end
+	end
+end

data/lib/neuroncheck/plugin.rb

@@ -0,0 +1,149 @@
+module NeuronCheckSystem
+	# 追加されたキーワード全てが動的に定義されていくモジュール
+	module Keywords
+	end
+
+	module Plugin
+
+		# NeuronCheckへ登録したキーワード(Symbol)と、それに対応するKeywordクラスの対応を格納したマップ
+		KEYWORD_CLASSES = {}
+
+		# キーワードの追加
+		def self.add_keyword(name, &block)
+			# すでに予約済みのキーワードであればエラー
+			if KEYWORD_CLASSES[name] then
+				raise PluginError, "the `#{name}' keyword has been already reserved"
+			end
+
+			# キーワードを表すクラスを作成
+			keyword_class = Class.new(Keyword, &block)
+
+			# 必要なインスタンスメソッドが全て定義されているかどうかを確認
+			if not keyword_class.method_defined?(:on_call) or
+			not keyword_class.method_defined?(:match?) or
+			not keyword_class.method_defined?(:expected_caption) then
+				raise PluginError, "##{__callee__} requires 3 method definitions - `on_call', `match?' and `expected_caption'"
+			end
+
+			# キーワードを登録
+			keyword_class.instance_variable_set(:@keyword_name, name)
+			KEYWORD_CLASSES[name] = keyword_class
+
+			# キーワードメソッドを定義
+			__define_keyword_method_to_module(name, keyword_class)
+		end
+
+		# キーワードの別名を定義
+		def self.alias_keyword(name, original_keyword_name)
+			# すでに予約済みのキーワードであればエラー
+			if KEYWORD_CLASSES[name] then
+				raise PluginError, "the `#{name}' keyword has been already reserved"
+			end
+
+			# 元キーワードが、自分が追加したキーワードの中になければエラー
+			unless KEYWORD_CLASSES[original_keyword_name] then
+				raise PluginError, "the `#{original_keyword_name}' keyword hasn't been reserved yet"
+			end
+
+			# 継承して別名クラスを作成
+			keyword_class = Class.new(KEYWORD_CLASSES[original_keyword_name])
+			keyword_class.instance_variable_set(:@keyword_name, name)
+			KEYWORD_CLASSES[name] = keyword_class
+
+			# キーワードメソッドを定義
+			__define_keyword_method_to_module(name, keyword_class)
+		end
+
+		# キーワード用のメソッドをKeywordモジュールへ定義する
+		def self.__define_keyword_method_to_module(name, keyword_class)
+			Keywords.module_eval do
+				define_method(name) do |*params|
+					# キーワードを生成
+					kw = keyword_class.new
+
+					# そのキーワードのon_callメソッドを実行
+					kw.on_call(*params)
+
+					# キーワードを返す
+					kw
+				end
+			end
+		end
+
+		# キーワードの削除
+		def self.remove_keyword(name)
+			# 自分が追加したキーワードの中になければエラー
+			unless KEYWORD_CLASSES[name] then
+				raise PluginError, "the `#{name}' keyword hasn't been reserved yet"
+			end
+
+			# 組み込みキーワードを削除使用とした場合はエラー
+			if KEYWORD_CLASSES[name].builtin_keyword? then
+				raise PluginError, "the `#{name}' keyword cannot be removed because it is NeuronCheck builtin keyword"
+			end
+
+			# キーワードを表すクラスを削除
+			KEYWORD_CLASSES.delete(name)
+
+			# キーワードメソッドの定義を削除
+			Keywords.module_eval do
+				remove_method(name)
+			end
+		end
+
+		# キーワードクラス
+		class Keyword
+			attr_accessor :api
+
+			def expected_short_caption
+		    expected_caption
+		  end
+
+			def get_params_as_json
+		    {}
+		  end
+
+			def self.builtin_keyword?
+				false
+			end
+		end
+
+		# キーワードの処理内で使用可能なAPI
+		class KeywordAPI
+			def initialize(declared_caller_locations, method_self_object = nil)
+				@declared_caller_locations = declared_caller_locations
+				@method_self_object = method_self_object
+			end
+
+			def get_appropriate_matcher(expected_value)
+				NeuronCheckSystem.get_appropriate_matcher(expected_value, @declared_caller_locations)
+			end
+
+			def expected_value_match?(value, expected_value)
+				get_appropriate_matcher(expected_value).match?(value, @method_self_object)
+			end
+
+			def get_expected_value_caption(expected_value)
+				get_appropriate_matcher(expected_value).expected_caption
+
+			end
+
+			def get_expected_value_short_caption(expected_value)
+				get_appropriate_matcher(expected_value).expected_short_caption
+
+			end
+
+			def get_expected_value_meta_info_as_json(expected_value)
+				get_appropriate_matcher(expected_value).meta_info_as_json
+
+			end
+		end
+	end
+end
+
+module NeuronCheck
+	# プラグイン有効化
+	def self.enable_plugin(plugin_name)
+		require "neuroncheck/plugin/#{plugin_name}"
+	end
+end

data/lib/neuroncheck/syntax.rb

@@ -0,0 +1,49 @@
+require 'neuroncheck/builtin_keyword'
+
+# NeuronCheckSyntaxはruby 2.0以前では使用しない (Refinementが実験的機能として定義されているため)
+unless RUBY_VERSION <= '2.0.9' then
+	NeuronCheckSystem::RUBY_TOPLEVEL = self
+
+	module NeuronCheckSyntax
+		refine Module do
+			# NeuronCheckの宣言用キーワードを、コード内の全箇所で使用可能にする
+			include NeuronCheckSystem::Keywords
+
+			# ndecl宣言 (このメソッドは初回実行時のみ呼び出されることに注意。1度ndeclを実行したら、次以降はNeuronCheckSystem::DeclarationMethodsの方が有効になるため、そちらが呼ばれる)
+			def ndecl(*expecteds, &block)
+				# モジュール/クラス内の場合の処理
+				# extend NeuronCheckが実行されていない未初期化の場合、NeuronCheck用の初期化を自動実行
+				unless @__neuron_check_extended then
+					extend NeuronCheck
+				end
+
+				# メイン処理実行
+				__neuroncheck_ndecl_main(expecteds, block, caller(1, 1))
+			end
+
+			alias ndeclare ndecl
+			alias ncheck ndecl
+			alias ntypesig ndecl
+			alias nsig ndecl
+
+			alias decl ndecl
+			alias declare ndecl
+			alias sig ndecl
+		end
+
+		# トップレベル定義のエイリアス
+		refine NeuronCheckSystem::RUBY_TOPLEVEL.singleton_class do
+			def decl(*expecteds, &block)
+				ndecl(*expecteds, &block)
+			end
+
+			def declare(*expecteds, &block)
+				ndecl(*expecteds, &block)
+			end
+
+			def sig(*expecteds, &block)
+				ndecl(*expecteds, &block)
+			end
+		end
+	end
+end

data/lib/neuroncheck/utils.rb

@@ -0,0 +1,92 @@
+module NeuronCheckSystem
+	module Utils
+		module_function
+
+		# From ActiveSupport (Thanks for Rails Team!)  <https://github.com/rails/rails/tree/master/activesupport>
+		#
+		# Truncates a given +text+ after a given <tt>length</tt> if +text+ is longer than <tt>length</tt>:
+	  #
+	  #   'Once upon a time in a world far far away'.truncate(27)
+	  #   # => "Once upon a time in a wo..."
+	  #
+	  # Pass a string or regexp <tt>:separator</tt> to truncate +text+ at a natural break:
+	  #
+	  #   'Once upon a time in a world far far away'.truncate(27, separator: ' ')
+	  #   # => "Once upon a time in a..."
+	  #
+	  #   'Once upon a time in a world far far away'.truncate(27, separator: /\s/)
+	  #   # => "Once upon a time in a..."
+	  #
+	  # The last characters will be replaced with the <tt>:omission</tt> string (defaults to "...")
+	  # for a total length not exceeding <tt>length</tt>:
+	  #
+	  #   'And they found that many people were sleeping better.'.truncate(25, omission: '... (continued)')
+	  #   # => "And they f... (continued)"
+	  def truncate(str, truncate_at, omission: '...', separator: nil)
+	    return str.dup unless str.length > truncate_at
+
+	    omission = omission || '...'
+	    length_with_room_for_omission = truncate_at - omission.length
+	    stop = \
+	      if separator
+	        rindex(separator, length_with_room_for_omission) || length_with_room_for_omission
+	      else
+	        length_with_room_for_omission
+	      end
+
+	    "#{str[0, stop]}#{omission}"
+	  end
+
+		# 1つ以上の文字列をorで結んだ英語文字列にする
+		def string_join_using_or_conjunction(strings)
+			ret = ""
+			strings.each_with_index do |str, i|
+				case i
+				when 0 # 最初の要素
+				when strings.size - 1 # 最後の要素
+					ret << " or "
+				else
+					ret << ", "
+				end
+
+				ret << str
+			end
+
+			ret
+		end
+
+		# Thread::Backtrace::Locationのリストを文字列形式に変換。フレーム数が多すぎる場合は途中を省略
+		def backtrace_locations_to_captions(locations)
+			locs = nil
+			if locations.size > 9 then
+				locs = (locations[0..3].map{|x| "from #{x.to_s}"} + [" ... (#{locations.size - 8} frames) ..."] + locations[-4..-1].map{|x| "from #{x.to_s}"})
+			else
+				locs = locations.map{|x| "from #{x.to_s}"}
+			end
+
+			if locs.size >= 1 then
+				locs.first.sub!(/\A\s*from /, '')
+			end
+
+			locs
+		end
+
+		# 指定した整数値を序数文字列にする
+		def ordinalize(v)
+			if [11,12,13].include?(v % 100)
+				"#{v}th"
+			else
+				case (v % 10)
+				when 1
+					"#{v}st"
+				when 2
+					"#{v}nd"
+				when 3
+					"#{v}rd"
+				else
+					"#{v}th"
+				end
+			end
+		end
+	end
+end