r_kit 0.4.2 → 0.4.3

data/lib/r_kit/css.rb

@@ -3,17 +3,24 @@ class RKit::Css
   with_engine __FILE__
   with_sprockets __FILE__
 
+  config :colors, :black, '#111'
+  config :colors, :dark_black, '#000'
+  config :colors, :grey, '#888'
+  config :colors, :light_black, '#181818'
+  config :colors, :red, '#b62b2b'
   config :colors, :white, '#fbfbfb'
 
-  config :colors, :primary_color, '#b62b2b'
-  config :colors, :text_color, '#888'
-  config :colors, :background_color, '#111'
-
+  alias_config :colors, :primary_color, :red
+  alias_config :colors, :text_color, :grey
+  alias_config :colors, :text_alt_color, :dark_black
+  alias_config :colors, :background_color, :black
+  alias_config :colors, :background_alt_color, :light_black
 
   alias_config :colors, :btn_color, :background_color
   alias_config :colors, :btn_background_color, :primary_color
+  alias_config :colors, :btn_disabled_color, :text_alt_color
+  alias_config :colors, :btn_disabled_background_color, :background_alt_color
 
-  alias_config :colors, :link_color, :primary_color
 
   # unused colors
   # config :colors, :secondary_color, 'cornflowerblue'

data/lib/r_kit/{decorator → decoration}/action_view_base_extend.rb

@@ -1,7 +1,7 @@
-module RKit::Decorator::ActionViewBaseExtend
+module RKit::Decoration::ActionViewBaseExtend
 
   def assign new_assigns
-    _decorate_assigns new_assigns if RKit::Decorator.config.auto_decoration
+    _decorate_assigns new_assigns if RKit::Decoration.config.auto_decoration
 
     super
   end

data/lib/r_kit/{decorator → decoration}/active_record_extend.rb

@@ -1,4 +1,5 @@
-module RKit::Decorator::ActiveRecordExtend
+module RKit::Decoration::ActiveRecordExtend
+
   attr_accessor :decorator_klass
 
   def acts_as_decorables base = nil, &block
@@ -9,6 +10,7 @@ module RKit::Decorator::ActiveRecordExtend
   # 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
 
 
@@ -21,14 +23,14 @@ module RKit::Decorator::ActiveRecordExtend
   end
 
   def decorator_klass_from_class base
-    if base <=> RKit::Decorator::Base
+    if base <=> RKit::Decoration::Base
       base
     else
       base.tap do |base|
-        base.send :include, Module.new{ include refine(RKit::Decorator::Base){} }
-        base.extend Module.new{ include refine(RKit::Decorator::Base.singleton_class){} }
-
-        RKit::Decorator::Base.inherited 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
@@ -38,16 +40,21 @@ module RKit::Decorator::ActiveRecordExtend
     const_name = mod.name.demodulize
 
     namespace.send :remove_const, const_name
-    namespace.const_set const_name, Class.new(RKit::Decorator::Base){ include mod }
+    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", Class.new(RKit::Decorator::Base, &block)
+      .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

data/lib/r_kit/decoration/base.rb

@@ -0,0 +1,35 @@
+require 'delegate'
+
+class RKit::Decoration::Base < SimpleDelegator
+
+  singleton_attr_reader :decorated_klass
+  singleton_attr_reader :after_initialize_procs, default: proc{ [] }
+
+  def self.after_initialize &block
+    after_initialize_procs << block
+  end
+
+  def initialize obj, view_context: nil
+    @_view_context = view_context
+    super obj
+
+    decorator_klass.after_initialize_procs.each{ |after_initialize_proc| self.instance_eval &after_initialize_proc }
+  end
+
+  alias :decorator_klass :class
+  delegate :class, to: :__getobj__
+
+
+  def _view_context
+    backtrace{ |obj| obj.is_a? ActionView::Base } || backtrace{ |obj| obj.respond_to? :view_context }.view_context
+  end
+
+  def view
+    @_view_context ||= _view_context
+  end
+
+
+  def === object
+    self == object || __getobj__ == object
+  end
+end

