passionview 0.0.0 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 198292d40879ce152a51845f39b1b24cf0de7928
-  data.tar.gz: df7b16a75fe46dcc31754674f5126778f9a7b0e7
+  metadata.gz: 5b45e27b2a47a1f99c639a07dc1a6fc5fddc4bb9
+  data.tar.gz: 2fbdbbd3d7571d6f854de5c383ada31c25e00694
 SHA512:
-  metadata.gz: 245fbde1b9905df338159bd0f2863c686cacfc50e3d31f89944ebf9036492a347dc4b8c199cdbb377118119e72b8d121f0611cf329ff7bc362469d5340863276
-  data.tar.gz: 43a2a09cc005d3648171a98500d4d973e52e3f473a16dbf40fc0217e0f51bd9d82214c3dfff0aa06eaabdc2d4f5aa91c7571e1dba689530a4b138333741c5654
+  metadata.gz: 16d514d7f8221eea35a6963bd4671995fafacc8ca6f60a6a17acf9f0a9ec2148be78e3c14a02ef920ff7e3918bd9fffeb663e176106398f928d37b10bd0b4256
+  data.tar.gz: 53656135764c204ffed1202df61a3ec91b234d52fb0aaf2ae30fed0530e5d0faf23318e818e9c4d7db73a374a4596980f4acc948116e880104f8763995f36953

data/lib/passion_view/actionable.rb

@@ -0,0 +1,61 @@
+module PassionView::Actionable
+  extend ActiveSupport::Concern
+
+  # well : menu en bas de page
+  # menu : menu sur l'entite
+  # nav : menu de navigation
+  # item : menu dans une liste
+  CONTEXTS = [:well, :menu, :nav, :item].freeze
+  TYPES = [:nav, :action].freeze
+
+  class Action
+    KEYS = [
+      :name, :icon, :path,
+      :type, :context, :priority,
+      :options
+    ].freeze
+
+    attr_accessor(*KEYS)
+
+    def initialize(attributes)
+      attributes.each do |key, value|
+        raise unless respond_to?(key)
+        send("#{key}=", value)
+      end
+    end
+
+    def [](key)
+      return unless KEYS.include?(key)
+
+      send(key)
+    end
+  end
+
+  class ActionList < Array
+    def context(context)
+      select do |a|
+        case a.context
+        when Symbol
+          a.context == context
+        when Array
+          a.context.include?(context)
+        end
+      end
+    end
+
+    def type(type)
+      select do |a|
+        case a.type
+        when Symbol
+          a.type == type
+        when Array
+          a.type.include?(type)
+        end
+      end
+    end
+  end
+
+  module ClassMethods
+    def action(name, path = nil, icon: nil); end
+  end
+end

data/lib/passion_view/authorization.rb

@@ -0,0 +1,8 @@
+# Authorization manages context necessary for auth
+module PassionView::Authorization
+  attr_accessor :user
+
+  def contextualize_auth(user)
+    self.user = user
+  end
+end

data/lib/passion_view/card/base.rb

@@ -0,0 +1,20 @@
+class PassionView::Card::Base < PassionView::ViewModel::Base
+  include PassionView::Routable
+  include PassionView::Actionable
+  include PassionView::Resourceful
+  include PassionView::Authorization
+
+  def to_key
+    [resource.id]
+  end
+
+  def to_model
+    resource
+  end
+
+  delegate :to_param, to: :resource
+
+  def self.i18n_scope
+    :cards
+  end
+end

data/lib/passion_view/card/collection.rb

@@ -0,0 +1,9 @@
+module PassionView::Card::Collection
+  extend ActiveSupport::Concern
+
+  include PassionView::ViewModel::List
+
+  def initialize(objects, options = {})
+    super(objects, options)
+  end
+end

data/lib/passion_view/card.rb

@@ -0,0 +1,4 @@
+module PassionView::Card; end
+
+require_relative 'card/base'
+require_relative 'card/collection'

data/lib/passion_view/filter/base.rb

@@ -0,0 +1,13 @@
+class PassionView::Filter::Base < PassionView::ViewModel::Base
+  def initialize(name, options = {})
+    super
+    @name = name
+    @value = options[:value]
+  end
+
+  def skip?
+    value.blank?
+  end
+
+  attr_reader :name, :value
+end

data/lib/passion_view/filter/simple_filter.rb

@@ -0,0 +1,14 @@
+class PassionView::Filter::SimpleFilter < PassionView::Filter::Base
+  def initialize(name, field:, value: [])
+    super
+    @field = field
+  end
+
+  def apply(items)
+    items.where(field => value)
+  end
+
+  private
+
+  attr_reader :field
+end

