r_kit 0.5 → 1.0

data/lib/r_kit/decoration/base.rb

@@ -1,10 +1,30 @@
 module RKit::Decoration::Base
 
+  def self.included base
+    base.singleton_attr_reader :decorated_class
+    base.singleton_attr_reader :after_initialize_procs, default: proc{ [] }
+
+    base.define_singleton_method :after_initialize, ->(&block) do
+      after_initialize_procs << block
+    end
+  end
+
+
   def initialize object, view_context: nil
     @view_context = view_context
-    super object
+
+    super(object)
+    after_initialize!
+  end
+
+  def after_initialize!
+    decorated = self
+    __getobj__.define_singleton_method(:decorated){ decorated }
+
+    decorator_class.after_initialize_procs.each{ |after_initialize_proc| self.instance_eval &after_initialize_proc }
   end
 
+
   alias :decorator_class :class
   delegate :class, to: :__getobj__
 
@@ -15,6 +35,8 @@ module RKit::Decoration::Base
 
   def decorated?() true end
 
+  def need_decoration?() false end
+
   def raw
     __getobj__
   end
@@ -25,7 +47,22 @@ module RKit::Decoration::Base
   end
 
   def view
-    @view_context ||= view_context
+    (@@mutex ||= Mutex.new).synchronize do
+      @view_context ||= view_context
+    end
+  rescue ThreadError
+    nil
+  end
+
+
+  def method_missing method_name, *args, &block
+    closure = super
+
+    if RKit::Decoration.config.recursive_decoration && closure.need_decoration?
+      closure.decorate(view_context: view)
+    else
+      closure
+    end
   end
 
 end

data/lib/r_kit/decoration/class.rb

@@ -1,16 +1,14 @@
 class RKit::Decoration::Class
 
-  class << self
-    alias :basic_new :new
-    def new *args, &block
-      basic_new(*args, &block).decorator
-    end
+  def self.new *args, &block
+    super.decorator
   end
 
 
-  def initialize decorated, from: nil, &block
+  def initialize decorated, from: nil, sleeping: nil, &block
     @decorated = decorated
     @from = from
+    @sleeping = sleeping
     @block = block || proc{}
   end
 
@@ -18,11 +16,25 @@ class RKit::Decoration::Class
   def decorator
     decorator_from(@from)
       .tap{ |decorator| decorator.instance_variable_set "@decorated_class", @decorated }
-      .tap{ |decorator| decorator.class_eval{ alias :"#{ decorated_class.demodulize.underscore }" :__getobj__ } }
+      .tap{ |decorator|
+        unless decorator.decorated_class.method_defined? :"#{ decorator.decorated_class.demodulize.underscore }"
+          decorator.class_eval{ alias :"#{ decorated_class.demodulize.underscore }" :__getobj__ }
+        end
+      }
+      .tap{ |decorator| decorator.send :include, @sleeping }
       .tap{ |decorator| decorator.class_eval &@block }
   end
 
 
+  def decorator_superclass
+    if @decorated <=> Enumerable
+      RKit::Decoration::Collection
+    else
+      RKit::Decoration::Object
+    end
+  end
+
+
 
   protected def decorator_from from
     send "decorator_from_#{ from.class.underscore }", from
@@ -37,7 +49,7 @@ class RKit::Decoration::Class
     decorator_from(
       @decorated
         .namespace
-        .const_get name, default: Class.new(RKit::Decoration::Object)
+        .const_get name, default: Class.new(decorator_superclass)
     )
   end
 
@@ -48,64 +60,23 @@ class RKit::Decoration::Class
     mod
       .namespace
       .const_replace mod.demodulize,
-        Class.new(RKit::Decoration::Object){ include mod }
+        Class.new(decorator_superclass){ include mod }
   end
 
   def decorator_from_class base
-    if base <=> RKit::Decoration::Object
+    if base <=> RKit::Decoration::Base
       base
     else
       # TODO: method class_to_module
       # TODO: method class.add_ancestor(superclass)
