stitcher 0.1.0

data/docs/typed.md

@@ -0,0 +1,15 @@
+
+
+
+```ruby
+class X
+  let name: String, age: Numeric
+end
+x = X.new
+x.name = "homu" # OK
+x.age = 13 # OK
+x.name 13 # Error
+```
+
+
+

data/example/core_ex.rb

@@ -0,0 +1,23 @@
+# original source code
+# http://melborne.github.io/2013/08/30/monkey-patching-for-prudent-rubyists/
+require "stitcher"
+
+using Stitcher
+
+class Array
+	stitcher_require +[Fixnum, Fixnum]
+	def at *indices
+		at(indices.shift).at(*indices)
+	end
+end
+
+p [1,2,3].at(1)
+# => 1
+p [[1,2,3], [4,5,6], [7,8,9]].at(1, 2)
+# => 6
+p [
+    [[1,2,3],[4,5,6],[7,8,9]],
+    [[10,11,12],[13,14,15],[16,17,18]],
+    [[19,20,21],[22,23,24],[25,26,27]]
+].at(1, 2, 0)
+# => 16

data/example/register.rb

@@ -0,0 +1,33 @@
+require "stitcher"
+
+class X
+	extend Stitcher::Register
+
+	def initialize value
+		@value = value
+	end
+	# Register method argument types.
+	stitcher_register :initialize, [Fixnum]
+
+	# Define multi methods.
+	def plus a
+		@value + a
+	end
+	stitcher_register :plus, [Fixnum]
+
+	def plus a
+		@value + a.to_i
+	end
+	stitcher_register :plus, [String]
+end
+
+x = X.new 10
+# x = X.new "10"		# Error: No match method.
+
+# Call X#plus(Fixnum)
+p x.plus -3
+# => 7
+
+# Call X#plus(String)
+p x.plus "42"
+# => 57

data/example/simple.rb

@@ -0,0 +1,66 @@
+require "stitcher"
+
+# Using stitcher library.
+using Stitcher
+
+class Person
+	# Define accessor with variable type(Class).
+	stitcher_accessor name: String, age: Integer
+
+	def set name, age
+		self.name = name
+		self.age  = age
+	end
+	# Register set method with Argument types(Classes).
+	stitch :set, [String, Integer]
+
+	# Register for next define method.
+	stitcher_require [Hash]
+	def set hash
+		set hash[:name], hash[:age]
+	end
+
+	# Define "set" method with Argument types.
+	# set(Integer, String)
+	stitcher_define_method(:set, age: Integer, name: String){
+		self.name = name
+		self.age  = age
+	}
+
+	# Other define method
+	stitch.set(ary: [String, Integer]){
+		set *ary
+	}
+
+	def print
+		p "name:#{name} age:#{age}"
+	end
+
+	# Require format with block object.
+	stitcher_require [String] & Stitcher::Concepts.blockable
+	def print fmt
+		printf(fmt, *yield(name, age))
+	end
+end
+
+x = X.new
+x.name = "homu"
+x.age  = 14
+# x.age = 14.0		# Error: No match method.
+
+x.set "mami", 15
+x.print
+# => "name:mami age:15"
+
+x.set({ name: "saya", age: 14 })
+x.print
+# => "name:saya age:14"
+
+x.set 14, "mado"
+x.print("%s-%s\n"){ |name, age| [name, age] }
+# => mado-14
+
+x.set ["homu", 14]
+x.print("%s-%s\n"){ |name, age| [age, name] }
+# => 14-homu
+

data/example/type.rb

@@ -0,0 +1,24 @@
+require "stitcher"
+using Stitcher::Refinements::Type
+
+# Object to Type.
+# Type is Class object.
+1.type         # => Fixnum Type
+"homu".type    # => String Type
+Numeric.type   # => Numeric Type
+
+
+# Operator is like Class object operators.
+1.type == Fixnum   # => true
+1.type == Numeric  # => false
+1.type <= Numeric  # => true
+
+
+# Using | operator.
+# Example: Define Boolean type
+Boolean = TrueClass | FalseClass
+
+Boolean == true   # => true
+Boolean == false  # => true
+Boolean == nil    # => false
+Boolean == 0      # => false