data/lib/passion_view/filter.rb

@@ -0,0 +1,4 @@
+module PassionView::Filter; end
+
+require_relative 'filter/base'
+require_relative 'filter/simple_filter'

data/lib/passion_view/filterable.rb

@@ -0,0 +1,56 @@
+module PassionView::Filterable
+  extend ActiveSupport::Concern
+
+  def initialize(items, options = {})
+    super
+    filters = options.delete(:filters) || {}
+
+    filter_with(filters)
+  end
+
+  def items
+    filters.reduce(super) { |items, filter| filter.skip? ? items : filter.apply(items) }
+  end
+
+  private
+
+  def url_options
+    super.merge(filterable_params)
+  end
+
+  def filterable_params
+    filters.each.with_object({}) { |filter, params| params[filter.name] = filter.value unless filter.skip? }
+  end
+
+  def filter_with(_)
+    @filters ||= []
+  end
+
+  attr_reader :filters
+
+  module Controller
+    extend ActiveSupport::Concern
+
+    def filter_params
+      action = params[:action]&.to_sym
+
+      raise "Unfilterable action: #{action.inspect}" unless self.class.filter?(action)
+
+      params[:filters]&.to_unsafe_h || {}
+    end
+
+    module ClassMethods
+      def filter(*actions)
+        filtered_actions.push(*actions)
+      end
+
+      def filter?(action)
+        filtered_actions.include?(action)
+      end
+
+      def filtered_actions
+        @filtered_actions ||= []
+      end
+    end
+  end
+end

data/lib/passion_view/form/base.rb

@@ -0,0 +1,134 @@
+class PassionView::Form::Base < PassionView::ViewModel::Base
+  include ActiveModel::Conversion
+  include ActiveModel::Validations
+
+  Delegation = Struct.new(
+    :to,
+    :prefix,
+    :methods,
+    :cast,
+    :accessor,
+  )
+
+  def persisted?
+    false
+  end
+
+  def valid?
+    [super].concat(self.class.delegations(inherited: true).map do |delegation|
+      item = instance_eval("self.#{delegation.to} rescue nil")
+      next if item.nil?
+      result = item.respond_to?(:valid?) ? item.valid? : true
+
+      # TODO: tester les validations des models
+      #       du type "validates :qqch(sans _id), presence: true"
+      if item.respond_to?(:errors)
+        item.errors.messages.each do |method, messages|
+          messages.each do |message|
+            errors.add(:"#{delegation.prefix}#{method}", message) unless errors[:"#{delegation.prefix}#{method}"].include?(message)
+          end if item.methods.include?(method)
+        end
+      end
+
+      result
+    end).compact.reduce(:&)
+  end
+
+  def assign_attributes(new_attributes)
+    Rails.logger.debug("Permitting parameters: #{permitted_params.map(&:inspect).join(', ')}")
+    new_attributes.permit(*permitted_params)
+
+    new_attributes.each do |k, v|
+      send("#{k}=", v) if respond_to?("#{k}=")
+    end
+  end
+
+  def update_attributes(new_attributes)
+    assign_attributes(new_attributes)
+    valid? && save
+  end
+
+  def permitted_params
+    self.class.permitted_params
+  end
+
+  class << self
+    def permit(*methods)
+      permitted_params.concat(methods)
+    end
+
+    def delegate(*methods)
+      options = methods.pop
+      unless options.is_a?(Hash) && (to = options[:to])
+        raise ArgumentError, 'Delegation needs a target'
+      end
+
+      prefix, = options.values_at(:prefix, :allow_nil)
+      cast = options[:cast]
+      writer = options[:accessor] || !cast.nil?
+
+      method_prefix = "#{prefix == true ? to : prefix}_" if prefix
+
+      delegations << Delegation.new(
+        to,
+        method_prefix,
+        methods,
+        cast,
+        writer,
+      )
+
+      caster = caster_for(cast)
+
+      raise ArgumentError, ':errors not allowed' if methods.include?(:errors)
+
+      methods.each do |method|
+        permit("#{method_prefix}#{method}")
+      end if writer
+      methods += methods.map { |method| "#{method}=" } if writer
+
+      methods.each do |method|
+        if method =~ /[^\]]=$/
+          define_method("#{method_prefix}#{method}") do |arg|
+            instance_variable_set("@#{method_prefix}#{method.gsub(/=$/, '')}_before_type_cast", arg)
+            arg = caster.call(arg) unless caster.nil?
+            instance_eval("self.#{to}").send(method, arg)
+          end
+
+          define_method("#{method_prefix}#{method.to_s.gsub(/=$/, '')}_before_type_cast") do
+            instance_variable_get("@#{method_prefix}#{method.gsub(/=$/, '')}_before_type_cast") || send("#{method_prefix}#{method.gsub(/=$/, '')}")
+          end
+        else
+          define_method("#{method_prefix}#{method}") do |*args, &block|
+            instance_eval("self.#{to}").try(:send, method, *args, &block)
+          end
+        end
+      end
+    end
+
+    def delegations(inherited: false)
+      @delegations ||= []
+      return @delegations unless inherited && superclass.respond_to?(:delegations)
+      @delegations + superclass.delegations(inherited: true)
+    end
+
+    def permitted_params
+      @permitted_params ||= []
+    end
+
+    private
+
+    def caster_for(cast_type)
+      case cast_type
+      when :date     then ->(v) { Date.parse(v) if v =~ /\A\d\d\d\d-\d\d-\d\d\z/ }
+      when :datetime then ->(v) { Time.zone.parse(v) if v =~ /\A\d\d\d\d-\d\d-\d\d \d\d:\d\d\z/ }
+      when :boolean  then ->(v) { (%w(1 true yes) + %w(0 false no)).include?(v) ? %w(1 true yes).include?(v) : nil }
+      when :integer  then ->(v) { v.to_i if v =~ /\A[-+]?\d+\z/ }
+      when :float    then ->(v) { v.to_f if v =~ /\A[-+]?\d+(?:\.\d+|)\z/ }
+      when :decimal  then ->(v) { BigDecimal.new(v) if v =~ /\A[-+]?\d+(?:\.\d+|)\z/ }
+      when :blank    then nil
+      when Proc      then cast_type
+      else                ->(v) { v unless v.blank? }
+      end
+    end
+  end
+end