+      decorator_superclass = self.decorator_superclass
+
       base.tap do |base|
-        base.send :include, Module.new{ include refine(RKit::Decoration::Object){} }
-        base.extend Module.new{ include refine(RKit::Decoration::Object.singleton_class){} }
+        base.send :include, Module.new{ include refine(decorator_superclass){} }
+        base.extend Module.new{ include refine(decorator_superclass.singleton_class){} }
         base.instance_variable_set "@decorated_class", @decorated
         base.class_eval{ alias :"#{ decorated_class.demodulize.underscore }" :__getobj__ }
       end
     end
   end
 end
-
-
-# # TODO: all the methods below this comment should be private, even more, they should be in a "decorator_finder_creator_definer", and not included in active_record. SRP guys !
-# def define_decorator arg
-#   @decorator_klass = decorator_klass_from arg
-#   @decorator_klass
-# end
-#
-#
-# def decorator_klass_from arg
-#   send "decorator_klass_from_#{ arg.class.name.underscore }", arg
-# end
-#
-# def decorator_klass_from_nil_class *args
-#   decorator_klass_from "#{ name }Decorator".constantize
-# end
-#
-# def decorator_klass_from_class base
-#   if base <=> RKit::Decoration::Base
-#     base
-#   else
-#     base.tap do |base|
-#       base.send :include, Module.new{ include refine(RKit::Decoration::Base){} }
-#       base.extend Module.new{ include refine(RKit::Decoration::Base.singleton_class){} }
-#       base.instance_variable_set "@decorated_klass", self
-#       base.class_eval{ alias :"#{ decorated_klass.demodulize.underscore }" :__getobj__ }
-#     end
-#   end
-# end
-#
-# def decorator_klass_from_module mod
-#   namespace = (mod.name.deconstantize.presence || 'Object').constantize
-#   const_name = mod.name.demodulize
-#
-#   namespace.send :remove_const, const_name
-#   namespace.const_set const_name, RKit::Decoration::Class.new(self){ include mod }
-# end
-#
-# def decorator_klass_from_proc block
-#   (name.deconstantize.presence || 'Object')
-#     .constantize
-#     .const_set "#{ name.demodulize }Decorator", RKit::Decoration::Class.new(self, &block)
-# end

data/lib/r_kit/decoration/dsl.rb

@@ -5,6 +5,11 @@ class RKit::Decoration::Dsl
   method :acts_as_decorables
   domain ActiveRecord::Base
 
+  before do
+    def self.decorator_class() @decorator_class ||= Module.new end
+    def decorated?() false end
+  end
+
 
   params ->(from = nil, &block){}
 
@@ -12,110 +17,36 @@ class RKit::Decoration::Dsl
 
     @decorator_class = RKit::Decoration::Class.new self,
       from: decoration_dsl.params.from,
+      sleeping: decorator_class,
       &decoration_dsl.params.block
 
     def decorator_class
       @decorator_class
     end
 
-    # TODO: this couls move in "ennumerable", cause if the AR::relation is mapped into an array
-    # or if we create an array with decorables objects in it
-    # this will fail
-    # --
-    # in addition, make a "safe_decorate" for collections, wich will decorate if respond_to_decorate,
-    # and will not raise error
-    # TODO: act as paginable can not be used, because of decoration (implicit here)
-    # decorated paginated collection still work fine
-    # but non paginated collection, becomes dumb arrays
-    # def decorate view_context: nil
-    #   all.map{ |record| record.decorate view_context: view_context }
-    # end
-
     def decorate **options
       RKit::Decoration::Collection.new all, **options
     end
 
     def decorated?() false end
 
+    def need_decoration?() true end
+
   end
 
 
   methods :instance do
 
+    delegate :decorator_class, to: :__class__
+
+
     def decorate **options
-      __class__.decorator_class.new self, **options
+      decorator_class.new self, **options
     end
 
     def decorated?() false end
 