data/lib/stitcher.rb

@@ -0,0 +1,40 @@
+require_relative "./stitcher/version"
+# require_relative "./stitcher/type"
+require_relative "./stitcher/define_method"
+require_relative "./stitcher/accessor"
+require_relative "./stitcher/stitch"
+require_relative "./stitcher/operators"
+require_relative "./stitcher/require"
+require_relative "./stitcher/variadic_argument"
+require_relative "./stitcher/core"
+require_relative "./stitcher/concepts"
+
+module Stitcher
+	include Accessor
+	include Stitch
+	include Require
+
+	refine Module do
+		include Stitcher
+	end
+
+	refine Class do
+		prepend Operators
+	end
+
+	refine Array do
+		prepend Operators
+	end
+
+	refine Proc do
+		prepend Operators
+	end
+
+	refine Array do
+		include VariadicArgument
+	end
+end
+
+class Module
+	include Stitcher::Core
+end

data/lib/stitcher/accessor.rb

@@ -0,0 +1,21 @@
+require_relative "./register"
+require_relative "./define_method"
+
+using Stitcher
+
+module Stitcher module Accessor
+	include Register
+
+	def stitcher_writer **opt
+		opt.each { |name, type|
+			Register.register(self, "#{name}=", [type], (DefineMethod.as_instance_executable do |var|
+				instance_variable_set "@#{name}", var
+			end))
+		}
+	end
+
+	def stitcher_accessor **opt
+		attr_reader *opt.keys
+		Accessor.instance_method(:stitcher_writer).bind(self).(opt)
+	end
+end end

data/lib/stitcher/concepts.rb

@@ -0,0 +1,6 @@
+module Stitcher module Concepts
+	def blockable
+		proc { |*args, &block| !!block }
+	end
+	module_function :blockable
+end end

data/lib/stitcher/core.rb

@@ -0,0 +1,31 @@
+require_relative "./variadic_argument"
+
+module StitcherArrayEx
+	refine Array do
+		include Stitcher::VariadicArgument
+	end
+end
+using StitcherArrayEx
+
+module Stitcher module Core
+	def stitcher_method_table name
+		instance_eval { @stitcher_method_table ||= {}; @stitcher_method_table[name] ||= {} }
+	end
+	
+	def stitcher_method_table_all name
+		mtable = stitcher_method_table(name) unless superclass
+		return stitcher_method_table_all(superclass, name).merge(mtable) if superclass
+		mtable
+	end
+
+	def stitcher_add name, sig, method
+		sig = (method.arity < 0 ? +([Object] * method.arity.abs) : [Object] * method.arity.abs) unless sig
+		stitcher_method_table(name)[sig] = method
+	end
+
+	def stitcher_method_detecting name, *args, &block
+		mtable = stitcher_method_table(name).to_a.reverse
+		_, method = mtable.find {|sig, _| sig.=== args, &block }
+		method
+	end
+end end

data/lib/stitcher/core_ext.rb

@@ -0,0 +1,7 @@
+module StitcherArrayEx
+	refine Array do
+		def === other
+			size == other.size && zip(other).all? { |a, b| a === b }
+		end
+	end
+end

data/lib/stitcher/define_method.rb

