moosex 0.0.10 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2e60a3c50ecdccca330d91d980b5512a4ff2134d
-  data.tar.gz: b86c1f9dfdfcf180b05d4c4cde80ccec38c9ad83
+  metadata.gz: fd8eb35f9d9028cc9f148b60f56f49ae49b2472f
+  data.tar.gz: 0c94cb4df401dd137d59ca3133917ddf7f195d9d
 SHA512:
-  metadata.gz: 27668b133f039c5bc9f99e8b16f291071a213d9cb1e1bf040828953c0d17f2ece5768365a118c46feb4cba8d5f03e4d3b5af3c0f910dce565f4a32ddec820167
-  data.tar.gz: ee19e17a6877e20fb57c54490b109d8aca8cc6abe4a4686e4f69bbc13ad9c4e411373f7293579b49a73e3a170a1be7c9fe45a3493a3f793d45b439a6397a6055
+  metadata.gz: 1feb33f6f36589c92562a2c15a89e71a8267dab34e4742ef9b5d3743f1fb2be1828a5e653d9926fa22ec68a697731d31856845b16799d0dee70163ed20e28dc4
+  data.tar.gz: d58b9b922630abd5ff3160641661887d9bdde81df95afa4f413cc13cb7430b82a1b08ce15e7091251cfaddf19c658f55640436b5170fe32491190e657f4eef9f

data/Changelog

@@ -1,3 +1,8 @@
+0.0.11 - 2013-02-04
+	- basic support to after/before/around #12
+	- improve exception #15
+	- improve type system via MooseX::Types #16
+	
 0.0.10 - 2014-02-03
 	- improve readme #2014-02-01
     - BUILDARGS should accept different signatures #36

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    moosex (0.0.10)
+    moosex (0.0.11)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -1,6 +1,6 @@
 # MooseX
 