+    def need_decoration?() true end
+
   end
 end
-
-
-
-
-# attr_accessor :decorator_klass
-#
-# def acts_as_decorables base = nil, &block
-#   define_decorator base || block
-#   define_instance_methods
-# end
-#
-# # TODO: all the methods below this comment should be private, even more, they should be in a "decorator_finder_creator_definer", and not included in active_record. SRP guys !
-# def define_decorator arg
-#   @decorator_klass = decorator_klass_from arg
-#   @decorator_klass
-# end
-#
-#
-# def decorator_klass_from arg
-#   send "decorator_klass_from_#{ arg.class.name.underscore }", arg
-# end
-#
-# def decorator_klass_from_nil_class *args
-#   decorator_klass_from "#{ name }Decorator".constantize
-# end
-#
-# def decorator_klass_from_class base
-#   if base <=> RKit::Decoration::Base
-#     base
-#   else
-#     base.tap do |base|
-#       base.send :include, Module.new{ include refine(RKit::Decoration::Base){} }
-#       base.extend Module.new{ include refine(RKit::Decoration::Base.singleton_class){} }
-#       base.instance_variable_set "@decorated_klass", self
-#       base.class_eval{ alias :"#{ decorated_klass.demodulize.underscore }" :__getobj__ }
-#     end
-#   end
-# end
-#
-# def decorator_klass_from_module mod
-#   namespace = (mod.name.deconstantize.presence || 'Object').constantize
-#   const_name = mod.name.demodulize
-#
-#   namespace.send :remove_const, const_name
-#   namespace.const_set const_name, RKit::Decoration::Class.new(self){ include mod }
-# end
-#
-# def decorator_klass_from_proc block
-#   (name.deconstantize.presence || 'Object')
-#     .constantize
-#     .const_set "#{ name.demodulize }Decorator", RKit::Decoration::Class.new(self, &block)
-# end
-#
-# # TODO: this couls move in "ennumerable", cause if the AR::relation is mapped into an array
-# # or if we create an array with decorables objects in it
-# # this will fail
-# # --
-# # in addition, make a "safe_decorate" for collections, wich will decorate if respond_to_decorate,
-# # and will not raise error
-# def decorate view_context: nil
-#   all.map{ |record| record.decorate view_context: view_context }
-# end
-#
-#
-# def define_instance_methods
-#   define_method 'decorate' do |view_context: nil|
-#     self.class.decorator_klass.new self, view_context: view_context
-#   end
-# end

data/lib/r_kit/decoration/enumerable_extend.rb

@@ -1,9 +1,13 @@
 module Enumerable
 
   def decorate **options
-    RKit::Decoration::Collection.new(self, **options).safe
+    RKit::Decoration::Collection.new(self, **options)
   end
 
   def decorated?() false end
 
+  def need_decoration?
+    any?(&:need_decoration?)
+  end
+
 end

data/lib/r_kit/decoration/object_extend.rb

@@ -0,0 +1,5 @@
+class Object
+
+  def need_decoration?() false end
+
+end

data/lib/r_kit/decoration.rb

@@ -1,11 +1,5 @@
 class RKit::Decoration
 
-  # TODO: backtrace is not really a dependency,
-  # as we, most of the time, get the view context from the block
-  # and if not, we do not require the "view_context" (well, we could not, I think)
-  # (the only case is if the user define a block elswhere than in the view or in the controller, and use it)
-  # (but this case will fail today as well, I think)
-  # -> pb w/ backtrace in console (Screencast.limit(5).decorate.map{|x|x} -> infinite loop)
   dependency :backtrace,
     :dsl,
     :utility
@@ -17,10 +11,13 @@ class RKit::Decoration
     'base/object',
     'class',
     'dsl',
-    'enumerable_extend'
+    'enumerable_extend',
+    'object_extend'
 
   load_path __FILE__, 'action_view_base_extend', if: :implicit_decoration
 
 
   config :implicit_decoration, true
+  config :recursive_decoration, true
+
 end

