r_kit 0.5 → 1.0

data/lib/r_kit/override/test.rb

@@ -0,0 +1,466 @@
+
+class A
+  def x
+    "x"
+  end
+
+  override_method :x do
+    __olddef__ << "y"
+  end
+end
+
+# overide classic
+puts "A: xy -> #{ A.new.x }"
+
+class B
+  def x
+    "x"
+  end
+end
+
+class C < B
+  override_method :x do
+    __olddef__ << "y"
+  end
+end
+
+# override w/ inheritance
+puts "C: xy -> #{ C.new.x }"
+
+class D
+  override_method :x do
+    __olddef__ || "y"
+  end
+end
+
+# override when no previous def
+puts "D: y -> #{ D.new.x }"
+
+class E
+  def x
+    "x"
+  end
+
+  override_method :x do
+    __olddef__ << "y"
+  end
+
+  override_methods do
+    def x
+      __olddef__ << "z"
+    end
+  end
+end
+
+# override many
+puts "E: xyz -> #{ E.new.x }"
+
+class F < B
+  def a
+    "a"
+  end
+
+  override_methods do
+    def a
+      __olddef__ << "b"
+    end
+
+    def x
+      __olddef__ << "y"
+    end
+  end
+end
+
+# multi override don't collapse
+f = F.new
+puts "F: ab -> #{ f.a }"
+puts "F: xy -> #{ f.x }"
+puts "F: ab -> #{ f.a }"
+puts "F: xy -> #{ f.x }"
+
+
+class G
+  def initialize(s)
+    @s = s
+  end
+
+  def should?
+   @s
+  end
+
+  def x
+    "x"
+  end
+
+  depend_pattern = ->{
+    if should?
+      __newdef__
+    else
+      nil
+    end
+  }
+
+  override_method :x, pattern: depend_pattern do
+    __olddef__ << "y"
+  end
+end
+
+# override w/ depend pattern
+puts "G:  -> #{ G.new(false).x }"
+puts "G: xy -> #{ G.new(true).x }"
+
+class H
+  def x(str)
+    "x" << str
+  end
+
+  override_method :x do |str, str_end|
+    __olddef__(str) << "y" << str_end
+  end
+end
+
+# override w/ args
+puts "H: xXyY -> #{ H.new.x('X', 'Y') }"
+
+class I
+  def x(str)
+    "x" << str
+  end
+
+  override_methods do
+    def x(str, str_end)
+      __olddef__(str) << "y" << str_end
+    end
+  end
+end
+
+# override many w/ args
+puts "I: xXyY -> #{ I.new.x('X', 'Y') }"
+
+class J
+  def initialize(s)
+    @s = s
+  end
+
+  def should?
+   @s
+  end
+
+  def x
+    "x"
+  end
+
+  if_pattern = ->{
+    if should?
+      __newdef__
+    else
+      __olddef__
+    end
+  }
+
+  override_method :x, pattern: if_pattern do
+    __olddef__ << "y"
+  end
+end
+
+# override w/ if pattern
+puts "J: x -> #{ J.new(false).x }"
+puts "J: xy -> #{ J.new(true).x }"
+
+class K < SimpleDelegator
+  override_method :x do
+    __olddef__ << "y"
+  end
+end
+
+# override in delegator
+puts "K: xy -> #{ K.new(B.new).x }"
+
+class L
+  def initialize
+    @should_load = true
+  end
+
+  def load
+    "not implemented"
+  end
+
+  override_method :load do
+    if @should_load
+      @should_load = false
+      "load"
+    else
+      "nothing"
+    end
+  end
+end
+
+# change instance values inside overrided method
+l = L.new
+puts "L: load -> #{ l.load }"
+puts "L: nothing -> #{ l.load }"
+
+class M
+  def initialize
+    @loaded = false
+  end
+
+  def loaded?
+    @loaded
+  end
+
+  def load
+    "not implemented"
+  end
+
+  override_method :load do
+    @loaded = true
+    self
+  end
+end
+
+# return self in overrided method
+puts "M: false -> #{ M.new.loaded? }"
+puts "M: true -> #{ M.new.load.loaded? }"
+
+class N
+  class << self
+    def x
+      "x"
+    end
+
+    override_method :x do
+      __olddef__ << "y"
+    end
+  end
+end
+
+# override singleton method using '<<' syntax
+puts "N: xy -> #{ N.x }"
+
+class O
+  def self.x
+    "x"
+  end
+
+  override_methods do
+    def self.x
+      __olddef__ << "y"
+    end
+  end
+end
+
+# override singleton method using 'self.' syntax
+puts "O: xy -> #{ O.x }"
+
+class P < SimpleDelegator
+  def initialize(obj, should)
+    super(obj)
+    @should = should
+  end
+
+  if_pattern = ->{
+    if @should
+      __newdef__
+    else
+      __olddef__
+    end
+  }
+
+  override_method :x, pattern: if_pattern do
+    __olddef__ << "y"
+  end
+end
+
+# override in delegator w/ if pattern
+puts "P: x -> #{ P.new(B.new, false).x }"
+puts "P: xy -> #{ P.new(B.new, true).x }"
+
+module Q
+  override_method :x do
+    __olddef__ << "y" rescue 'hahah'
+  end
+end
+
+class R
+  prepend Q
+
+  def x
+    "x"
+  end
+end
+
+# override in a prepended module from a class
+puts "R: xy -> #{ (r = R.new).x }"
+puts "R: xy -> #{ r.x }"
+
+module S
+  def x
+    "x"
+  end
+end
+
+class T
+
+  override_method :x do
+    __olddef__ << "y"
+  end
+
+  include S
+
+end
+
+# override in a included module from a class
+puts "T: xy -> #{ (t = T.new).x }"
+puts "T: xy -> #{ t.x }"
+
+class U < SimpleDelegator
+  override_method :x do
+    __olddef__ || 'y'
+  end
+end
+
+# delegate w/ no previous def in delegated object
+puts "U: y -> #{ U.new(Class.new.new).x }"
+
+class V
+  def self.x
+    "x"
+  end
+
+  override_singleton_method :x do
+    __olddef__ << "y"
+  end
+end
+
+# override singleton method w/ specific method
+puts "V: xy -> #{ V.x }"
+
+class W
+  def self.x
+    "x"
+  end
+
+  override_singleton_methods do
+    def x
+      __olddef__ << "y"
+    end
+  end
+end
+
+# override singleton methods w/ specific method
+puts "W: xy -> #{ W.x }"
+
+class X
+  def self.x
+    "x"
+  end
+
+  override_singleton_method :x do
+    __olddef__ << "y"
+  end
+
+  override_singleton_methods do
+    def x
+      __olddef__ << "z"
+    end
+  end
+end
+
+# override many in singleton
+puts "X: xyz -> #{ X.x }"
+
+class Y
+  def self.a
+    "a"
+  end
+
+  def self.x
+    "x"
+  end
+
+  override_singleton_methods do
+    def a
+      __olddef__ << "b"
+    end
+
+    def x
+      __olddef__ << "y"
+    end
+  end
+end
+
+# multi singleton override don't collapse
+puts "Y: ab -> #{ Y.a }"
+puts "Y: xy -> #{ Y.x }"
+puts "Y: ab -> #{ Y.a }"
+puts "Y: xy -> #{ Y.x }"
+
+
+class Z
+  def self.meta_x method_name_1
+    singleton_class.send :define_method, method_name_1 do
+      # p method_name_1.object_id
+      method_name_1
+    end
+  end
+
+  override_singleton_method :meta_x do |name|
+
+    __olddef__(name).tap do |method_name_2|
+
+      override_singleton_method method_name_2 do
+        # p __olddef__.object_id
+        __olddef__ << method_name_2.to_s
+      end
+    end
+  end
+
+  meta_x 'x'
+  meta_x 'y'
+  meta_x 'z'
+
+end
+
+# overide nested
+puts "Z: xx -> #{ Z.x }"
+puts "Z: yy -> #{ Z.y }"
+puts "Z: zz -> #{ Z.z }"
+puts "!Z: xx -> #{ Z.x }"
+puts "!Z: yy -> #{ Z.y }"
+puts "!Z: zz -> #{ Z.z }"
+puts "NOTE: this behavior is because `__olddef__' (the nested one) get as a result `method_name_1'"
+puts "NOTE: as `method_name_1' is actually a local variable, it is passed as a reference, so it will be modified"
+puts "NOTE: as `method_name_1' is modified, it will change the behavior of `__olddef__'"
+puts "NOTE: see below a correct implementation of this"
+
+class Z2
+  def self.meta_x method_name_1
+    singleton_class.send :define_method, method_name_1 do
+      method_name_1.dup
+    end
+  end
+
+  override_singleton_method :meta_x do |name|
+
+    __olddef__(name).tap do |method_name_2|
+
+      override_singleton_method method_name_2 do
+        __olddef__ << method_name_2.to_s
+      end
+    end
+  end
+
+  meta_x 'x'
+  meta_x 'y'
+  meta_x 'z'
+
+end
+
+# overide nested
+puts "Z: xx -> #{ Z2.x }"
+puts "Z: yy -> #{ Z2.y }"
+puts "Z: zz -> #{ Z2.z }"
+puts "Z: xx -> #{ Z2.x }"
+puts "Z: yy -> #{ Z2.y }"
+puts "Z: zz -> #{ Z2.z }"