-A postmodern object DSL for Ruby [![Build Status](https://travis-ci.org/peczenyj/MooseX.png)](https://travis-ci.org/peczenyj/MooseX)
+A postmodern object DSL for Ruby [![Build Status](https://travis-ci.org/peczenyj/MooseX.png)](https://travis-ci.org/peczenyj/MooseX) [![Gem Version](https://badge.fury.io/rb/moosex.png)](http://badge.fury.io/rb/moosex)
 
 THIS MODULE IS EXPERIMENTAL YET! BE CAREFUL!
 
@@ -137,7 +137,6 @@ You can specify your own kind of type validation.
         raise "bar should respond to to_sym method!"
       end
     end,
-end
 ``` 
 
 Important: if you access the attribute instance name using @attribute_name= you loose the type check feature. You need always set/get the attribute value using the acessors generated by MooseX.
@@ -154,6 +153,18 @@ or
   default: lambda{ MyObject.new },
 ```
 
+### required
+
+if true, the constructor will raise error if this attribute was not present.
+
+```ruby
+  required: true,
+```
+
+if this attribute has a default value, we will initialize with this value and no exception will be raised.
+
+Optional.
+
 ### coerce
 
 You can try to coerce the attribute value by a lambda before the type check phase. For example you can do
@@ -195,7 +206,9 @@ Optional.
 You can specify one lambda or method name to be executed in each writter ( if coerce and type check does not raise any exception ). The trigger will be called in each setter and in the constructor if we do not use the default value. Useful to add a logging operation or some complex validation.
 
 ```ruby
-  trigger: lambda {|object, new_value| object.logger.log "change the attribute value to #{new_value}" }
+  trigger: lambda do |object, new_value| 
+    object.logger.log "change the attribute value to #{new_value}"
+  end
 ```
 or
 ```ruby
@@ -282,7 +295,7 @@ class Foo
     is: :rw,
     writter: :x=,
     reader: :x,
-    init_art: :x,
+    init_arg: :x,
   }
 end
 
@@ -341,6 +354,220 @@ end
 ```
 Optional.
 
+## Hooks: after/before/around
+
+Another great feature imported from Moose are the hooks after/before/around one method. You can run an arbitrary code, for example:
+
+```ruby
+class Point 
+  include MooseX
+
+  has [:x, :y ], { is: :rw, required: true }
+
+  def clear!
+    self.x = 0
+    self.y = 0
+  end
+end
+
+class Point3D < Point
+
+  has z: { is: :rw, required: true }
+
+  after :clear! do |object|
+    object.z = 0
+  end
+end
+```
+
+instead redefine the 'clear!' method in the subclass, we just add a piece of code, a lambda, and it will be executed after the normal 'clear!' method.
+
+### after 
+
+The after hook should receive the name of the method as a Symbol and a lambda. This lambda will, in the argument list, one reference for the object (self) and the rest of the arguments. This will redefine the the original method, add the code to run after the method. The after does not affect the return value of the original method, if you need this, use the 'around' hook.
+
+### before 
+
+The before hook should receive the name of the method as a Symbol and a lambda. This lambda will, in the argument list, one reference for the object (self) and the rest of the arguments. This will redefine the the original method, add the code to run before the method.
+
+A good example should be logging:
+
+```ruby
+class Point 
+  include MooseX
+
+  def my_method(x)
+    # do something
+  end
+
+  before :my_method do |object, x|
+    puts "#{Time.now} before my_method(#{x})"
+  end
+  after :my_method do |object, x|
+    puts "#{Time.now} after my_method(#{x})"
+  end
+end
+```
+
+### around
+
+The around hook is agressive: it will substitute the original method for a lambda. This lambda will receive the original method, a reference for the object and the argument list
+
+```ruby
+  around(:sum) do |original_method, object, a,b,c|
+    result = original_method.bind(object).call(a,b,c)
+    result + 1
+  end
+```
+
+it is useful to manipulate the return value if you need.
+
+## Types
+
+MooseX has a built-in type system to be helpful in many circunstances. How many times you need check if some argument is_a? Something? Or it respond_to? :some_method ? Now it is over. If you include the MooseX::Types module in your MooseX class you can use:
+
+### isAny
+
+will accept any type. Useful to combine with other types.
+
+```ruby
+  has x: { is: :rw, isa: isAny }
+```
+
+### isConstant
+
+will verify using :=== if the value is equal to some contant
+
+```ruby
+  has x: { is: :rw, isa: isConstant(1) }
+```
+
+### isType, isInstanceOf and isConsumerOf
+
+will verify the type using is_a? method. should receive a Class. isInstanceOf is an alias, to be used with Classes and isConsumerOf is for Modules.
+
+```ruby
+  has x: { is: :rw, isa: isConsumerOf(Enumerable) }
+```
+
+### hasMethods
+
+will verify if the value respond_to? for one or more methods.
+
+```ruby
+  has x: { is: :rw, isa: hasMethods(:to_s) }
+```
+### isEnum
+
+verify if the value is part of one enumeration of constants.
+
+```ruby
+  has x: { is: :rw, isa: isEnum(:black, :white, :red, :green, :yellow) }
+```
+
+### isMaybe(type)
+
+verify if the value isa type or is nil. You can combine with other types.
+
+```ruby
+  has x: { is: :rw, isa: isMaybe(Integer) } # accepts 1,2,3... or nil
+```
+
+### isNot(type)
+
+will revert the type check. Useful to combine with other types
+
+```ruby
+  has x: { 
+    is: :rw,   # x will accept any values EXCEPT :black, :white...
+    isa: isNot(isEnum(:black, :white, :red, :green, :yellow)) 
+  }
+```
+
+### isArray(type)
+
+Will verify if the value is an Array. Can receive one extra type, and we will verify each element inside the array againt this type, or Any if we not specify the type.
+
+```ruby
+  has x: { 
+    is: :rw,  
+    isa: isArray()    # will accept any array
+  }
+  has y: { 
+    is: :rw,          # this is a more complex type
+    isa: isArray(isArray(isMaybe(Integer))) 
+  }  
+```
+
+### isHash(type=>type)
+
+similar to isArray. if you do not specify a pair of types, it will check only if the value is_a? Hash. Otherwise we will verify each pair key/value.
+
+```ruby
+  has x: { 
+    is: :rw,  
+    isa: isHash()       # will accept any Hash
+  }
+  has y: { 
+    is: :rw,            # this is a more complex type
+    isa: isHash(Integer => isArray(isMaybe(Integer))) 
+  }  
+```
+
+## isSet(type)
+
+similar to isSet. the difference is: it will raise one exception if there are non unique elements in this array.
+
+```ruby
+  has x: { 
+    is: :rw,  
+    isa: isSet(Integer)  # will accept [1,2,3] but not [1,1,1]
+  }
+```
+
+## isTuple(types)
+
+similar to isArray, Tuples are Arrays with fixed size. We will verify the type of each element.
+
+For example, to specify one tuple with three elements, the first is Integer, the second is a Symbol and the las should be a String or nil:
+
+```ruby
+  has x: { 
+    is: :rw,  
+    isa: isTuple(Integer, Symbol, isMaybe(String))       
+  }
+```
+
+### isAllOf(types)
+
+will combine all types and will fail if one of the condition fails.
+
+```ruby
+  has x: { 
+    is: :rw,  
+    isa: isAllOf(
+        hasMethods(:foo, :bar),     # x should has foo and bar methods
+        isConsumerOf(Enumerable),   # AND should be an Enumerable
+        isNot(SomeForbiddenClass),  # AND and should not be an SomeForbiddenClass
+      )
+  }
+```
+
+### isAnyOf(types)
+
+will combine all types and will fail if all of the condition fails.
+
+```ruby
+  has x: { 
+    is: :rw,  
+    isa: isAnyOf(
+        hasMethods(:foo, :bar),   # x should has foo and bar methods 
+        isEnum(1,2,3,4),          # OR be 1,2,3 or 4
+        isHash(isAny => Integer)  # OR be an Hash of any type => Integers
+      )
+  }
+```
+
 ## BUILD
 
 If you need run some code after the creation of the object (like some extra validation), you should override the BUILD method.
@@ -362,7 +589,7 @@ end
 
 b1 = BuildExample.new(x: 1, y: 2) # will create the object 
 b2 = BuildExample.new(x: 1, y: 1) # will raise the exception!
-```ruby
+```
 
 ### BUILDARGS
 

data/lib/moosex.rb

@@ -6,9 +6,10 @@
 # License::   MIT
 #
 require "moosex/version"
+require "moosex/types"
 
 module MooseX
-	
+
 	def MooseX.included(c)
 			
 		c.extend(MooseX::Core)
@@ -38,7 +39,7 @@ module MooseX
 			subclass.class_exec do 
 				old_meta = subclass.__meta
 
-				meta = MooseX::Meta.new(old_meta.attrs)
+				meta = MooseX::Meta.new(old_meta)
 
 				define_singleton_method(:__meta) { meta }
 			end    		
@@ -47,22 +48,78 @@ module MooseX
 	end
 	
 	class Meta
-		attr_reader :attrs
-		def initialize(attrs=[])
-			@attrs = attrs.map{|att| att.clone }
+		attr_reader :attrs, :after, :before, :around
+
+		def initialize(old_meta=nil)
+			@attrs = []
+			@after = Hash.new {|hash, key| hash[key] = []}
+			@before= Hash.new {|hash, key| hash[key] = []}
+			@around= Hash.new {|hash, key| hash[key] = []}
+
+			if old_meta
+				@attrs = old_meta.attrs.map{|att| att.clone }
+				@after.merge! old_meta.after.clone
+				@before.merge! old_meta.before.clone
+				@around.merge! old_meta.around.clone
+			end
 		end
 		
 		def add(attr)
 			@attrs << attr
 		end
+
+		def add_after(method, block)
+			@after[method] << MooseX::Hook::After.new(method, block)
+		end
 		
+		def add_before(method, block)
+			@before[method]  << MooseX::Hook::Before.new(method, block)			
+		end
+
+		def add_around(method, block)
+			@around[method]  << MooseX::Hook::Around.new(method, block)			
+		end
+
 		def init(object, args)
 			@attrs.each{ |attr| attr.init(object, args) }
 		end
 	end	
 
 	module Core
-	
+		def after(method_name, &block)
+			method = instance_method method_name
+
+			define_method method_name do |*args|
+				result = method.bind(self).call(*args)
+				block.call(self,*args)
+				result
+			end
+
+			__meta.add_after(method_name, block)
+		end
+
+		def before(method_name, &block)
+			method = instance_method method_name
+
+			define_method method_name do |*args|
+				block.call(self,*args)
+				method.bind(self).call(*args)
+			end
+
+			__meta.add_before(method_name, block)
+		end
+
+		def around(method_name, &block)
+			method = instance_method method_name
+
+			define_method method_name do |*args|
+				
+				block.call(method, self,*args)
+				
+			end			
+			__meta.add_around(method, block)
+		end
+
 		def has(attr_name, attr_options = {})
 			if attr_name.is_a? Array 
 				attr_name.each do |attr| 
@@ -92,7 +149,31 @@ module MooseX
 		end
 	end	
 	
+	module Hook
+		class Base
+			attr_reader :method, :block
+			def initialize(method, block)
+				@method= method 
+				@block = block
+			end
+		end
+
+		class After < Base
+		end
+
+		class Before < Base
+		end
+
+		class Around < Base
+		end
+	end
+
+	class InvalidAttributeError < TypeError
+
+	end
+
 	class Attribute
+		include MooseX::Types
 
 		attr_reader :attr_symbol, :is, :reader, :writter, :lazy, :builder, :methods
 		DEFAULTS= { 
@@ -100,7 +181,7 @@ module MooseX
 			clearer: false,
 			required: false, 
 			predicate: false,
-			isa: lambda { |value| true },
+			isa: isAny,
 			handles: {},
 			trigger: lambda {|object,value|},  # TODO: implement
 			coerce: lambda {|object| object},  # TODO: implement
@@ -111,7 +192,7 @@ module MooseX
 		VALIDATE = {
 			is: lambda do |is, field_name| 
 				unless [:rw, :rwp, :ro, :lazy, :private].include?(is)
-					raise "invalid value for field '#{field_name}' is '#{is}', must be one of :private, :rw, :rwp, :ro or :lazy"  
+					raise InvalidAttributeError, "invalid value for field '#{field_name}' is '#{is}', must be one of :private, :rw, :rwp, :ro or :lazy"  
 				end
 			end,
 		};
@@ -121,13 +202,7 @@ module MooseX
 				is.to_sym 
 			end,
 			isa: lambda do |isa, field_name| 
-				return isa if isa.is_a? Proc
-				
-				return lambda do |new_value| 
-					unless new_value.is_a?(isa)
-						raise "isa check for \"#{field_name}\" failed: is not instance of #{isa}!" 
-					end 
-				end	 
+				isType(isa) 
 			end,
 			default: lambda do |default, field_name|
 				return default if default.is_a? Proc
@@ -151,7 +226,7 @@ module MooseX
 					predicate.to_sym
 				rescue => e
 					# create a nested exception here
-					raise "cannot coerce field predicate to a symbol for #{field_name}: #{e}"
+					raise InvalidAttributeError, "cannot coerce field predicate to a symbol for #{field_name}: #{e}"
 				end
 			end,
 			clearer: lambda do|clearer, field_name| 
@@ -165,7 +240,7 @@ module MooseX
 					clearer.to_sym
 				rescue => e
 					# create a nested exception here
-					raise "cannot coerce field clearer to a symbol for #{field_name}: #{e}"
+					raise InvalidAttributeError, "cannot coerce field clearer to a symbol for #{field_name}: #{e}"
 				end
 			end,
 			handles: lambda do |handles, field_name|
@@ -182,7 +257,7 @@ module MooseX
 
 						if handle == BasicObject
 							
-							raise "ops, should not use BasicObject for handles in #{field_name}"
+							raise InvalidAttributeError, "ops, should not use BasicObject for handles in #{field_name}"
 						
 						elsif handle.is_a? Class
 
@@ -260,7 +335,7 @@ module MooseX
 
 			REQUIRED.each { |field| 
 				unless o.has_key?(field)
-					raise "field #{field} is required for Attribute #{a}" 
+					raise InvalidAttributeError, "field #{field} is required for Attribute #{a}" 
 				end
 			}
 			COERCE.each_pair do |field, coerce|
@@ -342,19 +417,20 @@ module MooseX
 				value = @default.call
 				value_from_default = true
 			elsif @required
-				raise "attr \"#{@attr_symbol}\" is required"
+				raise InvalidAttributeError, "attr \"#{@attr_symbol}\" is required"
 			else
 				return
 			end
- 
-
-			value = @coerce.call(value)
 
-			@isa.call( value )
+			value = @coerce.call(value) 	
+ 			begin
+				@isa.call( value )
+			rescue MooseX::Types::TypeCheckError => e
+				raise MooseX::Types::TypeCheckError, "isa check for field #{attr_symbol}: #{e}"
+			end
 			unless value_from_default
 				@trigger.call(object, value)
 			end
-			
 			inst_variable_name = "@#{@attr_symbol}".to_sym
 			object.instance_variable_set inst_variable_name, value
 		end
@@ -375,7 +451,12 @@ module MooseX
 
 					value = builder.call(object)
 					value = coerce.call(value)
-					type_check.call(value)
+					begin
+						type_check.call( value )
+					rescue MooseX::Types::TypeCheckError => e
+						raise MooseX::Types::TypeCheckError, "isa check for #{inst_variable_name} from builder: #{e}"
+					end
+
 					trigger.call(object, value)
 					object.instance_variable_set(inst_variable_name, value)					
 				end
@@ -388,13 +469,18 @@ module MooseX
 		end
 		
 		def generate_writter
+			writter_name       = @writter
 			inst_variable_name = "@#{@attr_symbol}".to_sym
 			coerce     = @coerce
 			type_check = @isa
 			trigger    = @trigger
 			Proc.new  do |value| 
 				value = coerce.call(value)
-				type_check.call(value)
+				begin
+					type_check.call( value )
+				rescue MooseX::Types::TypeCheckError => e
+					raise MooseX::Types::TypeCheckError, "isa check for #{writter_name}: #{e}"
+				end
 				trigger.call(self,value)
 				instance_variable_set inst_variable_name, value
 			end