data/lib/r_kit/dsl/base/thrust.rb

@@ -12,6 +12,10 @@ class RKit::Dsl::Base
       end
     end
 
+    protected def thrust_dsl_callback!
+      @domain.class_eval &readonly.methods[:before]
+    end
+
     protected def thrust_dsl_interface!
       name = @name
 
@@ -48,12 +52,12 @@ class RKit::Dsl::Base
       @domain.send :define_singleton_method, "try_to_#{ @method }" do |*args, &block|
         send "#{ name }_params=", *args, &block
 
-        if send "can_#{ send(name).method }?"
+        if send("can_#{ send(name).method }?") && !send("#{ send(name).method }?")
           send(name).dsls[name] << self
 
           instance_eval &send(name).methods[:class]
           class_eval &send(name).methods[:instance]
-          if respond_to?(:acts_as_decorables?) && acts_as_decorables?
+          if respond_to?(:acts_as_decorables?)
             decorator_class.class_eval &send(name).methods[:decorator]
           end
 

data/lib/r_kit/dsl/base.rb

@@ -36,10 +36,9 @@ class RKit::Dsl::Base
 
     @domain ||= domain
 
-    shadow :domain do |shadow_self|
-      shadow_self.instance_variable_set "@domain", domain
-
+    shadow domain: domain do |shadow_self|
       thrust_dsl!
+      thrust_dsl_callback! if @methods[:before]
       thrust_dsl_interface!
       thrust_dsl_options!
       thrust_dsl_extend!
@@ -47,6 +46,13 @@ class RKit::Dsl::Base
   end
 
 
+  def before &block
+    methods :before, &block
+
+    thrust_dsl_callback!
+  end
+
+
   def params params_lambda
     @params = RKit::Dsl::Base::Params.new(params_lambda)
   end

data/lib/r_kit/dsl/dsl_extend.rb

@@ -4,7 +4,7 @@ module RKit::Dsl::DslExtend
     subclass.instance_variable_set "@_dsl", RKit::Dsl::Base.new(subclass)
   end
 
-  delegate :name, :method, :domain, :params, :methods, :allowed?, :restricted,
+  delegate :name, :method, :domain, :before, :params, :methods, :allowed?, :restricted,
     to: :@_dsl
 
 end

data/lib/r_kit/dsl/test.rb

@@ -0,0 +1,81 @@
+class Yank
+  act_as_a_dsl # active la déclaration de la dsl
+
+  name :yank # définit le nom de la dsl, utilisé pour les params surtout
+  method :acts_as_yankables # définit le nom de la méthode
+  domain ActiveRecord::Base # définit la zone d'action de la dsl
+
+  # définit des méthodes directement dans la classe du domaine
+  # ce qui permet d'ajouter du comportement dans le domaine sans avoir appelé la méthode de la dsl
+  before do
+    def yanked?
+      false
+    end
+  end
+
+  # définit si je peux exécuter ou non la dsl
+  allowed? do
+    table_exists? # && column_names.include?("yank")
+  end
+
+  # définit le comportement en si le 'allowed?' réponds 'false'
+  # il y a un "raise DslStandardError" par défaut, si rien n'est renseigné
+  restricted do
+    raise DatabaseSchemaError.new(self, method_name: 'bonjour')
+  end
+
+  # définit la structure des arguments que je peux utiliser pour la dsl
+  params ->(y_arg, *y_args){}
+
+  # définit les méthodes de classes qui seront ajoutés lors de l'utilisation de la dsl
+  methods :class do
+
+
+    yank.params.y_args # permet d'accéder aux arguments passés lors de l'appel de la dsl. c'est une Struct
+
+    yank.extract_local_variables # extrait les arguments passés lors de l'appel de la dsl en variables locales
+    y_args
+
+
+    scope :yanked, ->{ all }
+
+    def yanked?
+      true
+    end
+  end
+
+  # définit les méthodes d'instance qui seront ajoutés lors de l'utilisation de la dsl
+  methods :instance do
+    def yank
+      "yank"
+    end
+  end
+
+  # définit les méthodes de decorator qui seront ajoutés lors de l'utilisation de la dsl
+  # uniquement si la classe "hôte" réponds à "decorator_klass" (c'est la cas si on utilise RKit::Decorator ^^)
+  methods :decorator do
+    def yank
+      "yyyyyyyyy"
+    end
+  end
+end
+
+=begin
+# utilisation
+class Article < ActiveRecord::Base
+  try_to_acts_as_yankables :y_arg # ne va pas trigger 'restricted' si le 'allowed?' réponds 'false'
+  acts_as_yankables :y_arg # trigger le 'restricted'
+end
+
+class Commentaire < ActiveRecord::Base
+end
+-> Commentaire.new.yanked? #=> false
+
+
+# in main
+Article.can_acts_as_yankables?
+Article.acts_as_yankables?
+Yank.acts_as_yankables #=> [Article]
+
+DSLS #=> {yank: [Article]}
+=end