data/lib/r_kit/decoration/class.rb

@@ -0,0 +1,22 @@
+class RKit::Decoration::Class
+
+  module OpenClass
+    refine Class do
+      def new super_class = Object, **options, &block
+        super(super_class, &block).tap do |klass|
+          options.each{ |key, value| klass.instance_variable_set "@#{ key }", value }
+        end
+      end
+    end
+  end
+  using OpenClass
+
+  # TODO: improve this "new" method, in order to move the creation of the decoraor klass for ARextend to here
+  # ot should be able to accept a proc, a module, a class, or nil(autodetect)
+  # -- While doing so, U could move the logic of Class.to_module && Module.to_class && Proc.to_class in "utilities" (or new rkit service)
+  def self.new decorated_klass, &block
+    Class.new(RKit::Decoration::Base, decorated_klass: decorated_klass, &block).tap do |klass|
+      klass.class_eval{ alias :"#{ decorated_klass.demodulize.underscore }" :__getobj__ }
+    end
+  end
+end

data/lib/r_kit/decoration.rb

@@ -0,0 +1,19 @@
+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)
+  dependency :backtrace
+
+
+  load_path __FILE__, 'base.rb'
+  load_path __FILE__, 'class.rb'
+
+  load_path __FILE__, 'action_view_base_extend.rb'
+  load_path __FILE__, 'active_record_extend.rb'
+
+
+  config :auto_decoration, true
+end

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

@@ -0,0 +1,13 @@
+module RKit::Dsl::Base::LocalParams
+
+  def persisting_binding
+    @persiting_binding ||= binding
+  end
+
+  def method_missing method_name, *args, &block
+    persisting_binding.eval method_name.to_s
+  rescue
+    super
+  end
+
+end

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

@@ -0,0 +1,38 @@
+class RKit::Dsl::Base::Params
+  attr_reader :params, :params_lambda
+
+  def initialize params_lambda
+    raise NoLambdaError unless params_lambda.lambda?
+
+    @params_lambda = params_lambda
+    @params = Hash.new{ |hash, key| hash[key] = params_struct.new }
+  end
+
+
+  def try_parameters *args, &block
+    @params_lambda.call *args, &block
+  end
+
+  def extract_parameters base, *args, &block
+    @params[base] = params_struct.new @params_lambda.extract_parameters(*args, &block)
+  end
+
+
+  # TODO: extract local variables may be an independant service of rkit
+  def extract_local_variables base
+    base.singleton_class.send :prepend, RKit::Dsl::Base::LocalParams
+    base.persisting_binding.eval(
+      @params[base].to_hash.map{ |name, value| "#{ name }=#{ value.inspect }" }.join(";")
+    )
+  end
+
+
+  private def params_names
+    @params_names ||= @params_lambda.parameters.map{ |(_, name)| name }
+  end
+
+  private def params_struct
+    @params_struct ||= StrongStruct.new allowed: params_names
+  end
+
+end

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

@@ -0,0 +1,16 @@
+class RKit::Dsl::Base::Readonly < SimpleDelegator
+
+  def dsls
+    __getobj__.class.dsls
+  end
+
+  attr_accessor :base
+  getobj_attr_reader :name, :method, :domain, :params, :methods
+
+  alias :basic_params :params
+  delegate :try_parameters, :extract_parameters,
+    to: :basic_params
+
+  def params() basic_params.params[base] end
+  def extract_local_variables() basic_params.extract_local_variables(base) end
+end

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

