moosex 0.0.9 → 0.0.10

data/spec/point_spec.rb

@@ -0,0 +1,201 @@
+require 'moosex'
+
+class Point
+	include MooseX
+
+	has x: {
+		is: :rw,      # read-write (mandatory)
+		isa: Integer, # should be Integer
+		default: 0,   # default value is 0 (constant)
+	}
+
+	has y: {
+		is: :rw,
+		isa: Integer,
+		default: lambda { 0 }, # you should specify a lambda
+	}
+	
+	has secret: {
+		is: :private,
+	}
+ 	
+	def clear 
+		self.x= 0        # to run with type-check you must
+		self.y= 0        # use the setter instad @x=
+	end
+
+  def change_secret(new_secret)
+		self.secret= new_secret
+	end
+
+	def show_secret
+		secret
+	end
+end 
+
+describe "Point" do
+	describe "should has an intelligent constructor" do
+		it "without arguments, should initialize with default values" do
+			p = Point.new
+			p.x.should be_zero
+			p.y.should be_zero
+		end
+	
+		it "should initialize only y" do
+			p = Point.new( x: 5 )
+			p.x.should == 5
+			p.y.should be_zero
+		end
+	
+		it "should initialize x and y" do
+			p = Point.new( x: 5, y: 4)
+			p.x.should == 5
+			p.y.should == 4
+		end
+  end
+
+  describe "private accessors" do		
+		it "should change private by method" do
+			p = Point.new(secret: 1)
+			p.show_secret.should == 1
+			p.change_secret(2)
+			p.show_secret.should == 2
+		end
+		
+		it "cant read secret" do
+			p = Point.new
+			expect {
+				p.secret
+			}.to raise_error(NoMethodError)
+		end
+		
+		it "cant write secret" do
+			p = Point.new
+			expect {
+				p.secret = 1
+			}.to raise_error(NoMethodError)
+		end		
+	end
+	
+	describe "should create a getter and a setter" do
+		it "for x" do
+			p = Point.new
+			p.x= 5
+			p.x.should == 5
+		end		
+		
+		it "for x, with type check" do
+			p = Point.new
+			expect { 
+				p.x = "lol" 
+			}.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: is not instance of Integer!')
+		end	
+
+		it "clear should clean attributes" do
+			p = Point.new( x: 5, y: 4)
+			p.clear
+			p.x.should be_zero
+			p.y.should be_zero			
+		end	
+	end	
+end
+
+class Point3D < Point
+
+	has x: {        # override original attr!
+		is: :rw,
+		isa: Integer,
+		default: 1,
+	}
+	
+	has z: {
+		is: :rw,      # read-write (mandatory)
+		isa: Integer, # should be Integer
+		default: 0,   # default value is 0 (constant)
+	}
+
+	has color: {
+		is: :rw,      # you should specify the reader/writter
+		reader: :what_is_the_color_of_this_point,
+		writter: :set_the_color_of_this_point,
+		default: :red,
+	}
+
+	def clear 
+		self.x= 0      # to run with type-check you must
+		self.y= 0      # use the setter instad @x=
+		self.z= 0
+	end
+end 
+
+describe "Point3D" do
+	describe "should has an intelligent constructor" do
+		it "without arguments, should initialize with default values" do
+			p = Point3D.new
+			p.x.should == 1
+			p.y.should be_zero
+			p.z.should be_zero
+			p.what_is_the_color_of_this_point.should == :red
+		end
+	
+		it "should initialize only y" do
+			p = Point3D.new( x: 5 )
+			p.x.should == 5
+			p.y.should be_zero
+			p.z.should be_zero
+			p.what_is_the_color_of_this_point.should == :red						
+		end
+	
+		it "should initialize x and y" do
+			p = Point3D.new( x: 5, y: 4, z: 8, color: :yellow)
+			p.x.should == 5
+			p.y.should == 4
+			p.z.should == 8
+			p.what_is_the_color_of_this_point.should == :yellow			
+		end
+	end
+	
+	describe "should create a getter and a setter" do
+		it "for z" do
+			p = Point3D.new
+			p.z= 5
+			p.z.should == 5
+		end		
+		
+		it "for z, with type check" do
+			p = Point3D.new
+			expect { 
+				p.z = "lol" 
+			}.to raise_error('isa check for "z" failed: is not instance of Integer!')
+		end	
+		
+		it "for z, with type check" do			
+			expect { 
+				Point3D.new(z: "lol") 
+			}.to raise_error('isa check for "z" failed: is not instance of Integer!')
+		end	
+
+		it "clear should clean attributes" do
+			p = Point3D.new( x: 5, y: 4, z: 9)
+			p.clear
+			p.x.should be_zero
+			p.y.should be_zero	
+			p.z.should be_zero			
+		end	
+	end	
+
+	describe "should create the accessors names with custom names" do
+		it "should get/set" do
+			p = Point3D.new
+			p.what_is_the_color_of_this_point.should == :red
+			p.set_the_color_of_this_point(:black)
+			p.what_is_the_color_of_this_point.should == :black
+		end
+	end
+end