data/lib/passion_view/form.rb

@@ -0,0 +1,3 @@
+module PassionView::Form; end
+
+require_relative 'form/base'

data/lib/passion_view/paginable.rb

@@ -0,0 +1,136 @@
+module PassionView::Paginable
+  extend ActiveSupport::Concern
+
+  include PassionView::Pathable
+
+  attr_accessor :current_page, :current_per
+
+  DEFAULT_PER_PAGE = 10
+
+  def initialize(items, options = {})
+    super
+    pagination = options.delete(:pagination) || {}
+
+    paginate_with(pagination[:page], pagination[:per])
+  end
+
+  def items
+    super.page(current_page)
+         .per(current_per)
+  end
+
+  def next_pages(count = 2, &block)
+    (-count..count).each do |idx|
+      target = current_page + idx
+      yield target, next_page_path(idx) if block_given? && !out_of_range?(target)
+    end
+  end
+
+  def first_page?(page = nil)
+    page ||= current_page
+    page.to_i == first_page
+  end
+
+  def last_page?(page = nil)
+    page ||= current_page
+    page.to_i == last_page
+  end
+
+  def current_page?(page)
+    page.to_i == current_page
+  end
+
+  def first_page
+    1
+  end
+
+  def previous_page
+    next_page(-1)
+  end
+
+  def next_page(shift = 1)
+    target = current_page + shift
+    target = first_page if target < first_page
+    target = last_page  if target > last_page
+
+    target
+  end
+
+  def last_page
+    [items.total_pages, 1].max
+  end
+
+  def out_of_range?(target)
+    (target < first_page) || (target > last_page)
+  end
+
+  def first_page_path
+    paginable_path(page: first_page)
+  end
+
+  def previous_page_path
+    paginable_path(page: previous_page)
+  end
+
+  def next_page_path(shift = 1)
+    paginable_path(page: next_page(shift))
+  end
+
+  def last_page_path
+    paginable_path(page: last_page)
+  end
+
+  def paginable_path(options)
+    page_path(url_options.merge(options))
+  end
+
+  def page_path(options = {})
+    resource_path(options)
+  end
+
+  def url_options
+    super.merge(paginable_params)
+  end
+
+  def paginable_params(page = nil, per = nil)
+    params = {}
+    page ||= current_page
+    per  ||= current_per
+
+    params[:page] = page unless page == first_page
+    params[:per]  = per  unless per.nil? || per == DEFAULT_PER_PAGE
+
+    params
+  end
+
+  def paginate_with(page, per = nil)
+    self.current_page = page.nil? ? 1 : page.to_i
+    self.current_per  = per.nil?  ? DEFAULT_PER_PAGE : per.to_i
+  end
+
+  module Controller
+    extend ActiveSupport::Concern
+
+    def pagination_params
+      action = params[:action]&.to_sym
+
+      raise "Unpaginable action: #{action.inspect}" unless self.class.paginate?(action)
+
+      params.permit(:page, :per).to_h
+    end
+
+    module ClassMethods
+      def paginate(*actions)
+        paginated_actions.push(*actions)
+      end
+
+      def paginate?(action)
+        paginated_actions.include?(action)
+      end
+
+      def paginated_actions
+        @paginated_actions ||= []
+      end
+    end
+  end
+end