@@ -0,0 +1,67 @@
+class RKit::Dsl::Base
+  module Thrust
+
+    protected def thrust_dsl!
+      readonly = self.readonly
+      name = @name
+
+      @domain.send :define_singleton_method, @name do
+        (instance_variable_get(name.ivar) ||
+          instance_variable_set(name.ivar, readonly))
+            .tap{ |readonly| readonly.base = self }
+      end
+    end
+
+    protected def thrust_dsl_interface!
+      name = @name
+
+      @domain.send :define_singleton_method, "can_#{ @method }?" do
+        instance_eval &send(name).methods[:allowance]
+      end
+
+      @domain.send :define_singleton_method, "#{ @method }?" do
+        send(name).dsls[name].include? self
+      end
+
+      @base.send :define_singleton_method, @method do
+        @@dsls[name]
+      end
+    end
+
+    protected def thrust_dsl_options!
+      name = @name
+
+      @domain.send :define_singleton_method, "#{ @name }_params=" do |*args, &block|
+        send(name).try_parameters(*args, &block)
+        send(name).extract_parameters self, *args, &block
+      end
+
+      @domain.send :define_singleton_method, "#{ @name }_params" do
+        instance_variable_get("@#{ name }_params") ||
+          instance_variable_set("@#{ name }_params", send(name).params)
+      end
+    end
+
+    protected def thrust_dsl_extend!
+      name = @name
+
+      @domain.send :define_singleton_method, "try_to_#{ @method }" do |*args, &block|
+        send "#{ name }_params=", *args, &block
+
+        if send "can_#{ send(name).method }?"
+          send(name).dsls[name] << self
+
+          instance_eval &send(name).methods[:class]
+          class_eval &send(name).methods[:instance]
+          decorator_klass.class_eval &send(name).methods[:decorator] if respond_to? :decorator_klass
+
+          true
+        end
+      end
+
+      @domain.send :define_singleton_method, @method do |*args, &block|
+        instance_eval &send(name).methods[:restriction] unless send "try_to_#{ send(name).method }", *args, &block
+      end
+    end
+  end
+end

data/lib/r_kit/dsl/base.rb

@@ -0,0 +1,68 @@
+class RKit::Dsl::Base
+
+  @@dsls = Hash.new{ |hash, key| hash[key] = Array.new }
+  def self.dsls
+    @@dsls
+  end
+
+  attr_accessor :base
+
+  def initialize base
+    @base = base
+    @methods = Hash.new{ |hash, key| hash[key] = proc{} }
+
+    @methods[:allowance] = proc{ true }
+    @methods[:restriction] = proc{ raise DslStandardError.new(self, method_name: __method__) }
+    # TODO: the __method__ return 'initialize', and not the "acts_as_..." that it shoul
+
+    @params = RKit::Dsl::Base::Params.new(->(){})
+  end
+
+
+  def name name
+    @name = name
+  end
+
+  def method method
+    @method = method
+  end
+
+
+  def domain domain
+    raise DslDefinitionError.new(@base) if [@name, @method].none?
+
+    @domain = domain
+
+    thrust_dsl!
+    thrust_dsl_interface!
+    thrust_dsl_options!
+    thrust_dsl_extend!
+  end
+
+
+  def params params_lambda
+    @params = RKit::Dsl::Base::Params.new(params_lambda)
+  end
+
+
+  def allowed? &block
+    methods :allowance, &block
+  end
+
+  def restricted &block
+    methods :restriction, &block
+  end
+
+  def methods context, &block
+    @methods[context] = block
+  end
+
+
+  include RKit::Dsl::Base::Thrust
+
+
+  protected def readonly
+    RKit::Dsl::Base::Readonly.new(self)
+  end
+
+end

data/lib/r_kit/dsl/dsl_definition_error.rb

@@ -0,0 +1,10 @@
+class DslDefinitionError < StandardError
+  def initialize base
+    # TODO: link to the doc
+    super %Q{
+DslDefinitionError: Wrong dsl definition order on `#{ base }',
+  you can't declare a `domain' unless you have previously declared a `name' AND a `method'
+  Please, visit XXX for more details
+    }
+  end
+end

data/lib/r_kit/dsl/dsl_extend.rb

@@ -0,0 +1,10 @@
+module RKit::Dsl::DslExtend
+
+  def self.extended subclass
+    subclass.instance_variable_set "@_dsl", RKit::Dsl::Base.new(subclass)
+  end
+
+  delegate :name, :method, :domain, :params, :methods, :allowed?, :restricted,
+    to: :@_dsl
+
+end

data/lib/r_kit/dsl/dsl_standard_error.rb

@@ -0,0 +1,9 @@
+class DslStandardError < StandardError
+  def initialize base, method_name:;
+    super %Q{
+DslStandardError: You tried to use the `#{ method_name }' DSL on `#{ base }',
+  Sadly, something went wrong, it seems that you can't use that DSL on your Class
+  Please, refer to the corresponding documentation
+    }
+  end
+end

