moosex 0.0.18 → 0.0.19

data/spec/coerce_spec.rb

@@ -6,7 +6,7 @@ class CoerceTest
 	has attribute_ro: {
 		is: :ro,
 		isa: Integer,
-		coerce: lambda {|value| value.to_i },
+		coerce: ->(value) { value.to_i },
 	}
 
 	has attribute_rw: {
@@ -18,8 +18,8 @@ class CoerceTest
 	has attribute_lazy: {
 		is: :lazy,
 		isa: Integer,
-		coerce: lambda {|value| value.to_i },
-		builder: lambda{|object| "2048" },
+		coerce: ->(value) { value.to_i },
+		builder: ->(object) { "2048" },
 	}
 end
 
@@ -45,37 +45,4 @@ describe "CoerceTest" do
 		ct.attribute_lazy.should == 2048
 	end
 end
-=begin
-require 'moosex/types'
 
-class CoerceTest2
-  include MooseX
-  include MooseX::Types
-
-  has a: { is: :rw, coerce: :to_i }                   # if respond_to? then coerce
-  has b: { is: :rw, coerce: { to_i: true } }          # always coerce
-  has c: { is: :rw, coerce: { to_i: false} }          # if respond_to? then coerce 
-  has d: { is: :rw, coerce: [ :to_s, :to_string ] }   # try to apply one of
-  has e: { is: :rw, coerce: [                         # if respond_to? then coerce via method/lambda
-    {  to_s: lambda{|x| x.to_s.to_sym } },            # can add more, will be evaluated in order
-    {  to_sym: :to_sym  },
-   ] 
-  }
-  has f: { is: :rw, coerce: [                         # should accept one array of 
-       { String => lambda{|x| x.to_sym } },           # type => coerce
-       { Object => lambda{|x| x.to_s } },
-    ]
-  }
-  has g: { is: :rw, coerce: { String => :to_sym } }   # should accept one pair
-  has h: { is: :rw, coerce: {                         # should accept one type validator
-    isArray(String) => lambda{|obj| obj.join(",") } 
-    }
-  }  
-  has i: {is: :rw, isa: isString(format: /\w+:\w+/) } # validator with autocoerce!
-
-end
-
-describe CoerceTest2 do
-
-end
-=end

data/spec/lazy_spec.rb

@@ -17,14 +17,14 @@ class LazyFox
 
 	has lazy_attr_who_accepts_lambda: {
 		is: :lazy,
-		builder: lambda{ |object| object.something }
+		builder: ->(this){ this.something }
 	}
 
 	has lazy_with_default: {
 		is: :lazy,
 		default: 10,
 		clearer: true,
-		builder: lambda {|o| 1 },
+		builder: ->(this) { 1 },
 	}
 
 	has last_lazy_attr: {

data/spec/meta_spec.rb

@@ -22,6 +22,12 @@ class TestMeta2
   }
 end
 
+class TestMeta3 < TestMeta
+
+  has :lol, { doc: "lol"}
+end
+
+
 describe TestMeta do
   it "should has 'meta'" do
     TestMeta.respond_to?(:meta).should be_true
@@ -87,4 +93,12 @@ describe TestMeta2 do
     docs[:bar].should == "etc"
   end
 
+end
+
+describe TestMeta3 do
+  it "should inherit meta" do
+    TestMeta3.meta.info[:foo].should == ""
+    TestMeta3.meta.info[:bar].should == "etc"    
+    TestMeta3.meta.info[:lol].should == "lol"
+  end
 end

data/spec/modifiers_spec.rb

@@ -1,27 +1,27 @@
 require 'moosex/attribute/modifiers'
 
-describe MooseX::Attribute::Is do
+describe MooseX::AttributeModifiers::Is do
   it "should accept only valid parameters" do
     expect { 
-      MooseX::Attribute::Is.new.process({is: :forbidden}, :foo)
+      MooseX::AttributeModifiers::Is.new.process({is: :forbidden}, :foo)
     }.to raise_error(MooseX::InvalidAttributeError,
       "invalid value for field 'foo' is 'forbidden', must be one of :private, :rw, :rwp, :ro or :lazy")
   end
 end
 
-describe MooseX::Attribute::Predicate do
+describe MooseX::AttributeModifiers::Predicate do
   it "should accept only valid parameters" do
     expect { 
-      MooseX::Attribute::Predicate.new.process({predicate: 0}, :foo)
+      MooseX::AttributeModifiers::Predicate.new.process({predicate: 0}, :foo)
     }.to raise_error(MooseX::InvalidAttributeError,
       "cannot coerce field predicate to a symbol for foo: undefined method `to_sym' for 0:Fixnum")
   end
 end
 
-describe MooseX::Attribute::Handles do
+describe MooseX::AttributeModifiers::Handles do
   it "should accept only valid parameters" do
     expect { 
-      MooseX::Attribute::Handles.new.process({handles: BasicObject}, :foo)
+      MooseX::AttributeModifiers::Handles.new.process({handles: BasicObject}, :foo)
     }.to raise_error(MooseX::InvalidAttributeError,
       "ops, should not use BasicObject for handles in foo")
   end

data/spec/parametric_role_spec.rb

@@ -7,11 +7,11 @@ module Logabble
   has logger: {
     is: :ro,
     #isa: Logger,
-    default: lambda{ 
+    default: -> do 
       logger = Logger.new(STDOUT) 
       logger.level = Logger::INFO
       logger
-    },
+    end,
     handles: {
       log_info: :info, 
       log_warn: :warn, 

data/spec/plugin_spec.rb

@@ -0,0 +1,74 @@
+require 'moosex'
+require 'moosex/attribute'
+require 'moosex/attribute/modifiers'
+
+module MooseX
+  module AttributeModifiers
+    module ThirdParty
+      class Bar
+        def process(options, attr_symbol)
+         !! options.delete(:bar)
+        end
+     end
+    end
+  end  
+end
+
+module MyPlugin
+  def self.included(x)
+    x.meta.add_plugin(:bar)
+  end
+end
+
+module TestAddAttribute
+  class A
+    include MooseX.init(meta: true)
+    include MyPlugin
+
+    has :foo, {
+      bar: true
+    }
+  end
+
+  class B < A
+
+    has :foo2, {
+      bar: true
+    }
+  end
+
+  class C
+    include MooseX.init(meta: true)
+    
+    has :foo, {
+      bar: true
+    }
+  end    
+end
+
+describe TestAddAttribute do
+  it "A should support the new attribute" do
+    TestAddAttribute::A.new(foo: 1)
+  end
+
+  it "A should support the new attribute in meta" do
+    TestAddAttribute::A.meta.attrs[:foo].attribute_map[:bar].should be_true
+  end 
+
+  it "B should support the new attribute" do
+    TestAddAttribute::B.new(foo: 1, foo2: 2)
+  end
+
+  it "B should support the new attribute in meta" do
+    TestAddAttribute::B.meta.attrs[:foo].attribute_map[:bar].should be_true
+    TestAddAttribute::B.meta.attrs[:foo2].attribute_map[:bar].should be_true   
+  end    
+
+  it "C should support the new attribute" do
+    TestAddAttribute::C.new(foo: 1)
+  end
+
+  it "C should support the new attribute in meta" do
+    TestAddAttribute::C.meta.attrs[:foo].attribute_map[:bar].should be_nil
+  end       
+end

data/spec/point_spec.rb

@@ -13,7 +13,7 @@ class Point
 	has y: {
 		is: :rw,
 		isa: Integer,
-		default: lambda { 0 }, # you should specify a lambda
+		default: -> { 0 }, # you should specify a lambda
 	}
 	
 	has secret: {

data/spec/proxy_spec.rb

@@ -5,7 +5,7 @@ class ProxyToTarget
 
   has target: {
     is:  :ro,
-    default: lambda { Target.new },  # default, new instace of Target
+    default: -> { 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
@@ -13,19 +13,19 @@ class ProxyToTarget
         method_y: 1,                 # call obj.mymethod_z(2,3) is the equivalent to
       },                             # call obj.target.method_z(1,2,3)
       my_method_y_with_lambda: {     # currying!!!  
-        method_y: lambda{ 1 },       # call obj.mymethod_z(2,3) is the equivalent to
+        method_y: ->{ 1 },       # call obj.mymethod_z(2,3) is the equivalent to
       },                             # call obj.target.method_z(1,2,3)
       my_method_z_with_array: {
-        method_z: [1,lambda{ 2 } ,3]
+        method_z: [1,->{ 2 } ,3]
       },
       my_method_k_with_literal_array: {
         method_k: [[1,2,3]]
       },
       my_method_k_with_literal_array2: {
-        method_k: [ lambda{  [1,2,3] } ]
+        method_k: [ ->{  [1,2,3] } ]
       },
       my_method_k_with_literal_array3: {
-        method_k: lambda{  [[1,2,3]] } 
+        method_k: ->{  [[1,2,3]] } 
       }            
     }
   }
@@ -111,7 +111,7 @@ class ProxyToTargetUsingArrayOfMethods
 
   has targetz: {
     is:  :ro,
-    default: lambda { Target.new }, 
+    default: -> { Target.new }, 
     handles: [ 
       :method_x, :method_y      # will inject all methods with same name
     ] 
@@ -139,7 +139,7 @@ class ProxyToTargetUsingSingleMethod
 
   has target: {
     is:  :ro,
-    default: lambda { Target.new }, 
+    default: -> { Target.new }, 
     handles: "method_x"         # coerce to an array of symbols
   }
 end
@@ -158,7 +158,7 @@ class ProxyToTargetUsingModule
 
   has target: {
     is:  :ro,
-    default: lambda { Target.new }, 
+    default: -> { Target.new }, 
     handles: TargetModule          # will import all methods from module
   }
 end
@@ -184,7 +184,7 @@ class ProxyToTargetUsingClass
 
   has target: {
     is:  :ro,
-    default: lambda { Target.new }, 
+    default: -> { Target.new }, 
     handles: Target                   # will use only public methods on Target class
   }                                   # exclude methods from superclass
 end

data/spec/traits_spec.rb

@@ -0,0 +1,324 @@
+require 'moosex'
+require 'moosex/types'
+
+module TestTrait
+  class MyHomePage
+    include MooseX
+    include MooseX::Types
+
+    has :counter, {
+      is: :ro,
+      isa: Integer,
+      default: 0,
+      traits: MooseX::Traits::Counter,
+      handles: {
+        inc_counter: :inc,
+        dec_counter: :dec,
+        reset_counter!: :reset,
+      }
+    }
+
+    has :counter_rw, {
+      is: :rw,
+      isa: Integer,
+      default: 0,
+      traits: [ MooseX::Traits::Counter ],
+      handles: {
+        inc_counter_rw: :inc,
+        dec_counter_rw: :dec,
+        reset_counter_rw!: :reset,
+      }
+    }
+
+    has :lazy_counter, {
+      is: :lazy,
+      isa: Integer,
+      traits: [ MooseX::Traits::Counter ],
+      handles: {
+        lazy_inc_counter: :inc,
+        lazy_dec_counter: :dec,
+        lazy_reset_counter!: :reset,
+      },
+      clearer: true,
+    }
+
+    has surname_name: {
+      is: :private,
+      isa: isTuple(String, String),
+      traits: [ MooseX::Traits::Pair ],
+      handles: {
+        surname: :first,
+        name: :second,
+        :surname= => :first=,
+        :name= => :second=,
+        surname_and_name: { join: ->{","} }
+      }
+    }
+
+    has bit: {
+      is: :ro,
+      default: true,
+      traits: MooseX::Traits::Bool,
+      handles: [ :toggle!, :not, :set!, :unset!, :value ],
+    }
+
+    has important: {
+      is: :rw,
+      default: nil,
+      traits: MooseX::Traits::RescueToNil,
+      handles: {
+        plus: :+,
+        minus: :-,
+      }
+    }
+
+    has important2: {
+      is: :rw,
+      default: nil,
+      traits: MooseX::Traits::RescueToZero,
+      handles: {
+        plus2: :+,
+        minus2: :-,
+      }
+    }
+
+    has phrase: {
+      is: :rw,
+      default: nil,
+      traits: MooseX::Traits::RescueToEmptyString,
+      handles: {
+        upcase_phrase: :upcase
+      }
+    }
+
+    def build_lazy_counter
+      0
+    end
+  end
+
+  class ComplexExample
+    include MooseX
+    include MooseX::Types
+
+    has surname_name: {
+      is: :rw,
+      isa: isMaybe(isTuple(String, String)),
+      default: nil,
+      traits: [ MooseX::Traits::RescueToEmptyString, MooseX::Traits::Pair ],
+      handles: {
+        surname: :first,
+        name: :second,
+        :surname= => :first=,
+        :name= => :second=,
+        surname_and_name: { join: ->{", "} }
+      }
+    }
+  end
+end
+
+describe TestTrait::ComplexExample do
+  it "should be possible call surname_and_name" do
+    ce = TestTrait::ComplexExample.new(surname_name: ["Asimov", "Isaac"])
+    ce.name.should == "Isaac"
+    ce.surname_and_name.should == "Asimov, Isaac"
+  end
+
+  it "should be possible call surname_and_name if nil" do
+    ce = TestTrait::ComplexExample.new(surname_name: nil)
+    ce.name.should == ""    
+    ce.surname_and_name.should == ", "
+  end  
+
+  it "should be possible call surname_and_name if nil 2" do
+    ce = TestTrait::ComplexExample.new(surname_name: nil)
+    ce.name.should == ""    
+    ce.surname_and_name.should == ", "
+
+    ce.name= "Isaac"
+    ce.surname_and_name.should == ", Isaac"
+    ce.surname= "Asimov"
+    ce.surname_and_name.should == "Asimov, Isaac"
+    
+    ce.surname_name= nil
+    ce.name.should == ""    
+    ce.surname_and_name.should == ", "    
+  end    
+end
+
+describe TestTrait::MyHomePage do
+  it "should increase counter" do
+    page = TestTrait::MyHomePage.new(counter: 0)
+    page.counter.should be_zero
+    page.inc_counter
+    page.counter.should == 1
+
+    page.inc_counter(3)
+    page.counter.should == 4
+
+    page.dec_counter
+    page.counter.should == 3
+
+    page.dec_counter(2)
+    page.counter.should == 1
+
+    page.reset_counter!
+    page.counter.should be_zero
+
+    page.inc_counter(5)
+    (page.counter * 8).should == 40 
+  end
+
+  it "should increase counter by default value" do
+    page = TestTrait::MyHomePage.new
+    page.counter.should be_zero
+    page.inc_counter
+    page.counter.should == 1
+
+    page.inc_counter(3)
+    page.counter.should == 4
+
+    page.dec_counter
+    page.counter.should == 3
+
+    page.dec_counter(2)
+    page.counter.should == 1
+
+    page.reset_counter!
+    page.inc_counter
+    page.counter.should == 1
+  end  
+
+  it "should increase counter_rw by default value" do
+    page = TestTrait::MyHomePage.new
+    page.counter_rw.should be_zero
+    page.inc_counter_rw
+    page.counter_rw.should == 1
+
+    page.counter_rw = 4
+    page.counter_rw.should == 4
+
+    page.dec_counter_rw
+    page.counter_rw.should == 3
+
+    page.dec_counter_rw(2)
+    page.counter_rw.should == 1
+
+    page.reset_counter_rw!
+    page.counter_rw.should be_zero
+  end  
+
+   it "should increase lazy_counter if lazy" do
+    page = TestTrait::MyHomePage.new
+    page.lazy_counter.should be_zero
+    page.lazy_inc_counter
+    page.lazy_counter.should == 1
+
+    page.lazy_inc_counter(3)
+    page.lazy_counter.should == 4
+
+    page.lazy_dec_counter
+    page.lazy_counter.should == 3
+
+    page.lazy_dec_counter(2)
+    page.lazy_counter.should == 1
+
+    page.lazy_reset_counter!
+    page.lazy_counter.should be_zero
+
+    page.clear_lazy_counter!
+    page.lazy_counter.should be_zero
+    page.lazy_inc_counter
+    page.lazy_counter.should == 1
+  end 
+
+  it "should store name, surname " do
+    page = TestTrait::MyHomePage.new(surname_name: ["Smith", "John"])
+
+    page.name.should == "John"
+    page.surname.should == "Smith"
+    page.surname_and_name.should == "Smith,John"
+
+    page.name= "Karl"
+    page.surname="Popper"
+
+    page.name.should == "Karl"
+    page.surname.should == "Popper"
+    page.surname_and_name.should == "Popper,Karl"
+
+    expect { 
+      page.surname_name.count.should == 2
+    }.to raise_error(NoMethodError)
+  end
+  
+  it "bit should act as a boolean" do
+    page = TestTrait::MyHomePage.new
+    page.bit.should == true
+    page.toggle!
+    page.bit.should == false
+    page.not.should == true
+    
+    page.set!
+    page.bit.should == true
+
+    unless page.bit
+      raise "should act as a true value"
+    end
+    page.unset!
+    page.bit.should == false
+
+    if !! page.bit # necessary!!!
+      raise "should act as a false value"
+    end
+
+    if page.value 
+      raise "should act as a false value"
+    end
+  end
+
+  it "important should be converted to integer" do
+    page = TestTrait::MyHomePage.new(important: 1)
+    page.important.should       == 1
+    page.plus(1).should         == 2
+    page.minus(4).should        == -3
+    (page.important + 5).should == 6
+  end 
+
+  it "important should be converted to integer returning nil" do
+    page = TestTrait::MyHomePage.new(important: nil)
+    page.important.should        == nil 
+    page.plus(1).should          == nil
+    page.minus(4).should         == nil
+    (page.important + 5).should  == nil
+  end
+
+  it "important2 should be converted to integer" do
+    page = TestTrait::MyHomePage.new(important2: 1)
+    page.important2.should       == 1
+    page.plus2(1).should         == 2
+    page.minus2(4).should        == -3
+    (page.important2 + 5).should == 6
+  end 
+
+  it "important2 should be converted to integer returning 0" do
+    page = TestTrait::MyHomePage.new(important2: nil)
+    page.important2.should        be_zero
+    page.plus2(1).should          == 0
+    page.minus2(4).should         == 0
+    (page.important2 + 5).should  == 0
+  end
+
+  it "phrase should be converted to String" do
+    page = TestTrait::MyHomePage.new(phrase: "hello")
+    page.phrase.should           == "hello"
+    page.upcase_phrase           == "HELLO"
+    (page.upcase_phrase.concat ", WORLD").should == "HELLO, WORLD"
+  end 
+
+  it "phrase should returning empty string" do
+    page = TestTrait::MyHomePage.new(phrase: nil)
+    page.phrase.should           be_eql? ""
+    page.upcase_phrase           == ""
+    (page.upcase_phrase.concat ", WORLD").should == ", WORLD"
+  end        
+end  
+