data/lib/passion_view/pathable.rb

@@ -0,0 +1,5 @@
+module PassionView::Pathable
+  def url_options
+    @url_options ||= {}
+  end
+end

data/lib/passion_view/relation.rb

@@ -0,0 +1,58 @@
+module PassionView::Relation
+  # delegate :to_sql,
+  #          :offset_value,
+  #          :total_count,
+  #          :limit_value,
+  #          to: :scoped
+
+  def items
+    case (items = super)
+    when ActiveRecord::Relation
+      items
+    when ActiveRecord::Base
+      items.where(nil)
+    else
+      raise TypeError, "not an ActiveRecord object: #{items.class}"
+    end
+  end
+
+  def first
+    item_view_model(items.first)
+  end
+
+  def last
+    item_view_model(items.first)
+  end
+
+  def count
+    items.count
+  end
+
+  def size
+    items.size
+  end
+
+  def include?(obj)
+    items.include?(obj)
+  end
+
+  def empty?
+    items.empty?
+  end
+
+  def to_sql
+    items.to_sql
+  end
+
+  def offset_value
+    items.offset_value
+  end
+
+  def total_count
+    items.total_count
+  end
+
+  def limit_value
+    items.limit_value
+  end
+end

data/lib/passion_view/resourceful.rb

@@ -0,0 +1,34 @@
+# Resourceful makes an instance a resource in terms of Rails routing
+module PassionView::Resourceful
+  extend ActiveSupport::Concern
+
+  include PassionView::Routable
+
+  def initialize(resource, options = {})
+    super
+    @resource = resource
+    @parent_resource = options[:parent]
+  end
+
+  def resource_path(options = {})
+    routes.polymorphic_path(polymorphic_components, options)
+  end
+
+  private
+
+  def resource
+    @resource
+  end
+
+  def polymorphic_components
+    options[:polymorphic_path] || [@parent_resource, nested_resource_path].compact
+  end
+
+  def resource_class
+    @resource.klass #### @objects
+  end
+
+  def nested_resource_path
+    resource_class
+  end
+end

data/lib/passion_view/routable.rb

@@ -0,0 +1,42 @@
+# Routable exposes contextualized routes in an object
+module PassionView::Routable
+  extend ActiveSupport::Concern
+
+  def contextualize_routes(obj)
+    routes.contextualize(obj)
+  end
+
+  def routes
+    @_routes_context ||= Class.new do
+      include Rails.application.routes.url_helpers
+      include Rails.application.routes.mounted_helpers
+
+      def default_url_options
+        @_context ? @_context.default_url_options : {}
+      end
+
+      def _routes_context
+        self
+      end
+
+      def _with_routes(routes)
+        old_routes, @_routes = @_routes, routes
+        yield
+      ensure
+        @_routes = old_routes
+      end
+
+      def contextualized?
+        !@_context.nil?
+      end
+
+      def contextualize(obj)
+        @_context = obj
+      end
+
+      def without_context
+        self.class.new
+      end
+    end.new
+  end
+end

data/lib/passion_view/sortable.rb