data/spec/proxy_spec.rb

@@ -0,0 +1,145 @@
+require 'moosex'
+
+class ProxyToTarget
+  include MooseX
+
+  has target: {
+    is:  :ro,
+    default: lambda { Target.new }, # default, new instace of Target
+    handles: {                      # handles is for delegation,
+      my_method_x: :method_x,       # inject methods with new names 
+      my_method_y: :method_y,       # old => obj.target.method_x
+    },                              # now => obj.my_method_x
+  }
+end
+
+module TargetModule
+  def method_x; 1024; end             # works with simple methods
+  def method_y(a,b,c); a + b + c; end # or methods with arguments
+end
+
+class Target 
+  include TargetModule
+end
+
+describe "ProxyToTarget" do
+  it "should delegate method_x to the target" do
+    p = ProxyToTarget.new
+
+    p.target.method_x.should == 1024
+    p.my_method_x.should == 1024
+  end
+
+  it "should delegate method_y to the target" do
+    p = ProxyToTarget.new
+
+    p.target.method_y(1,2,3).should == 6
+    p.my_method_y(1,2,3).should == 6
+  end 
+  
+  it "should inject method_y" do
+    p = ProxyToTarget.new
+    
+    p.respond_to?(:my_method_y).should be_true
+    ProxyToTarget.instance_methods.member?(:my_method_y).should be_true
+  end
+end
+
+class ProxyToTargetUsingArrayOfMethods
+  include MooseX
+
+  has targetz: {
+    is:  :ro,
+    default: lambda { Target.new }, 
+    handles: [ 
+      :method_x, :method_y      # will inject all methods with same name
+    ] 
+  }
+end
+
+describe "ProxyToTargetUsingArrayOfMethods" do
+  it "should delegate method_x to the target" do
+    p = ProxyToTargetUsingArrayOfMethods.new
+
+    p.targetz.method_x.should == 1024
+    p.method_x.should == 1024
+  end
+
+  it "should delegate method_y to the target" do
+    p = ProxyToTargetUsingArrayOfMethods.new
+
+    p.targetz.method_y(1,2,3).should == 6
+    p.method_y(1,2,3).should == 6
+  end 
+end
+
+class ProxyToTargetUsingSingleMethod
+  include MooseX
+
+  has target: {
+    is:  :ro,
+    default: lambda { Target.new }, 
+    handles: "method_x"         # coerce to an array of symbols
+  }
+end
+
+describe "ProxyToTargetUsingSingleMethod" do
+  it "should delegate method_x to the target" do
+    p = ProxyToTargetUsingSingleMethod.new
+
+    p.target.method_x.should == 1024
+    p.method_x.should == 1024
+  end
+end
+
+class ProxyToTargetUsingModule
+  include MooseX
+
+  has target: {
+    is:  :ro,
+    default: lambda { Target.new }, 
+    handles: TargetModule          # will import all methods from module
+  }
+end
+
+describe "ProxyToTargetUsingModule" do
+  it "should delegate method_x to the target" do
+    p = ProxyToTargetUsingModule.new
+
+    p.target.method_x.should == 1024
+    p.method_x.should == 1024
+  end
+
+  it "should delegate method_y to the target" do
+    p = ProxyToTargetUsingModule.new
+
+    p.target.method_y(1,2,3).should == 6
+    p.method_y(1,2,3).should == 6
+  end   
+end
+
+class ProxyToTargetUsingClass
+  include MooseX
+
+  has target: {
+    is:  :ro,
+    default: lambda { Target.new }, 
+    handles: Target                   # will use only public methods on Target class
+  }                                   # exclude methods from superclass
+end
+
+describe "ProxyToTargetUsingClass" do
+  it "should delegate method_x to the target" do
+    p = ProxyToTargetUsingClass.new
+
+    p.target.method_x.should == 1024
+    p.method_x.should == 1024
+  end
+
+  it "should delegate method_y to the target" do
+    p = ProxyToTargetUsingClass.new
+
+    p.target.method_y(1,2,3).should == 6
+    p.method_y(1,2,3).should == 6
+  end   
+end