data/lib/r_kit/override/unbound_method_extend.rb

@@ -0,0 +1,8 @@
+class UnboundMethod
+
+  def simple_override receiver:, &block
+    name = self.name
+    receiver.prepend Module.new{ define_method name, &block }
+  end
+
+end

data/lib/r_kit/override.rb

@@ -0,0 +1,15 @@
+class RKit::Override
+
+  load_path __FILE__,
+    'base',
+    'method_extend',
+    'module_extend',
+    'pattern',
+    'unbound_method_extend'
+
+  # load_path __FILE__, 'test'
+  # load_path __FILE__, 'perfs'
+
+  # TODO: config for 'simple_override' -> active or not ?
+
+end

data/lib/r_kit/pagination/base/page.rb

@@ -11,43 +11,25 @@ class RKit::Pagination::Base::Page
   RKit::Decoration::Dsl.domain self
   acts_as_decorables do
 
-    # TODO: we tried to cancel the underscored alias of __getobj__
-    # cause the class name is also an attr_name
-    # but this doesn't work, cause when you use a block, the decorator class creation will be processed after
-    # so, in decoration, we might whant to alias only if method not already defined
-    def page
-      __getobj__.page
-    end
-
-
     after_initialize do
-      if __getobj__.page == base.page
+      if page == base.page
         alias :page_tag :disabled_link_to_page
       end
     end
 
 