data/lib/r_kit/dsl/module_extend.rb

@@ -0,0 +1,22 @@
+module RKit::Dsl::ModuleExtend
+
+  def act_as_a_dsl
+    extend RKit::Dsl::DslExtend
+  end
+
+
+  def acts_as *names
+    names.each do |name|
+      send "acts_as_#{ name }"
+    end
+  end
+
+  def try_to_acts_as *names
+    names.each do |name|
+      send "try_to_acts_as_#{ name }"
+    end
+  end
+
+
+  Module.send :include, self
+end

data/lib/r_kit/dsl/no_lambda_error.rb

@@ -0,0 +1,10 @@
+class NoLambdaError < StandardError
+  def initialize
+    # TODO: add a link to smthng that explain the difference between proc & lambda
+    # TODO: why not one of my videos ;)
+    super %Q{
+NoLambdaError: You need to use a lambda, not a proc
+  Use the fancy ruby2 `->(){}', or the good old `lambda{}' syntax
+    }
+  end
+end

data/lib/r_kit/dsl.rb

@@ -0,0 +1,21 @@
+class RKit::Dsl
+
+  dependency :struct
+
+  load_path __FILE__, 'base.rb'
+  load_path __FILE__, 'base/local_params.rb'
+  load_path __FILE__, 'base/params.rb'
+  load_path __FILE__, 'base/readonly.rb'
+  load_path __FILE__, 'base/thrust.rb', priority: 1
+
+  load_path __FILE__, 'dsl_definition_error.rb'
+  load_path __FILE__, 'dsl_standard_error.rb'
+  load_path __FILE__, 'no_lambda_error.rb'
+
+  load_path __FILE__, 'dsl_extend.rb'
+  load_path __FILE__, 'module_extend.rb'
+
+
+  load_path __FILE__, 'test.rb'
+
+end

data/lib/r_kit/pagination/active_record_extend.rb

@@ -0,0 +1,23 @@
+module RKit::Pagination::ActiveRecordExtend
+
+  # TODO: use rkit::dsl for this
+  # class X < RKit::Dsl::Base
+  #   for Y #this is the targeted class
+  #   name :act_as_xable
+  #   instance_interfere do; end #class methods
+  #   class_interfere do; end #instance_methods
+  #   decorator_interfere do; end #decorator_methods
+  #   can_interfere? do; #auth to load the dsl in a specific class
+  # end
+  # All of this is largely inspired by the work on ARutility
+
+  def acts_as_paginables
+    define_singleton_method "paginate", ->(page: nil, per_page: nil) do
+      RKit::Pagination::Base.new(all, page: page, per_page: per_page)
+    end
+  end
+
+  # we need to create a "paginate" scope, that will create a Pagination::base object
+
+  ActiveRecord::Base.extend self
+end

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

@@ -0,0 +1,53 @@
+class RKit::Pagination::Base::Page
+
+  attr_accessor :base, :page
+
+  def initialize base, page: page
+    @base = base
+    @page = page
+  end
+
+
+  extend RKit::Decoration::ActiveRecordExtend
+  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
+        alias :page_tag :disabled_link_to_page
+      end
+    end
+
+
+    def page_tag name = __getobj__.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
+    end
+
+    def disabled_link_to_page name = __getobj__.page
+      view.content_tag :span, name, class: :'btn-disabled'
+    end
+
+  end
+
+
+
+
+  # this need
+  # current_page
+
+  # and a decorator
+
+end