moosex 0.0.17 → 0.0.18

data/lib/moosex/core.rb

@@ -0,0 +1,114 @@
+module MooseX
+    module Core
+    def on_init(&block)
+      __moosex__meta.add_role(block)
+    end
+        
+    def after(*methods_name, &block)
+      __moosex__add_hooks(:after, methods_name, block, caller()) 
+    end
+
+    def before(*methods_name, &block)
+      __moosex__add_hooks(:before, methods_name, block, caller()) 
+    end
+
+    def around(*methods_name, &block)
+      __moosex__add_hooks(:around, methods_name, block, caller())
+    end
+
+    def requires(*methods)
+      methods.each do |method_name|
+        __moosex__meta.add_requires(method_name)
+      end 
+    end
+
+    def has(attr_name, attr_options = {})
+      if attr_name.is_a? Array
+        attr_name.each do |attr| 
+          __moosex__has(attr, attr_options) 
+        end
+      elsif attr_name.is_a? Hash 
+        attr_name.each_pair do |attr, options |
+          has(attr, options)
+        end
+      else
+        __moosex__has(attr_name, attr_options)
+      end
+    end
+
+    private
+    def __moosex__add_hooks(hook, methods_name, block, c)
+      methods_name.each do |method_name|  
+        begin
+          __moosex__try_to_add_hook_now(hook, method_name, block)
+        rescue => e
+          MooseX.warn "unable to apply hook #{hook} in #{method_name} @ #{self}: #{e}", c if self.is_a?(Class) 
+          __moosex__meta.add_hook(hook, method_name, block)
+        end
+      end
+    end
+
+    def __moosex__try_to_add_hook_now(hook, method_name, block)
+      case hook 
+      when :before 
+        __moosex__try_to_add_before_now(method_name, block)
+      when :after
+        __moosex__try_to_add_after_now(method_name, block)
+      when :around
+        __moosex__try_to_add_around_now(method_name, block)
+      end  
+    end
+
+    def __moosex__try_to_add_before_now(method_name, block)
+      method = instance_method method_name
+
+      define_method method_name do |*args, &proc|
+        block.call(self,*args, &proc)
+        method.bind(self).call(*args, &proc)
+      end      
+    end
+
+    def __moosex__try_to_add_after_now(method_name, block)
+      method = instance_method method_name
+
+      define_method method_name do |*args, &proc|
+        result = method.bind(self).call(*args, &proc)
+        block.call(self,*args,&proc)
+        result
+      end      
+    end
+
+    def __moosex__try_to_add_around_now(method_name, block)
+      method = instance_method method_name
+
+      code = Proc.new do | o, *a, &proc| 
+        method.bind(o).call(*a,&proc) 
+      end
+
+      define_method method_name do |*args, &proc|
+        block.call(code, self,*args, &proc)
+      end      
+    end
+
+    def __moosex__has(attr_name, attr_options)
+      attr = MooseX::Attribute.new(attr_name, attr_options, self)
+
+      __moosex__meta.add(attr)
+
+      __moosex__create_methods(attr)
+    end
+
+    def __moosex__create_methods(attr)
+      attr.methods.each_pair do |method, proc|
+        define_method method, &proc
+      end
+
+      if attr.is.eql?(:rwp) 
+        private attr.writter
+      elsif attr.is.eql?(:private)
+        private attr.writter
+        private attr.reader
+      end
+    end
+  end
+end

data/lib/moosex/exceptions.rb

@@ -0,0 +1,11 @@
+module MooseX
+  
+  class FatalError < StandardError
+  end  
+
+  class RequiredMethodNotFoundError < NameError
+  end
+
+  class InvalidAttributeError < TypeError
+  end
+end

data/lib/moosex/meta.rb

@@ -0,0 +1,139 @@
+module MooseX
+
+  class Meta
+    attr_reader :attrs, :requires, :hooks
+
+    def initialize(old_meta=nil)
+      @initialized = false
+      @attrs    = {}
+      @requires = []
+      @roles    = []
+
+      @hooks = {
+        before: Hash.new { |hash, key| hash[key] = [] },
+        after:  Hash.new { |hash, key| hash[key] = [] },
+        around: Hash.new { |hash, key| hash[key] = [] },
+      }
+
+      if old_meta
+        old_meta.attrs.each_pair do |key, value|
+          @attrs[key] = value.clone
+        end
+        @requires = old_meta.requires.clone
+      end
+    end
+
+    def info
+      @attrs.map{|attr_symbol, attr| {attr_symbol => attr.doc }}.reduce(:merge)
+    end
+    
+    def init_roles(*args)
+      @roles.each do|role| 
+        role.call(*args)
+      end  
+    end
+
+    def load_from(module_or_class)
+      other_meta = module_or_class.__moosex__meta
+      other_meta.attrs.each_pair do |key, value|
+        @attrs[key] = value.clone
+      end     
+      @requires += other_meta.requires
+    end
+    
+    def load_from_klass(klass)
+      other_meta = klass.__moosex__meta
+
+      other_meta.hooks.each_pair do |hook, data|
+        data.each_pair do |m, b|
+          @hooks[hook][m] += b.clone
+        end
+      end
+    end
+
+    def add(attr)
+      if @attrs.has_key?(attr.attr_symbol) && ! attr.override
+        raise FatalError, "#{attr.attr_symbol} already exists, you should specify override: true" 
+      end
+      @attrs[attr.attr_symbol] = attr
+    end
+
+    def add_requires(method)
+      @requires << method
+    end
+
+    def add_hook(hook, method, block)
+      @hooks[hook][method] << block.clone
+    end
+
+    def add_role(block)
+      @roles << block
+    end
+
+    def init(object, args)
+      @attrs.each_pair do |symbol, attr| 
+        attr.init(object, args)
+      end  
+
+      MooseX.warn "unused attributes #{args} for #{object.class}", caller unless args.empty?  
+
+      @requires.each do |method|
+        unless object.respond_to? method
+          raise RequiredMethodNotFoundError,
+            "you must implement method '#{method}' in #{object.class}: required"
+        end 
+      end
+    end
+
+    def init_klass(klass)
+      @hooks.values.map {|h| h.keys }.flatten.uniq.map do |method_name|
+        begin
+          [ klass.instance_method(method_name), method_name ]
+        rescue => e
+          MooseX.warn "Unable to apply hooks (after/before/around) in #{klass}::#{method_name} : #{e}" # if $MOOSEX_DEBUG
+          nil
+        end
+      end.select do |value| 
+        !value.nil?
+      end.reduce({}) do |hash, tuple|
+        method, method_name = tuple
+
+        hash[method_name] = __moosex__init_hooks(method_name, method)
+
+        hash
+      end
+    end
+
+    def verify_requires_for(x)
+      @requires.each do |method|
+        unless x.public_instance_methods.include? method
+          MooseX.warn "you must implement method '#{method}' in #{x} #{x.class}: required"# if $MOOSEX_DEBUG
+        end 
+      end
+    end
+    private
+    def __moosex__init_hooks(method_name, method)
+
+      before = @hooks[:before][method_name]
+      after  = @hooks[:after][method_name]
+      around = @hooks[:around][method_name]
+
+      original = lambda do |object, *args, &proc| 
+        method.bind(object).call(*args, &proc)
+      end 
+
+      lambda do |*args, &proc|
+        before.each{|b| b.call(self,*args, &proc)}
+        
+        result = around.inject(original) do |lambda1, lambda2|
+          lambda2.curry[lambda1] 
+        end.call(self, *args, &proc)
+
+        after.each{|b| b.call(self,*args, &proc)}
+        
+        result
+      end
+    end
+
+  end 
+end   

data/lib/moosex/types.rb

@@ -6,6 +6,7 @@ module MooseX
     end
 
     class TypeCheckError < TypeError
+
     end
 
     module Core 
@@ -181,45 +182,56 @@ module MooseX
 
       def isTuple(*types)
 
-        createValidator "[Tuple [#{types.map{|t| t.to_s}.join ', '}]]" do |tuple|
-          isType(Array).call(tuple)
-
+        size_validation = lambda do |tuple|
           unless tuple.size == types.size
             raise TypeCheckError, "Tuple violation: size should be #{types.size} instead #{tuple.size}"
-          end
-
-          types.each_index do |index|
-            begin
-              isType(types[index]).call(tuple[index])
-            rescue TypeCheckError => e
-              raise TypeCheckError, "Tuple violation: on position #{index} caused by #{e}"
-            end
-          end
+          end              
         end
 
