r_kit 0.5 → 1.0

data/lib/r_kit/grid/base/grid.rb

@@ -1,31 +1,81 @@
-class RKit::Grid::Base
-  class Grid < self
-    attr_accessor :collection
+class Grid < RKit::Grid::Base
 
-    def initialize collection, &block
-      @collection = collection
+  def self.try_convert object, &block
+    if object.kind_of? RKit::Grid::Base
+      object
 
-      @_binding = RKit::Grid::Binding.new
-      @_binding.block = block
+    elsif object.respond_to? :to_grid
+      object.to_grid &block
 
-      super @_binding
+    else
+      RKit::Grid::Base::Grid.new Array.wrap(object), &block
     end
+  end
+
+
+  attr_accessor :collection
+
+  def initialize collection, &block
+    @collection = collection
+
+    @_binding = RKit::Grid::Binding.new
+    @_binding.block = block
+
+    super @_binding
+  end
 
-    def required_bindings
-      {
-        col_size: RKit::Grid.config.col_size,
-        attributes: {
-          class: :grid
-        }
+  def required_bindings
+    # TODO: change config to min-col-size
+    # TODO: col size adapts to collection size, but not below min-col-size
+    {
+      col_size: RKit::Grid.config.col_size,
+      attributes: {
+        class: :grid
       }
-    end
+    }
+  end
+
 
-    def _attributes
-      _binding.attributes
+  class << self
+    def binding_accessor name
+      define_method name do |value, &block|
+        _binding.block = block if block
+        _binding.send "#{ name }=", value
+
+        self
+      end
     end
+  end
+
+  binding_accessor :col_size
+  binding_accessor :attributes
+  binding_accessor :col_attributes
 
-    def capture
-      GridRow.new(collection, binding: _binding).to_s
+
+
+  def flex &block
+    attributes class: 'grid-flex', &block
+  end
+
+  def items value, &block
+    attributes class: "grid-items-#{ value }", &block
+  end
+
+
+
+  def _tag
+    :div
+  end
+
+  def _attributes
+    _binding.attributes
+  end
+
+  def capture
+    collection.map do |object|
+      GridCol.new(object, binding: _binding).to_s
     end
+    .reduce(:safe_concat)
   end
+
 end

data/lib/r_kit/grid/base/grid_col.rb

@@ -1,26 +1,29 @@
-class RKit::Grid::Base
-  class GridCol < self
-    attr_accessor :object
+class GridCol < RKit::Grid::Base
+  attr_accessor :object
 
-    def initialize object, binding:;
-      @object = object
-      super binding
-    end
+  def initialize object, binding:;
+    @object = object
+    super binding
+  end
 
-    def required_bindings
-      {
-        col_attributes: {
-          class: ->{ :"grid-col-#{ _binding.col_size }" }
-        }
+  def required_bindings
+    {
+      col_attributes: {
+        class: proc{ :"grid-col-#{ _binding.col_size }" }.call
       }
-    end
+    }
+  end
+
 
-    def _attributes
-      _binding.col_attributes object
-    end
+  def _tag
+    _binding.col_attributes(object)["tag"] || :div
+  end
+
+  def _attributes
+    _binding.col_attributes(object).except("tag")
+  end
 
-    def capture
-      _binding.capture object
-    end
+  def capture
+    _binding.capture object
   end
 end

data/lib/r_kit/grid/base.rb

@@ -20,21 +20,7 @@ class RKit::Grid::Base
   end
 
 
-  class << self
-    def binding_accessor name
-      define_method name do |value, &block|
-        _binding.block = block if block
-        _binding.send "#{ name }=", value
-
-        self
-      end
-    end
-  end
 
-  binding_accessor :col_size
-  binding_accessor :attributes
-  binding_accessor :row_attributes
-  binding_accessor :col_attributes
 
 
   def capture
@@ -42,7 +28,7 @@ class RKit::Grid::Base
   end
 
   def to_s
-    _h.content_tag :div, _attributes, &method(:capture)
+    _h.content_tag _tag, _attributes, &method(:capture)
   end
 
 end

data/lib/r_kit/grid/binding.rb

@@ -22,9 +22,6 @@ class RKit::Grid::Binding
   delegate :attributes=, :attributes,
     to: :@attributes
 
-  delegate :attributes=, :attributes,
-    to: :@row_attributes, prefix: :row
-
   delegate :attributes=, :attributes,
     to: :@col_attributes, prefix: :col
 
@@ -56,7 +53,7 @@ class RKit::Grid::Binding
     # TODO: Tha last one can be replaced (or duplicated) by a "respond_to?" automatically triggered from here
     def attributes= attributes
       @attributes.merge!(attributes) do |key, old_value, new_value|
-        Array.wrap(old_value) + Array.wrap(new_value)
+        Array.wrap(old_value) | Array.wrap(new_value)
       end
     end
 
@@ -72,15 +69,11 @@ class RKit::Grid::Binding
     def process value, object = nil
       case value
       when Proc
-        proc_value = case value.arity
-        when 1 then value.call(object)
-        else value.call
-        end
-        process(proc_value, object)
+        process(value.call(object), object)
       when Array
         value.map{ |unique_value| process(unique_value, object) }.join(' ')
       when String, Symbol
-        value.to_s.dasherize
+        value.dasherize
       else
         raise ArgumentError, 'Must be Array, Proc or String/Symbol'
       end

data/lib/r_kit/grid/lib/assets/stylesheets/r_kit/base/grid.scss

@@ -1,26 +1,23 @@
 .grid {
   margin: auto;
-  width: $base_width * 94;
+  width: $base_width * 96;
 
-  .grid-row {
-    display: flex;
-    flex-wrap: wrap;
-    align-items: baseline;
+  display: flex;
+  flex-wrap: wrap;
+  align-items: baseline;
 
-    margin: 0 -#{$base_width};
-
-    @for $col_size from 1 through 12 {
-      .grid-col-#{ $col_size } {
-        margin: 0 $base_width;
-        width: $base_width * (8 * $col_size - 2);
-        flex-shrink: 0;
-      }
+  @for $col_size from 1 through 12 {
+    .grid-col-#{ $col_size } {
+      padding: 0 $base_width;
+      width: $base_width * 8 * $col_size;
+      box-sizing: border-box;
+      flex-shrink: 0;
+    }
 
-      @for $off_size from 1 through 12-$col_size {
-        .grid-col-#{ $col_size }-off-#{ $off_size } {
-          @extend .grid-col-#{ $col_size };
-          margin-left: $base_width * (8 * $off_size + 1);
-        }
+    @for $off_size from 1 through 12-$col_size {
+      .grid-col-#{ $col_size }-off-#{ $off_size } {
+        @extend .grid-col-#{ $col_size };
+        margin-left: $base_width * (8 * $off_size + 1);
       }
     }
   }

data/lib/r_kit/grid/lib/assets/stylesheets/r_kit/base/grid_flex.scss

@@ -0,0 +1,19 @@
+.grid.grid-flex{
+  margin: 0;
+  width: auto;
+  min-width: $base_width * 96;
+
+  @for $col_size from 1 through 12 {
+    .grid-col-#{ $col_size } {
+      width: $col_size * 100 / 12#{'%'};
+      min-width: $base_width * 8 * $col_size;
+    }
+
+    @for $off_size from 1 through 12-$col_size {
+      .grid-col-#{ $col_size }-off-#{ $off_size } {
+        @extend .grid-col-#{ $col_size };
+        margin-left: $off_size * 100 / 12#{'%'};
+      }
+    }
+  }
+}