-    def page_tag name = __getobj__.page
+    def page_tag name = page
       link_to_page name
     end
 
 
-    def link_to_page name = __getobj__.page
-      view.link_to name, view.url_for(page: __getobj__.page), class: :btn
+    def link_to_page name = page
+      view.link_to name, view.url_for(page: page), class: :btn
     end
 
-    def disabled_link_to_page name = __getobj__.page
+    def disabled_link_to_page name = page
       view.content_tag :span, name, class: :'btn-disabled'
     end
-
   end
 
-
-
-
-  # this need
-  # current_page
-
-  # and a decorator
-
 end

data/lib/r_kit/pagination/base.rb

@@ -12,8 +12,10 @@ class RKit::Pagination::Base < CollectionDelegator
     @per_page = options[:per_page] || RKit::Pagination.config.per_page[collection.klass]
   end
 
-  tap_attr_accessor :page
-  tap_attr_accessor :per_page
+  def paginated?() true end
+
+
+  tap_attr_accessor :page, :per_page, typecast: :to_i
 
   def total_pages
     (collection.count / per_page.to_f).ceil
@@ -31,17 +33,25 @@ class RKit::Pagination::Base < CollectionDelegator
 
 
   def limited_collection
-    collection
+    @limited_collection ||= collection
       .limit(per_page)
       .offset((page-1) * per_page)
   end
 
+  include Enumerable
+
   def each &block
-    limited_collection.each &block
+    limited_collection.each(&block)
   end
 
   delegate :inspect, to: :limited_collection
 