+        individual_validations = create_individual_validations_for_tuples(types)
+
+        proc = isAllOf(
+            isType(Array),
+            size_validation,
+            *individual_validations,
+          )
+
+        createValidator("[Tuple [#{types.map{|t| t.to_s}.join ', '}]]", &proc)
       end
 
       def isSet(type=nil)
         type = isAny if type.nil?
 
-        createValidator "[Set #{type.to_s}]" do |set|
-          isType(Array).call(set)
+        proc = isAllOf(
+            isArray(type),
+            lambda do |set|
+              if set.uniq.size != set.size
+                raise TypeCheckError, "Set violation: has one or more non unique elements"
+              end 
+            end,
+          )
 
-          if set.uniq.size != set.size
-            duplicated = set.inject(Hash.new(0)) {|h,i| h[i] += 1; h }.select{|k,v| v > 1 }
-            raise TypeCheckError, "Set violation: has one or more non unique elements: #{duplicated} (value => count)"
-          end 
+        createValidator("[Set #{type.to_s}]", &proc)
+      end
 
-          set.each do |item| 
+      private
+      def create_individual_validations_for_tuples(types)
+        individual_validations = []
+        types.each_index do |index|        
+          individual_validations << lambda do |tuple|
             begin
-              isType(type).call(item)
+              isType(types[index]).call(tuple[index])
             rescue TypeCheckError => e
-              raise TypeCheckError, "Set violation: caused by #{e}"
+              raise TypeCheckError, "Tuple violation: on position #{index} caused by #{e}"
             end
           end
         end
-      end 
+
+        individual_validations        
+      end      
 
     end
+
   end 
-end
+
+end 

data/lib/moosex/version.rb

@@ -1,3 +1,3 @@
 module MooseX
-  VERSION = "0.0.17"
+  VERSION = "0.0.18"
 end

data/spec/lol_spec.rb

@@ -13,6 +13,7 @@ class Lol
       default: 1,
       predicate: :can_haz_c?,     # custom predicate
       clearer: "desintegrate_c",  # force coerce to symbol
+      xxx: 1,
     }
 
 	has [:d, :e] => {

data/spec/meta_spec.rb

@@ -0,0 +1,90 @@
+require 'moosex'
+
+class TestMeta
+  include MooseX.init(meta: true)
+
+  has :foo
+  has :bar, {
+    is: :ro,
+    default: 1,
+    doc: "etc",
+  }
+end
+
+class TestMeta2
+  include MooseX.init(meta: :mymeta)
+
+  has :foo
+  has :bar, {
+    is: :ro,
+    default: 1,
+    doc: "etc",
+  }
+end
+
+describe TestMeta do
+  it "should has 'meta'" do
+    TestMeta.respond_to?(:meta).should be_true
+  end
+
+  it "meta should return list of attributes" do
+    attrs = TestMeta.meta.attrs
+
+    attributes = attrs.keys
+    attributes[0].should == :foo
+    attributes[1].should == :bar
+
+    attrs[:foo].is.should == :rw
+
+    attrs[:bar].is.should == :ro
+    attrs[:bar].default.call.should == 1 
+    attrs[:bar].doc.should == "etc"  
+  end
+
+  it "meta should return list of documentations" do
+    docs = TestMeta.meta.info
+
+    docs[:foo].should == ""
+    docs[:bar].should == "etc"
+  end
+
+  it "TestMeta shuold be possible add an attribute on the fly" do
+    TestMeta.has :baz, { required: true}
+    tm = TestMeta.new(baz: 1)
+    tm.baz.should == 1
+    
+    expect{
+      TestMeta.new
+    }.to raise_error(MooseX::InvalidAttributeError,
+      'attr "baz" is required')
+  end
+end
+
+describe TestMeta2 do
+  it "should has 'mymeta'" do
+    TestMeta2.respond_to?(:meta).should be_false
+    TestMeta2.respond_to?(:mymeta).should be_true
+  end
+
+  it "meta should return list of attributes" do
+    attrs = TestMeta2.mymeta.attrs
+
+    attributes = attrs.keys
+    attributes[0].should == :foo
+    attributes[1].should == :bar
+
+    attrs[:foo].is.should == :rw
+
+    attrs[:bar].is.should == :ro
+    attrs[:bar].default.call.should == 1 
+    attrs[:bar].doc.should == "etc"  
+  end
+
+  it "meta should return list of documentations" do
+    docs = TestMeta2.mymeta.info
+
+    docs[:foo].should == ""
+    docs[:bar].should == "etc"
+  end
+
+end