data/lib/r_kit/grid/lib/assets/stylesheets/r_kit/base/grid_items.scss

@@ -0,0 +1,5 @@
+@each $align in flex-start flex-end center baseline stretch {
+  .grid.grid-items-#{ $align } {
+    align-items: $align;
+  }
+}

data/lib/r_kit/grid/lib/assets/stylesheets/r_kit/grid.scss

@@ -1,5 +1,7 @@
 @import "variables/grid";
 @import "base/grid";
+@import "base/grid_flex";
+@import "base/grid_items";
 
 
 

data/lib/r_kit/grid.rb

@@ -7,19 +7,18 @@ class RKit::Grid
     'base',
     'base/grid',
     'base/grid_col',
-    'base/grid_row',
     'binding'
 
   load_path __FILE__, 'enumerable_extend', if: :enumerable_extend
-  load_path __FILE__, 'kernel_extend', if: :kernel_extend
 
 
   config :extends, true
   alias_config :enumerable_extend, :extends
-  alias_config :kernel_extend, :extends
 
 
   config :base_width, [0.75, ['rem']]
   config :col_size, 3
 
+  alias_config :grid_base_width, :base_width
+
 end

data/lib/r_kit/override/base.rb

@@ -0,0 +1,125 @@
+class RKit::Override::Base
+
+  def self.override *args
+    new(*args).override
+  end
+
+
+  attr_accessor :method_name, :method, :pattern, :receiver
+
+  def initialize method_name, method:, pattern:, pattern_args:, receiver:;
+    @method_name = method_name
+    @method = method
+    @pattern = RKit::Override::Pattern.build(pattern, *pattern_args)
+    @receiver = receiver
+  end
+
+  def override
+    override_method
+    # TODO: hook_method
+  end
+
+
+  module Nodef
+
+    def self.__nodef__ method_name
+      define_method :__olddef__ do |*args, &block|
+
+        if respond_to?(:__getobj__) && __getobj__.respond_to?(method_name)
+          __getobj__.send(method_name, *args, &block)
+
+        else
+          owner = self.class.instance_method(method_name).owner
+          __newdef__ = owner.instance_method(method_name)
+          owner.send :remove_method, method_name
+
+          closure = if respond_to?(method_name)
+            send(method_name, *args, &block)
+          end
+
+          owner.send(:define_method, method_name, __newdef__)
+          closure
+        end
+      end
+
+      instance_method :__olddef__
+    end
+
+  end
+
+
+  def __olddef__
+    __olddef__ = receiver.instance_method(method_name)
+
+    proc do |*args, &block|
+      __olddef__.bind(self).call(*args, &block)
+    end
+  rescue NameError
+    Nodef.__nodef__(method_name)
+  end
+
+  def __newdef__
+    method
+  end
+
+
+
+
+
+
+
+
+  protected def override_method
+    oneself = self
+    # override_binding = Module.new{
+    #   define_method :__olddef__, oneself.__olddef__
+    #   define_method :__newdef__, oneself.__newdef__
+    #   define_method :override, oneself.pattern
+    # }
+
+    old_m = oneself.__olddef__
+    new_m = oneself.__newdef__
+    ove_m = oneself.pattern
+
+    override_binding = proc{
+      define_method :__olddef__, old_m
+      define_method :__newdef__, new_m
+      define_method :override, ove_m
+    }
+
+    # forget_binding = proc{
+    #     remove_method :__olddef__
+    #     remove_method :__newdef__
+    #     remove_method :override
+    #   }
+
+
+    receiver.send :define_method, method_name do |*args, &block|
+
+      #p self.singleton_class.included_modules
+      #p
+
+#      self.extend override_binding #unless self.singleton_class.include?(override_binding)
+#  p "add"
+
+
+
+      (class << self; self; end).instance_eval &override_binding
+
+
+      closure = self.override *args, &block
+      #closure = instance_eval(&ove_m)
+
+
+#      p "delete"
+#      (class << self; self; end).class_eval &forget_binding rescue nil
+       closure
+
+    end
+  end
+
+  protected def override_hook
+
+  end
+
+end