@@ -0,0 +1,103 @@
+module PassionView::Sortable
+  extend ActiveSupport::Concern
+
+  include PassionView::Pathable
+
+  attr_accessor :sort_column, :sort_direction
+
+  def initialize(items, options = {})
+    super
+    sort = options.delete(:sort) || {}
+
+    sort_with(sort[:sort], sort[:direction])
+  end
+
+  def items
+    super.order(order_arel[sort_column].send(sort_direction))
+  end
+
+  def sort_columns_available
+    order_arel.keys
+  end
+
+  def sort_column_available?(name)
+    sort_columns_available.include?(name.to_s)
+  end
+
+  def sort_directions_available
+    %w(asc desc)
+  end
+
+  def default_sort_column
+    resource_class.primary_key
+  end
+
+  def default_sort_direction
+    sort_directions_available.first
+  end
+
+  def sort_by_path(column, direction = default_sort_direction)
+    sortable_path(sortable_params(column, direction))
+  end
+
+  def sortable_path(options)
+    resource_path(url_options.merge(options))
+  end
+
+  def url_options
+    super.merge(sortable_params)
+  end
+
+  def order_arel
+    table = resource_class.arel_table
+    pk = default_sort_column
+
+    { pk => table[pk.to_sym] }
+  end
+
+  def sortable_params(column = nil, direction = nil)
+    params = {}
+
+    column    ||= sort_column
+    direction ||= sort_direction
+
+    params[:sort]      = column
+    params[:direction] = direction
+
+    params
+  end
+
+  def sort_with(column, direction)
+    self.sort_column = column || default_sort_column
+    self.sort_column = default_sort_column unless sort_columns_available.include?(sort_column)
+
+    self.sort_direction = direction || default_sort_direction
+    self.sort_direction = default_sort_direction unless %w(asc desc).include?(sort_direction)
+  end
+
+  module Controller
+    extend ActiveSupport::Concern
+
+    def sort_params
+      action = params[:action]&.to_sym
+
+      raise "Unsortable action: #{action.inspect}" unless self.class.sort?(action)
+
+      params.permit(:sort, :direction).to_h
+    end
+
+    module ClassMethods
+      def sort(*actions)
+        sorted_actions.push(*actions)
+      end
+
+      def sort?(action)
+        sorted_actions.include?(action)
+      end
+
+      def sorted_actions
+        @sorted_actions ||= []
+      end
+    end
+  end
+end

data/lib/passion_view/view_model/base.rb

@@ -0,0 +1,20 @@
+class PassionView::ViewModel::Base
+  extend ActiveModel::Naming
+  extend ActiveModel::Translation
+
+  def initialize(_, options = {})
+    @options = options
+  end
+
+  def self.i18n_scope
+    :viewmodel
+  end
+
+  def self.lookup_ancestors
+    [self]
+  end
+
+  private
+
+  attr_reader :options
+end

data/lib/passion_view/view_model/list.rb

@@ -0,0 +1,28 @@
+# items: enumerable
+module PassionView::ViewModel::List
+  extend ActiveSupport::Concern
+  extend Enumerable
+
+  def initialize(items, options = {})
+    super
+    @items = items
+    @item_view_model_class = options[:item_view_model_class]
+  end
+
+  def each
+    return enum_for(:each) unless block_given?
+
+    items.each do |e|
+      yield item_view_model(e)
+    end
+  end
+
+  def item_view_model(item)
+    item_view_model_class.new(item)
+  end
+
+  private
+
+  attr_reader :items
+  attr_reader :item_view_model_class
+end

data/lib/passion_view/view_model.rb

@@ -0,0 +1,4 @@
+module PassionView::ViewModel; end
+
+require_relative 'view_model/base'
+require_relative 'view_model/list'

data/lib/passion_view.rb

@@ -0,0 +1,15 @@
+module PassionView; end
+
+require 'passion_view/pathable'
+require 'passion_view/routable'
+require 'passion_view/actionable'
+require 'passion_view/authorization'
+require 'passion_view/relation'
+require 'passion_view/resourceful'
+require 'passion_view/filterable'
+require 'passion_view/paginable'
+require 'passion_view/sortable'
+require 'passion_view/view_model'
+require 'passion_view/card'
+require 'passion_view/form'
+require 'passion_view/filter'

data/lib/passionview.rb

@@ -0,0 +1 @@
+require 'passion_view'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: passionview
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.0
 platform: ruby
 authors:
 - ADHOC-GTI
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-05-02 00:00:00.000000000 Z
+date: 2018-05-03 00:00:00.000000000 Z
 dependencies: []
 description: |2
         Get view logic out of persistence models and controllers and put it into
@@ -19,6 +19,27 @@ extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
+- lib/passion_view.rb
+- lib/passion_view/actionable.rb
+- lib/passion_view/authorization.rb
+- lib/passion_view/card.rb
+- lib/passion_view/card/base.rb
+- lib/passion_view/card/collection.rb
+- lib/passion_view/filter.rb
+- lib/passion_view/filter/base.rb
+- lib/passion_view/filter/simple_filter.rb
+- lib/passion_view/filterable.rb
+- lib/passion_view/form.rb
+- lib/passion_view/form/base.rb
+- lib/passion_view/paginable.rb
+- lib/passion_view/pathable.rb
+- lib/passion_view/relation.rb
+- lib/passion_view/resourceful.rb
+- lib/passion_view/routable.rb
+- lib/passion_view/sortable.rb
+- lib/passion_view/view_model.rb
+- lib/passion_view/view_model/base.rb
+- lib/passion_view/view_model/list.rb
 - lib/passionview.rb
 homepage: https://github.com/adhoc-gti/passionview
 licenses: