moosex 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 853ceb9084c1f328f72ef7a1c8c5ccfac1047afd
-  data.tar.gz: 4577ed6c0db01b29bc735e7e1dfcdf9ffdffb001
+  metadata.gz: 14b97eb6c1912038ced4647e89e4ebe2c10092d7
+  data.tar.gz: 1d1bcca3b65ea98b49b04bde2769edc5f2ffe676
 SHA512:
-  metadata.gz: 61ae609b6b0c19053e78941b50991e5f88255a4bcf713d443fa48cb171ddbdd4710ea8e592e673eadd163730b97e41be4f79b9bed6bb85b5e651041074b1109c
-  data.tar.gz: 57c88e944b04b96657f6f7cc07fbc7f5001fc81b33a6584025efc57dba08b16448f019d74c50689e13e05440d501fc67b6eebd303141cfeaa1cc9b8dd036b8ba
+  metadata.gz: 85aa1e9641e90f307dc37c29c4dbb8ba1b68dcf7784d7ab688638ac57351e790fc37f6459ebb6ca578dec571952c18f748aaef687159b98f62bc689750d2f672
+  data.tar.gz: 46c1e856c2c6f53d56e549ce5e7fb9a12158c1a6bb0019c0ecfa1b3a2b174db47ce02ba29f3dcdf18dbaf13c6cfe5d9016b2ed1cf52a41b6d4d0e46d19aad4bd

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 1.9.2-p320

data/Changelog

@@ -1,3 +1,9 @@
+0.0.3 - 2014-01-31
+	- add support to clearer #26
+	- add support to predicate #11
+	- add support to handle more than one attribute #2
+	- small improvements
+
 0.0.2 - 2014-01-31
 	- fix one important bug, not it is possible use in more than one class
 	- add require option

data/README.md

@@ -1,6 +1,6 @@
 # MooseX
 