+  def reverse
+    reversed = limited_collection.reverse
+    @limited_collection.clear.concat(reversed)
+    
+    self
+  end
 
 
   def pages
@@ -62,73 +72,33 @@ class RKit::Pagination::Base < CollectionDelegator
 
   RKit::Decoration::Dsl.domain self
   acts_as_decorables do
+    after_initialize do
+      # TODO: I need this definition here
+      # Otherwise, the base definition in enumerable_extend is found first
 
-    include Enumerable
-
-    def each &block
-      limited_collection.decorate.each &block
+      define_singleton_method :paginated?, ->{ true }
     end
 
 
-    def pagination_tag
-      view.content_tag :nav, class: :pagination do
-        [previous_page_tag, pages_tag, next_page_tag].reduce(:safe_concat)
+    depend on: :pages do
+      def pagination_tag
+        view.content_tag :nav, class: :pagination do
+          [previous_page_tag, pages_tag, next_page_tag].reduce(:safe_concat)
+        end
       end
-    end
 
-    def previous_page_tag
-      previous_page.decorate.page_tag "<"
-    end
+      def previous_page_tag
+        previous_page.decorate.page_tag "<"
+      end
 
-    def pages_tag
-      pages.map(&:decorate).map(&:page_tag).reduce(:safe_concat)
-    end
+      def pages_tag
+        pages.map(&:decorate).map(&:page_tag).reduce(:safe_concat)
+      end
 
-    def next_page_tag
-      next_page.decorate.page_tag ">"
+      def next_page_tag
+        next_page.decorate.page_tag ">"
+      end
     end
   end
 
-
-
-
-  # TODO: limited_collection, total_pages & pages can change, based on scopes or "page & per_page" config
-  # So we need a "@loaded" instance_variable
-  # that will have the same role as in AR::Relation
-  # -> either, can't scope if loaded
-  # -> either, empty the 3 "based on scope/config" variables
-  # --
-  # or, we don't memoize the 3 problematic vars
-  # wich will be my choice right now
-
-
-
-
-  # I need
-  # collection, records/instances/results/paginated_collection/limited_collection(as we use SQL 'limit')
-  # current page, total nb items, total pages
-
-  # calling could be : Articles.paginate(page: 2, per_page: 15).published
-  # note that published is _after_, but we still want to display 15 records
-  # Alternative call Articles.paginate.page(2).per_page(15)
-  # --
-  # the "per_page" will be settable either by an arg in the method,
-  # or by an option, per model, in the dsl (access by Article.all.instance_variable_get "@klass")
-  # or in the "pagination" config
-  # the "current page" will be 1 by default
-
-  # Raise an error if the collection has a "limit" or an "offset" (before or after pagination initialization)
-  # here is the pagination method scope : Paginator::Collection.new(scoped).limit(per).offset((page-1) * per)
-
-
-  # We also need a method "pagination_tag", in the view
-  # maybe use a decorator to do so.
-
-  # Define an option to use pagination based on instance, in this case, the "per_page" is set to one
-  # and the "pagination_tag" accept a block to display the "page number"
-
-
-  # Idea, the "current_page" info (to disable the current page link) could be an instance of a class (pagination::Page)
-  # so in that class, (or in her decorator), we could define the "link_to_page" method
-  # (and the "disabled_link_to", wich we will alias on self)
 end

data/lib/r_kit/pagination/dsl.rb

@@ -5,11 +5,21 @@ module RKit::Pagination::Dsl
   method :acts_as_paginables
   domain ActiveRecord::Base
 
+  params ->(per_page: nil){}
+
   methods :class do
 
+    # TODO: to move in 'before_acts_as_paginables' callback, once this is available in 'dsl'
+    if pagination_dsl.params.per_page
+      RKit::Pagination.config.per_page[self] = pagination_dsl.params.per_page
+    end
+
+
     def paginate page: nil, per_page: nil
       RKit::Pagination::Base.new(all, page: page, per_page: per_page)
     end
 
+    def paginated?() false end
+
   end
 end

data/lib/r_kit/pagination/enumerable_extend.rb

@@ -0,0 +1,7 @@
+module Enumerable
+
+  # TODO: paginate method
+
+  def paginated?() false end
+
+end