data/lib/r_kit/override/method_extend.rb

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

data/lib/r_kit/override/module_extend.rb

@@ -0,0 +1,53 @@
+class Module
+
+  protected def override_method method_name, method: nil, pattern: :standard, pattern_args: [], &block
+
+    RKit::Override::Base.override method_name,
+      method: (method || block),
+      pattern: pattern,
+      pattern_args: pattern_args,
+      receiver: self
+
+  end
+
+  protected def override_methods **options, &block
+
+    carrier = Module.new(&block)
+
+    carrier.instance_methods(false).each do |method_name|
+      override_method method_name, method: carrier.instance_method(method_name), **options
+    end
+
+    carrier.methods(false).each do |method_name|
+      singleton_carrier ||= Module.new{ include refine(carrier.singleton_class){} }
+      override_singleton_method method_name, method: singleton_carrier.instance_method(method_name), **options
+    end
+  end
+
+
+
+  protected def override_singleton_method *args, &block
+    singleton_class.override_method *args, &block
+  end
+
+  protected def override_singleton_methods *args, &block
+    singleton_class.override_methods *args, &block
+  end
+
+
+
+  protected def depend *args, strict: true, **options, &block
+    override_methods pattern: (strict && :depend || :if), pattern_args: (args << options), &block
+  end
+
+
+
+  protected def simple_override_method method_name, &block
+    instance_method(method_name).simple_override receiver: self, &block
+  end
+
+  protected def simple_override_singleton_method method_name, &block
+    method(method_name).simple_override &block
+  end
+
+end

data/lib/r_kit/override/pattern.rb

@@ -0,0 +1,53 @@
+class RKit::Override::Pattern
+
+  def self.build *args
+    new(*args).build
+  end
+
+
+  attr_accessor :pattern, :args
+
+  def initialize pattern, *args
+    @pattern = pattern
+    @args = args
+  end
+
+  def build
+    send "build_from_#{ pattern.class.name.underscore }"
+  end
+
+
+  protected def build_from_proc
+    pattern
+  end
+
+  protected def build_from_string
+    self.class.const_get("#{ pattern.upcase }_PATTERN").call(*args)
+  end
+  alias :build_from_symbol :build_from_string
+
+
+  STANDARD_PATTERN = -> *_ do
+    ->(*args, &block){ __newdef__(*args, &block) }
+  end
+
+  DEPEND_PATTERN = -> on: do
+    -> *args, &block do
+      if send(on).present?
+        __newdef__(*args, &block)
+      else
+        nil
+      end
+    end
+  end
+
+  IF_PATTERN = -> on: do
+    -> *args, &block do
+      if send(on).present?
+        __newdef__(*args, &block)
+      else
+        __olddef__(*args, &block)
+      end
+    end
+  end
+end

data/lib/r_kit/override/perfs.rb

@@ -0,0 +1,117 @@
+
+# Perfs
+n = 10_000
+t = Time.now
+n.times {
+  c = Class.new{
+    def a() "a" end
+
+    alias :__olddef__a :a
+    def a
+      __olddef__a << "b"
+    end
+
+    def x() "x" end
+
+    alias :__olddef__x :x
+    def x
+      __olddef__x << "y"
+    end
+  }
+}
+p "#{Time.now - t} : perf (x#{n}) - old school using alias"
+
+t = Time.now
+n.times {
+  c = Class.new{
+    def a() "a" end
+
+    override_method :a do
+      __olddef__ << "b"
+    end
+
+    def x() "x" end
+
+    override_method :x do
+      __olddef__ << "y"
+    end
+  }
+}
+p "#{Time.now - t} : perf (x#{n}) - override single method (~11x)"
+
+t = Time.now
+n.times {
+  c = Class.new{
+    def a() "a" end
+    def x() "x" end
+
+    override_methods do
+      def a
+        __olddef__ << "b"
+      end
+
+      def x
+        __olddef__ << "y"
+      end
+    end
+  }
+}
+p "#{Time.now - t} : perf (x#{n}) - override multiple methods (~11x)"
+
+p "-"
+c_basic = Class.new{
+  def initialize
+    @a = "a"
+    @x = "x"
+  end
+
+  def a() @a end
+
+  alias :__olddef__a :a
+  def a
+    __olddef__a << "b"
+  end
+
+  def x() @x end
+
+  alias :__olddef__x :x
+  def x
+    __olddef__x << "y"
+  end
+}
+c_over = Class.new{
+  def initialize
+    @a = "a"
+    @x = "x"
+  end
+
+  def a() @a end
+  def x() @x end
+
+  override_methods do
+    def a
+      __olddef__ << "b"
+    end
+
+    def x
+      __olddef__ << "y"
+    end
+  end
+}
+i_basic = c_basic.new
+i_over = c_over.new
+
+n = 100_000
+t = Time.now
+n.times {
+  i_basic.a
+  i_basic.x
+}
+p "#{Time.now - t} : perf (x#{n}) - old school method call"
+
+t = Time.now
+n.times {
+  i_over.a
+  i_over.x
+}
+p "#{Time.now - t} : perf (x#{n}) - override method call (~19x)"