data/lib/r_kit/dsl.rb

@@ -46,12 +46,6 @@ class RKit::Dsl
   # -> to do that, either, interchage all the methods (painfull)
   # -> or, try to replace the const_name when 'act_as_dsl' is used (pb when re-opening the class ?)
 
-  # TODO: rkit: on dsl, I lac of a callback when dsl is put in another class
-  # (like a 'def self.decorated(decorator)' for example).
-  # I know I can put the code in 'class methods',
-  # but I may also want a specific callback from the calling class ?
-  # (maybe smthng like "before_acts_as_X + after_act_as_X") ("self.yanked" "self.X-ed")
-
   # TODO: make smthing to define methods on the "domain" level
   # for example, in the series dsl, I could define a method "per_page" in all the domain, that would return '[]'
   # and when dsl is added, that would return an array with all the series
@@ -67,6 +61,7 @@ class RKit::Dsl
   # then -> def self.clas_method, -> def instance_method
   # then, in host class -> act_as_x -> define "@X", X_delegator(self), delegate *X.methods, to: @X
 
+
   # load_path __FILE__, 'test'
 
 end

data/lib/r_kit/frame/collection_dsl.rb

@@ -0,0 +1,24 @@
+class RKit::Frame::CollectionDsl
+
+  act_as_a_dsl
+
+  name :framed_collection_dsl
+  method :acts_as_frameable_collection
+  domain Enumerable
+
+
+  methods :instance do
+
+    override_method :each do |&block|
+      __olddef__ &->(obj) do
+
+        obj.shadow sy_frame: self do |obj|
+          block.call(obj)
+        end
+
+      end
+    end
+
+  end
+
+end

data/lib/r_kit/frame/empty_frame.rb

@@ -0,0 +1,7 @@
+class RKit::Frame::EmptyFrame
+  include Singleton
+
+  def !() true end
+  def empty?() true end
+  def method_missing(*_) nil end
+end

data/lib/r_kit/frame/instance_dsl.rb

@@ -0,0 +1,30 @@
+class RKit::Frame::InstanceDsl
+
+  act_as_a_dsl
+
+  name :framed_instance_dsl
+  method :acts_as_frameable
+  domain Object
+
+  before do
+    def frame
+      @sy_frame || RKit::Frame::EmptyFrame.instance
+    end
+
+    def frame= value
+      @sy_frame = value
+    end
+
+
+    def framed &block
+      shadow sy_frame: block.binding.eval('self') do |obj|
+        block.call obj
+      end
+    end
+
+    def framed?
+      !!frame
+    end
+  end
+
+end

data/lib/r_kit/frame.rb

@@ -0,0 +1,14 @@
+class RKit::Frame
+
+  dependency :dsl,
+    :utility
+
+
+  load_path __FILE__,
+    'empty_frame'
+
+  load_path __FILE__,
+    'collection_dsl',
+    'instance_dsl'
+
+end