@@ -0,0 +1,52 @@
+require_relative "./register"
+require_relative "./accessor"
+
+
+module Stitcher module DefineMethod
+	include Stitcher::Register
+
+	def self.as_instance_executable &block
+		Object.new.instance_eval do
+			define_singleton_method :stitcher_bind do |obj|
+				proc do |*args, &block_|
+					self_ = obj
+					self_.instance_exec *args, block, &block
+				end
+			end
+			self
+		end
+	end
+
+	def stitcher_define_method name, **opt, &block
+		obj = DefineMethod.as_instance_executable do |*args|
+			_ = args.pop		# block object
+			self_ = self
+			obj = Object.new
+			obj.extend(Module.new{
+				private
+				attr_reader *opt.keys
+			})
+			obj.instance_eval do
+				opt.each_with_index { |data, index|
+					name, type = data
+					instance_variable_set "@#{name}", args[index]
+				}
+
+# 				define_singleton_method :[] do |name|
+# 					self_.instance_eval "@#{ name }"
+# 				end
+#
+# 				define_singleton_method :[]= do |name, var|
+# 					obj.instance_eval { self_.instance_variable_set "@#{name}", var }
+# 				end
+				
+				define_singleton_method :method_missing do |name, *args, &block|
+					self_.__send__ name, *args, &block
+				end
+
+				instance_eval &block
+			end
+		end
+		Register.register self, name, opt.values, obj
+	end
+end end

data/lib/stitcher/operators.rb

@@ -0,0 +1,37 @@
+require_relative "./core_ext"
+
+using StitcherArrayEx
+
+module Stitcher
+	module Operators
+		def self.require_other other
+			Proc === other || Class === other
+		end
+
+		def & other
+			return super(other) unless Operators.require_other other
+			proc { |it, &block| self.===(it, &block) && other.===(it, &block)  }
+		end
+
+		def | other
+			return super(other) unless Operators.require_other other
+			proc { |it, &block| self.===(it, &block) || other.===(it, &block)  }
+		end
+
+		def !
+			proc { |it, &block| !(self.===(it, &block)) }
+		end
+
+		refine Class do
+			prepend Operators
+		end
+
+		refine Array do
+			prepend Operators
+		end
+
+		refine Proc do
+			prepend Operators
+		end
+	end
+end

data/lib/stitcher/register.rb

@@ -0,0 +1,31 @@
+require_relative "./core_ext"
+require_relative "./register"
+
+using StitcherArrayEx
+
+
+class UnboundMethod
+	alias_method :stitcher_bind, :bind
+end
+
+
+module Stitcher module Register
+	def self.define_call_method self_, name
+		self_.__send__ :define_method, name do |*args, &block|
+			method = self_.stitcher_method_detecting name, *args, &block
+
+			return super(*args, &block) unless method
+			method = method.stitcher_bind(self) if method.respond_to? :stitcher_bind
+			method.call *args, &block
+		end
+	end
+
+	def self.register self_, name, sig = nil, method = self_.instance_method(name)
+		self_.stitcher_add name, sig, method
+		Register.define_call_method self_, name
+	end
+
+	def stitcher_register name, sig, &block
+		Register.register(self, name, sig, block_given? ? block : instance_method(name))
+	end
+end end

data/lib/stitcher/require.rb

@@ -0,0 +1,27 @@
+require_relative "./register"
+# require_relative "../stitcher"
+
+
+module Stitcher module Require
+	include Register
+
+	def stitcher_require concept
+		@stitcher_require_concept = concept
+		@stitcher_require_methods = instance_methods.map { |name| instance_method name }
+
+		return if methods.include? :method_added
+		def self.method_added name
+			return unless @stitcher_require_concept
+			concept = @stitcher_require_concept
+			@stitcher_require_concept = nil
+
+			method = @stitcher_require_methods.find{ |it| it.name == name }
+			if method && stitcher_method_table(name).empty?
+				# Don't wrap method.
+				stitcher_add name, nil, method
+			end
+
+			Register.register self, name, concept
+		end
+	end
+end end

data/lib/stitcher/stitch.rb

@@ -0,0 +1,22 @@
+require_relative "./register"
+require_relative "./define_method"
+
+module Stitcher module Stitch
+	include Register
+	include DefineMethod
+
+	class Definer < BasicObject
+		def initialize obj
+			@obj = obj
+		end
+
+		def method_missing name, sig, &block
+			DefineMethod.instance_method(:stitcher_define_method).bind(@obj).(name, sig, &block)
+		end
+	end
+
+	def stitch *args, &block
+		return Definer.new self if args.empty?
+		Register.register self, *args, &block
+	end
+end end