data/spec/trigger_spec.rb

@@ -0,0 +1,83 @@
+require 'moosex'
+
+class TriggerTest
+	include MooseX
+
+	has logger: {
+		is: :ro
+	}
+
+	has attr_with_trigger: {
+		is: :rw,
+		trigger: :my_method,
+	}
+
+	has attr_with_trigger_ro: {
+		is: :ro,
+		trigger: :my_method,
+	}
+
+	has attr_with_default: {
+		is: :rw,
+		trigger: lambda do |object, new_value| 
+			object.logger.log "will update attr_with_trigger with new value #{new_value}"
+		end,
+		default: 1,
+	}
+
+	has attr_lazy_trigger: {
+		is: :lazy,
+		trigger: :my_method,
+		builder: lambda{ |x| 1},
+	}
+
+	def my_method(new_value)
+		logger.log "will update attr_with_trigger with new value #{new_value}"
+	end
+end
+
+describe "TriggerTest" do
+	it "should call trigger on constructor" do
+		log = double
+		log.should_receive(:log)
+		t = TriggerTest.new(attr_with_trigger: 1, logger: log)
+
+	end
+
+	it "should call trigger on constructor (ro)" do
+		log = double
+		log.should_receive(:log)
+		t = TriggerTest.new(attr_with_trigger_ro: 1, logger: log)
+
+	end
+
+	it "should NOT call trigger on constructor (with default)" do
+		log = double
+		log.should_not_receive(:log)
+		t = TriggerTest.new(logger: log)
+	end
+
+	it "should NOT call trigger on constructor (with default)" do
+		log = double
+		log.should_receive(:log)
+		t = TriggerTest.new(logger: log)
+
+		t.attr_with_default = 1
+	end
+
+	it "should call trigger on setter" do
+		log = double
+		log.should_receive(:log)
+		t = TriggerTest.new(logger: log)
+		
+		t.attr_with_trigger = 1
+	end
+
+	it "should call trigger on setter" do
+		log = double
+		log.should_receive(:log)
+		t = TriggerTest.new(logger: log)
+		
+		t.attr_lazy_trigger.should == 1
+	end	
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moosex
 version: !ruby/object:Gem::Version
-  version: 0.0.9
+  version: 0.0.10
 platform: ruby
 authors:
 - Tiago Peczenyj
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-02 00:00:00.000000000 Z
+date: 2014-02-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,8 +52,8 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: MooseX is an extension of Ruby object system. The main goal of MooseX
-  is to make Ruby Object Oriented programming easier, more consistent, and less tedious.
+description: MooseX is an extension of Ruby object DSL. The main goal of MooseX is
+  to make Ruby Object Oriented programming easier, more consistent, and less tedious.
   With MooseX you can think more about what you want to do and less about the mechanics
   of OOP. It is a port of Moose/Moo from Perl to Ruby world.
 email:
@@ -73,7 +73,18 @@ files:
 - lib/moosex.rb
 - lib/moosex/version.rb
 - moosex.gemspec
+- samples/point.rb
+- spec/baz_spec.rb
+- spec/build_spec.rb
+- spec/buildargs_spec.rb
+- spec/coerce_spec.rb
+- spec/foo_spec.rb
+- spec/lazy_spec.rb
+- spec/lol_spec.rb
 - spec/moosex_spec.rb
+- spec/point_spec.rb
+- spec/proxy_spec.rb
+- spec/trigger_spec.rb
 homepage: http://github.com/peczenyj/MooseX
 licenses:
 - MIT
@@ -97,6 +108,16 @@ rubyforge_project:
 rubygems_version: 2.2.1
 signing_key: 
 specification_version: 4
-summary: A postmodern object system for Ruby
+summary: A postmodern object DSL for Ruby
 test_files:
+- spec/baz_spec.rb
+- spec/build_spec.rb
+- spec/buildargs_spec.rb
+- spec/coerce_spec.rb
+- spec/foo_spec.rb
+- spec/lazy_spec.rb
+- spec/lol_spec.rb
 - spec/moosex_spec.rb
+- spec/point_spec.rb
+- spec/proxy_spec.rb
+- spec/trigger_spec.rb