-A postmodern object system for Ruby
+A postmodern object system for Ruby [![Build Status](https://travis-ci.org/peczenyj/MooseX.png)](https://travis-ci.org/peczenyj/MooseX)
 
 ```ruby
     require 'moosex'
@@ -32,7 +32,7 @@ A postmodern object system for Ruby
         has :bar, {  
             :is => :rwp,      # read-write-private (private setter)
             :isa => Integer, 
-            :required => true # you should require in the constructor 
+            :required => true, # you should require in the constructor 
         }
     end
 
@@ -44,11 +44,29 @@ A postmodern object system for Ruby
             :isa => lambda {|x| # you should add your own validator
                 raise 'x should be less than 100' if x > 100
             },
-            :required => true
+            :required => true,
+            :predicate => true, # add has_bam? method, ask if the attribute is unset
+            :clearer => true,   # add reset_bam! method, unset the attribute
         }
 
     end
 
+    class Lol 
+        include MooseX
+
+        has [:a, :b], {     # define attributes a and b
+            :is => :ro,     # with same set of properties
+            :default => 0,      
+        }
+
+        has :c => {         # alternative syntax to be 
+            :is => :ro,     # more similar to Moo/Moose    
+            :default => 1,
+            :predicate => :can_haz_c?,     # custom predicate
+            :clearer => "desintegrate_c",  # force coerce to symbol
+        }
+    end    
+
     # now you have a generic constructor
     p1  = Point.new                       # x and y will be 0
     p2  = Point.new( :x => 5 )            # y will be 0

data/Rakefile

@@ -0,0 +1,3 @@
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/lib/moosex.rb

@@ -12,14 +12,9 @@ module MooseX
 		o.extend(MooseX::Core)
 			
 		o.class_exec do 
-			meta = MooseX::Meta.new()
-		
-			#class_variable_set "@@meta".to_sym, meta
+			meta = MooseX::Meta.new
 
-			define_singleton_method :__meta do
-				meta
-				# class_variable_get "@@meta".to_sym
-			end
+			define_singleton_method(:__meta) { meta }
 		end
 
 		def initialize(args={})
@@ -32,56 +27,175 @@ module MooseX
 	
 	module Core
 	
-		def has(attr_name, attr_options)
-			attr = MooseX::Attribute.new(attr_name, attr_options)
+		def has(attr_name, attr_options = {})
+			if attr_name.is_a? Array 
+				attr_name.each do |attr| 
+					has(attr, attr_options) 
+				end
+			elsif attr_name.is_a? Hash 
+				attr_name.each_pair do |attr, options |
+					has(attr, options)
+				end
+			else
 
-			g = attr.generate_getter
-			
-    		define_method attr_name, &g
- 
- 			s = attr.generate_setter
- 		
- 			if attr_options[:is].eql? :rw 
-			
-				define_method "#{attr_name}=", &s
-			
-			elsif attr_options[:is].eql? :rwp
+				attr = MooseX::Attribute.new(attr_name, attr_options)
 
-				define_method "#{attr_name}=", &s
+				g = attr.generate_getter
+				
+	    		define_method attr.attr_symbol, &g
+	 
+	 			s = attr.generate_setter
+	 		
+	 			case attr.is 
+	 			when :rw 				
+					define_method "#{attr.attr_symbol}=", &s
 				
-				private "#{attr_name}="
+				when :rwp
+					define_method "#{attr.attr_symbol}=", &s
+					
+					private "#{attr.attr_symbol}="
+				end
 
+				__meta.add(attr)
 			end
-
-			__meta.add(attr)
 		end
-		
 	end	
 	
 	class Attribute
 
+		attr_reader :attr_symbol, :is, :isa, :default, :required
+
+		DEFAULTS= { 
+			:clearer => false,
+			:required => false, 
+			:predicate => false,
+			:isa => lambda { |x| true },
+		}
+
+		REQUIRED = [ :is ]
+
+		VALIDATE = {
+			:is => lambda do |is, field_name| 
+				unless [:rw, :rwp, :ro, :lazy].include?(is)
+					raise "invalid value for field '#{field_name}' is '#{is}', must be one of :rw, :rwp, :ro or :lazy"  
+				end
+			end,
+		};
+
+		COERCE = {
+			:is  => lambda do |is, field_name| 
+				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	 
+			end,
+			:default => lambda do |default, field_name|
+				return default if default.is_a? Proc
+
+				return lambda { default }		
+			end,
+			:required => lambda do |required, field_name| 
+				!!required 
+			end,
+			:predicate => lambda do |predicate, field_name| 
+				begin
+					if ! predicate
+						return false
+					elsif predicate.is_a? TrueClass
+						return "has_#{field_name}?".to_sym,
+					end
+
+					return predicate.to_sym
+				rescue e
+					# create a nested exception here
+					raise "cannot coerce field predicate to a symbol for #{field_name}: #{e}"
+				end
+			end,
+			:clearer => lambda do |clearer, field_name| 
+				begin
+					if ! clearer
+						return false
+					elsif clearer.is_a? TrueClass
+						return "reset_#{field_name}!".to_sym,
+					end
+
+					return clearer.to_sym
+				rescue e
+					# create a nested exception here
+					raise "cannot coerce field clearer to a symbol for #{field_name}: #{e}"
+				end
+			end,			
+		};
+
 		def initialize(a, o)
+			# todo extract this to a framework, see issue #21 on facebook
+			o = DEFAULTS.merge(o)
+
+			REQUIRED.each { |field| 
+				unless o.has_key?(field)
+					raise "field #{field} is required for Attribute #{a}" 
+				end
+			}
+			COERCE.each_pair do |field, coerce|
+				if o.has_key? field
+					o[field] = coerce.call(o[field], a)
+				end
+			end
+			VALIDATE.each_pair do |field, validate|
+				return if ! o.has_key? field
+
+				validate.call(o[field], a)
+			end	
+
 			@attr_symbol = a
-			@options     = o
+			@is          = o[:is]
+			@isa         = o[:isa]
+			@default     = o[:default]
+			@required    = o[:required] 
+			@predicate   = o[:predicate]
+			@clearer     = o[:clearer]
 		end
 		
 		def init(object, args)
+			inst_variable_name = "@#{@attr_symbol}".to_sym
+			
 			setter = @attr_symbol.to_s.concat("=").to_sym
 			value  = nil
- 
+
+			if @predicate
+				object.define_singleton_method @predicate do
+					instance_variable_defined? inst_variable_name
+				end
+			end
+
+			if @clearer
+				object.define_singleton_method @clearer do
+					if instance_variable_defined? inst_variable_name
+						remove_instance_variable inst_variable_name
+					end
+				end
+			end
+
 			if args.has_key? @attr_symbol
 				value = args[ @attr_symbol ]
-			elsif @options[:required]
+			elsif @required
 				raise "attr \"#{@attr_symbol}\" is required"
+			elsif @default
+				value = @default.call
 			else
-				value = (@options[:default].is_a? Proc) ? @options[:default].call : @options[:default]
+				return
 			end
  
- 			if @options[:is].eql? :ro
+ 			if @is.eql? :ro
 
  				# TODO: remove redundancy
 
-				inst_variable_name = "@#{@attr_symbol}".to_sym
 				type_check = generate_type_check
 				type_check.call(value)
 				object.instance_variable_set inst_variable_name, value
@@ -108,17 +222,8 @@ module MooseX
 		end
 		
 		def generate_type_check
-			if @options.has_key? :isa
-				isa = @options[:isa]
-
-				return isa if isa.is_a? Proc
 
-				return lambda do |new_value|
-					raise "isa check for \"#{@attr_symbol}\" failed: lol is not #{isa}!" unless new_value.is_a? isa
-				end	 
-			end
- 
-			lambda { |new_value| }
+			return @isa
 		end			
 	end
 	

data/lib/moosex/version.rb

@@ -1,3 +1,3 @@
 module Moosex
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/moosex_spec.rb

@@ -37,13 +37,38 @@ class Baz
 
 	has :bam, {
 		:is => :ro,
-		:isa => lambda {|x| raise 'x should be less than 100' if x > 100},
+		:isa => lambda {|bam| raise 'bam should be less than 100' if bam > 100},
 		:required => true
 	}
+	has :boom, {
+		:is => :rw,
+		:predicate => true,
+		:clearer => true,
+	}
+end
+
+class Lol 
+	include MooseX
+
+	has [:a, :b], {
+		:is => :ro,
+		:default => 0,		
+	}
+
+	has :c => {
+		:is => :ro,
+		:default => 1,
+		:predicate => :has_option_c?,
+		:clearer => "reset_option_c", # force coerce
+	}
 
+	has [:d, :e] => {
+		:is => "ro",
+		:default => 2,		
+	}	
 end
 
-describe "MooseX" do
+describe "Point" do
 	describe "should has an intelligent constructor" do
 		it "without arguments, should initialize with default values" do
 			p = Point.new
@@ -62,42 +87,6 @@ describe "MooseX" do
 			p.x.should == 5
 			p.y.should == 4
 		end
-
-		it "should require bar if necessary" do 
-			expect {
-				Foo.new
-			}.to raise_error("attr \"bar\" is required")
-		end
-
-		it "should require bar if necessary" do 
-			foo = Foo.new( :bar => 123 )
-			foo.bar.should == 123
-		end
-
-		it "should not be possible update bar (setter private)" do 
-			foo = Foo.new( :bar => 123 )
-			expect {
-				foo.bar = 1024
-			}.to raise_error(NoMethodError)
-		end
-
-		it "should require bam if necessary" do 
-			baz = Baz.new( :bam => 99 )
-			baz.bam.should == 99
-		end
-
-		it "should not be possible update baz (read only)" do 
-			baz = Baz.new( :bam => 99 )
-			expect {
-				baz.bam = 1024
-			}.to raise_error(NoMethodError)
-		end
-
-		it "should run the lambda isa" do 
-			expect {
-				baz = Baz.new( :bam => 199 )
-			}.to raise_error(/x should be less than 100/)
-		end
 	end
 	
 	describe "should create a getter and a setter" do
@@ -111,13 +100,13 @@ describe "MooseX" do
 			p = Point.new
 			expect { 
 				p.x = "lol" 
-			}.to raise_error('isa check for "x" failed: lol is not Integer!')
+			}.to raise_error('isa check for "x" failed: is not instance of Integer!')
 		end	
 		
 		it "for x, with type check" do			
 			expect { 
 				Point.new(:x => "lol") 
-			}.to raise_error('isa check for "x" failed: lol is not Integer!')
+			}.to raise_error('isa check for "x" failed: is not instance of Integer!')
 		end	
 
 		it "clear should clean attributes" do
@@ -127,4 +116,95 @@ describe "MooseX" do
 			p.y.should be_zero			
 		end	
 	end	
+end
+
+describe "Foo" do
+	it "should require bar if necessary" do 
+		expect {
+			Foo.new
+		}.to raise_error("attr \"bar\" is required")
+	end
+
+	it "should require bar if necessary" do 
+		foo = Foo.new( :bar => 123 )
+		foo.bar.should == 123
+	end
+
+	it "should not be possible update bar (setter private)" do 
+		foo = Foo.new( :bar => 123 )
+		expect {
+			foo.bar = 1024
+		}.to raise_error(NoMethodError)
+	end
+end 
+
+describe "Baz" do
+	it "should require bam if necessary" do 
+		baz = Baz.new( :bam => 99 )
+		baz.bam.should == 99
+	end
+
+	it "should not be possible update baz (read only)" do 
+		baz = Baz.new( :bam => 99 )
+		expect {
+			baz.bam = 1024
+		}.to raise_error(NoMethodError)
+	end
+
+	it "should run the lambda isa" do 
+		expect {
+			Baz.new( :bam => 199 )
+		}.to raise_error(/bam should be less than 100/)
+	end
+
+	it "rw acessor should has nil value, supports predicate" do
+		baz = Baz.new( :bam => 99 )
+		
+		baz.has_boom?.should be_false
+		baz.boom.should be_nil
+		baz.boom= 0
+		baz.has_boom?.should be_true
+		baz.boom.should be_zero
+	end
+
+	it "rw acessor should has nil value, supports clearer" do
+		baz = Baz.new( :bam => 99, :boom => 0 )
+		
+		baz.has_boom?.should be_true
+		baz.boom.should be_zero
+		
+		baz.reset_boom!
+
+		baz.has_boom?.should be_false
+		baz.boom.should be_nil
+	end	
+
+	it "should be possible call the clearer twice" do
+		baz = Baz.new( :bam => 99, :boom => 0 )
+		
+		baz.reset_boom!
+		baz.reset_boom!
+		
+		baz.has_boom?.should be_false
+		baz.boom.should be_nil
+	end		
+end
+
+describe "Lol" do
+	it "Lol should has five arguments" do
+		lol = Lol.new(:a => 5, :d => -1)
+		lol.a.should == 5
+		lol.b.should be_zero
+		lol.c.should == 1
+		lol.d.should == -1
+		lol.e.should == 2
+	end
+
+	it "Lol should support custom predicate and clearer" do
+		lol = Lol.new(:a => 5, :d => -1)
+
+		lol.has_option_c?.should be_true
+		lol.reset_option_c
+		lol.has_option_c?.should be_false
+	end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moosex
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Tiago Peczenyj
@@ -63,11 +63,13 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - Changelog
 - Gemfile
 - Gemfile.lock
 - LICENSE
 - README.md
+- Rakefile
 - lib/moosex.rb
 - lib/moosex/version.rb
 - moosex.gemspec