resource_renderer 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 14657a217dfa0b3161b7426718a6b93b0cc751cb
+  data.tar.gz: 449f911f3dff114495e7e7440b71f03c121235c5
+SHA512:
+  metadata.gz: e38924837f35761f15230232fde26fb51e8ca8a4e07436e4992b001efb0c7a67b6edac114a577ff55bfa233382925a74b768f4b9af07de4250f76f5c2ff301a1
+  data.tar.gz: e106380c0e971a26d5f591e24c36e5e4177765cc1434f3de8891b7e2e7aa26c189567df3d633b1dd2f0a991256b0c6c6c4abed44ea58a1d89c3f0bed3b08288c

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 Roberto Vasquez Angel
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,3 @@
+= ResourceRenderer
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,22 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ResourceRenderer'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path('../spec/dummy/Rakefile', __FILE__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+Bundler::GemHelper.install_tasks

data/app/attribute_renderers/acts_as_list_renderer.rb

@@ -0,0 +1,21 @@
+class ActsAsListRenderer < ResourceRenderer::AttributeRenderer::Base
+  def display(attribute_name, label, options = {}, &block)
+    options.reverse_merge!(scope: nil)
+
+    scope = options.delete(:scope)
+
+    scope = "#{scope}_id".intern if scope.is_a?(Symbol) && scope.to_s !~ /_id$/
+
+    data_attributes = {
+      'acts-as-list-item': true,
+      'acts-as-list-item-uid': model.to_param,
+      'acts-as-list-item-on-drop-target': h.url_for([:reposition, model])
+    }
+    data_attributes['acts-as-list-item-scope'] = "#{scope}-#{model.send(scope)}" if scope.present?
+
+
+    h.content_tag(:span, data: data_attributes, class: 'btn btn-xs btn-default acts-as-list-item') do
+      h.tag(:span, class: 'glyphicon glyphicon-sort')
+    end
+  end
+end

data/app/attribute_renderers/association_renderer.rb

@@ -0,0 +1,23 @@
+class AssociationRenderer < ResourceRenderer::AttributeRenderer::Base
+  def display(attribute_name, label, options = {}, &block)
+    options.reverse_merge!(label_method: :to_s)
+    label_method = options.delete(:label_method)
+
+    associated = value_for_attribute(attribute_name)
+
+    return if associated.nil?
+
+    url = options.delete(:url)
+    label = associated.send(label_method)
+
+    target = url.call(model) if url.is_a?(Proc)
+    target = url if url.is_a?(String)
+    target = associated if url.is_a?(TrueClass)
+
+    if target.nil?
+      label
+    else
+      h.link_to(label, target)
+    end
+  end
+end

data/app/attribute_renderers/attachment_renderer.rb

@@ -0,0 +1,11 @@
+class AttachmentRenderer < ResourceRenderer::AttributeRenderer::Base
+  def display(attribute_name, label, options = {}, &block)
+    options.reverse_merge!(format: :long)
+    format = options.delete(:format)
+    
+    h.link_to(value_for_attribute(attribute_name).url) do
+      h.tag(:span, class: 'btn btn-xs btn-primary btn-responsive') +
+      h.content_tag(:span, h.t(".download"), class: 'btn-text')
+    end
+  end
+end

data/app/attribute_renderers/big_decimal_renderer.rb

@@ -0,0 +1,2 @@
+class BigDecimalRenderer < ResourceRenderer::AttributeRenderer::Base
+end

data/app/attribute_renderers/boolean_renderer.rb

@@ -0,0 +1,7 @@
+class BooleanRenderer < ResourceRenderer::AttributeRenderer::Base
+  private
+
+  def value_for_attribute(attribute_name)
+    I18n.t("booleans.#{model.send(attribute_name).to_s}")
+  end
+end

data/app/attribute_renderers/date_renderer.rb

@@ -0,0 +1,8 @@
+class DateRenderer < ResourceRenderer::AttributeRenderer::Base
+  def display(attribute_name, label, options = {}, &block)
+    options.reverse_merge!(format: :long)
+    format = options.delete(:format)
+    
+    I18n.l(value_for_attribute(attribute_name), format: format)
+  end
+end

data/app/attribute_renderers/duration_renderer.rb

@@ -0,0 +1,47 @@
+class DurationRenderer < ResourceRenderer::AttributeRenderer::Base
+  def display(attribute_name, label, options = {}, &block)
+    return  h.capture { block.call(resource) } if block_given?
+
+    options.reverse_merge!(input_unit: :seconds)
+    input_unit = options.delete(:input_unit)
+
+    input_duration = value_for_attribute(attribute_name)
+    seconds = duration_in_seconds(input_duration, input_unit)
+
+    html_attributes = {
+
+    }
+
+    helper.capture do
+      h.content_tag(:span, html_attributes) { humanize(seconds) }
+    end
+  end
+
+  private
+
+  def duration_in_seconds(input_duration, input_unit)
+    case input_unit
+    when :seconds
+      input_duration
+    when :minutes
+      input_duration * 60
+    when :hours
+      input_duration * 3600
+    when :days
+      input_duration * 86400
+    when :weeks
+      input_duration * 604800
+    end
+  end
+
+  def humanize(seconds)
+    [[60, :seconds], [60, :minutes], [24, :hours], [1000, :days]].inject([]){ |s, (count, name)|
+      if seconds > 0
+        seconds, n = seconds.divmod(count)
+        translated_name = I18n.t("datetime.distance_in_words.x_#{name}", count: n.to_i)
+        s.unshift translated_name
+      end
+      s
+    }.join(' ')
+  end
+end

data/app/attribute_renderers/email_renderer.rb

@@ -0,0 +1,15 @@
+class EmailRenderer < ResourceRenderer::AttributeRenderer::Base
+  def display(attribute_name, label, options = {}, &block)
+    return h.capture { block.call(resource) } if block_given?
+    options.reverse_merge!(class: 'email')
+    html_class = options.delete(:class)
+
+    html_attributes = {
+      class: html_class
+    }
+
+    helper.capture do
+      h.content_tag(:div, html_attributes) { h.mail_to value_for_attribute(attribute_name) }
+    end
+  end
+end

data/app/attribute_renderers/false_class_renderer.rb

@@ -0,0 +1,2 @@
+class FalseClassRenderer < BooleanRenderer
+end

data/app/attribute_renderers/fixnum_renderer.rb

@@ -0,0 +1,2 @@
+class FixnumRenderer < ResourceRenderer::AttributeRenderer::Base
+end

data/app/attribute_renderers/image_renderer.rb

@@ -0,0 +1,8 @@
+class ImageRenderer < ResourceRenderer::AttributeRenderer::Base
+  def display(attribute_name, label, options = {}, &block)
+    options.reverse_merge!(format: :long)
+    format = options.delete(:format)
+    
+    h.image_tag(value_for_attribute(attribute_name).url, class: 'img-responsive')
+  end
+end

data/app/attribute_renderers/nil_class_renderer.rb

@@ -0,0 +1,5 @@
+class NilClassRenderer < ResourceRenderer::AttributeRenderer::Base
+  def display(field, label, options = {}, &block)
+    ''
+  end
+end

data/app/attribute_renderers/resource_renderer/attribute_renderer/base.rb

@@ -0,0 +1,28 @@
+module ResourceRenderer
+  module AttributeRenderer
+    class Base
+      attr_accessor :model, :helper
+      alias_method :h, :helper
+
+      def initialize(model, helper)
+        @model, @helper = model, helper
+      end
+
+      def display(attribute_name, label, options = {}, &block)
+        helper.capture do
+          if block_given?
+            block.call(resource)
+          else
+            "#{value_for_attribute(attribute_name)}"
+          end
+        end
+      end
+
+      private
+
+      def value_for_attribute(attribute_name)
+        model.send(attribute_name)
+      end
+    end
+  end
+end

data/app/attribute_renderers/string_renderer.rb

@@ -0,0 +1,15 @@
+class StringRenderer < ResourceRenderer::AttributeRenderer::Base
+  def display(attribute_name, label, options = {}, &block)
+    return h.capture { block.call(resource) } if block_given?
+    options.reverse_merge!(class: nil)
+    html_class = options.delete(:class)
+
+    html_attributes = {
+      class: html_class
+    }
+
+    helper.capture do
+      h.content_tag(:div, html_attributes) { value_for_attribute(attribute_name) }
+    end
+  end
+end

data/app/attribute_renderers/text_renderer.rb

@@ -0,0 +1,13 @@
+class TextRenderer < ResourceRenderer::AttributeRenderer::Base
+  def display(attribute_name, label, options = {}, &block)
+    editor_syntax = options.delete(:editor_syntax)
+
+    html_attributes = {
+      id: "#{model.class.name.parameterize}-#{model.to_param}",
+      'data-add-editor': true
+    }
+    html_attributes[:'data-editor-syntax'] = editor_syntax if editor_syntax.present?
+
+    h.content_tag(:pre, html_attributes) { value_for_attribute(attribute_name) }
+  end
+end

data/app/attribute_renderers/textile_doc_renderer.rb

@@ -0,0 +1,2 @@
+class TextileDocRenderer < ResourceRenderer::AttributeRenderer::Base
+end

data/app/attribute_renderers/thumbnail_renderer.rb

@@ -0,0 +1,13 @@
+class ThumbnailRenderer < ResourceRenderer::AttributeRenderer::Base
+  def display(attribute_name, label, options = {}, &block)
+    options.reverse_merge!(style: :thumb, image_tag_options: { class: 'thumbnail' })
+    style = options.delete(:style)
+    image_tag_options = options.delete(:image_tag_options)
+
+    attachment = value_for_attribute(attribute_name)
+    return unless attachment.respond_to?(:url)
+    source = attachment.url(style)
+    
+    helper.image_tag(source, image_tag_options)
+  end
+end

data/app/attribute_renderers/time_renderer.rb

@@ -0,0 +1,8 @@
+class TimeRenderer < ResourceRenderer::AttributeRenderer::Base
+  def display(attribute_name, label, options = {}, &block)
+    options.reverse_merge!(format: :long)
+    format = options.delete(:format)
+    
+    I18n.l(value_for_attribute(attribute_name), format: format)
+  end
+end

data/app/attribute_renderers/true_class_renderer.rb

@@ -0,0 +1,2 @@
+class TrueClassRenderer < BooleanRenderer
+end

data/app/attribute_renderers/youtube_video_renderer.rb

@@ -0,0 +1,20 @@
+class YoutubeVideoRenderer < ResourceRenderer::AttributeRenderer::Base
+  def display(attribute_name, label, options = {}, &block)
+    options.reverse_merge!(width: 640, height: 480, aspect_ratio: '16by9')
+    aspect_ratio = options.delete(:aspect_ratio)
+    # width = options.delete(:width)
+    # height = options.delete(:height)
+
+    iframe_attributes = {
+      class: 'embed-responsive-item',
+      # width: width,
+      # height: height,
+      src: "https://www.youtube.com/embed/#{model.identifier}",
+      frameborder: '0'
+    }
+
+    h.content_tag(:div, class: "embed-responsive embed-responsive-#{aspect_ratio}") do
+      h.content_tag(:iframe, nil, iframe_attributes)
+    end
+  end
+end

data/app/collection_renderers/bootstrap_table_collection_renderer.rb

@@ -0,0 +1,11 @@
+class BootstrapTableCollectionRenderer < TableCollectionRenderer
+  private
+
+  def renderer_class_name
+    'TableResourceRenderer'
+  end
+
+  def table_html_options
+    { class: 'table table-responsive table-condensed table-striped table-hover' }
+  end
+end

data/app/collection_renderers/bootstrap_thumbnail_collection_renderer.rb

@@ -0,0 +1,9 @@
+class BootstrapThumbnailCollectionRenderer < ResourceRenderer::CollectionRenderer::Base
+  def render(&block)
+    helper.capture do
+      helper.content_tag(:div, class: 'row') do
+        render_collection(&block)
+      end
+    end
+  end
+end

data/app/collection_renderers/resource_renderer/collection_renderer/base.rb

@@ -0,0 +1,45 @@
+module ResourceRenderer
+  module CollectionRenderer
+    class Base
+      attr_accessor :helper, :collection, :resource_class
+
+      def initialize(collection, resource_class, helper)
+        @collection, @resource_class, @helper = collection, resource_class, helper
+      end
+
+      def render(&block)
+        helper.capture do
+          render_collection(&block)
+        end
+      end
+
+      def association(*args, &block)
+        options = args.extract_options!
+        options[:as] = :association
+        column(*args, options, &block)
+      end
+      
+      private
+
+      def render_collection(&block)
+        collection.collect do |resource|
+          renderer_class.new(resource, helper).render(&block)
+        end.join.html_safe
+      end
+
+      def renderer_class
+        @renderer_class ||= get_renderer_class
+      end
+
+      def get_renderer_class
+        renderer = Object.const_get(renderer_class_name)
+        raise DisplayBlockNotDefinedException, "#{renderer.to_s} not defined" unless renderer.is_a?(Class)
+        renderer
+      end
+
+      def renderer_class_name
+        self.class.name.gsub('Collection', 'Resource')
+      end
+    end
+  end
+end

data/app/collection_renderers/table_collection_renderer.rb

@@ -0,0 +1,96 @@
+class TableCollectionRenderer < ResourceRenderer::CollectionRenderer::Base
+  class Header
+    attr_accessor :controller, :helper, :view_context, :resource_class
+    alias_method :h, :helper
+
+    def initialize(resource_class, helper)
+      @resource_class, @helper = resource_class, helper
+      @controller = helper.instance_variable_get('@_controller')
+      @view_context = @controller.view_context
+    end
+
+    def render(&block)
+      helper.content_tag(:tr) do
+        block.call(self)
+      end
+    end
+
+    def association(*args, &block)
+      options = args.extract_options!
+      options[:as] = :association   
+      column(*args, options, &block)
+    end
+
+    def column(attribute_name, options = {})
+      return column_with_sorting(attribute_name, options) if ransack_query.present? && options.has_key?(:sortable) && options[:sortable] != false
+
+      label = if @resource_class.respond_to?(:human_attribute_name)
+        @resource_class.human_attribute_name(attribute_name)
+      else
+        attribute_name
+      end
+      helper.content_tag(:th, label)
+    end
+
+    def timestamps
+      column(:created_at, sortable: true) +
+      column(:updated_at, sortable: true)
+    end
+
+    def acts_as_published_actions
+      column(:acts_as_published_actions)
+    end
+
+    def acts_as_list_actions(options = {})
+      column(:acts_as_published_actions)
+    end
+    private
+
+    def column_with_sorting(attribute_name, options = {})  
+      sort_by = case options[:sortable]
+      when TrueClass
+        attribute_name
+      when Symbol, String, Array
+        options[:sortable]
+      end
+
+
+      label = if @resource_class.respond_to?(:human_attribute_name)
+        @resource_class.human_attribute_name(attribute_name)
+      else
+        attribute_name
+      end
+
+      sort_link = helper.sort_link(ransack_query, sort_by, label)
+      
+      helper.content_tag(:th, sort_link)
+    end
+
+    def ransack_query
+      view_context.instance_variable_get('@q')
+    end
+  end
+
+  def render(&block)
+    helper.capture do
+      helper.content_tag(:table, table_html_options) do
+        helper.concat render_header(&block)
+        helper.concat render_collection(&block)
+      end
+    end
+  end
+
+  private
+
+  def table_html_options
+    nil
+  end
+
+  def render_header(&block)
+    header_renderer.render(&block)
+  end
+
+  def header_renderer
+    Header.new(resource_class, helper)
+  end
+end

data/app/collection_renderers/timeline_collection_renderer.rb

@@ -0,0 +1,5 @@
+class TimelineCollectionRenderer < ResourceRenderer::CollectionRenderer::Base
+  def collection
+    @collection.sort! { |a, b| a.happened_at <=> b.happened_at }
+  end
+end

data/app/helpers/resource_renderer/application_helper.rb

@@ -0,0 +1,4 @@
+module ResourceRenderer
+  module ApplicationHelper
+  end
+end

data/app/helpers/resource_renderer/view_helper.rb

@@ -0,0 +1,69 @@
+module ResourceRenderer
+  module ViewHelper
+    class RenderCollection
+      attr_accessor :helper, :collection, :renderer, :renderer_class
+
+      def initialize(collection, resource_class, helper, options = {})
+        options.reverse_merge!({ :as => :text })
+
+        renderer_name = options.delete(:as)
+
+        self.renderer_class = get_renderer_class(renderer_name)
+        self.collection = collection
+        self.helper = helper
+        self.renderer = renderer_class.new(collection, resource_class, helper)
+        self
+      end
+
+      def render_collection(&block)
+        renderer.render(&block)
+      end
+
+      private
+
+      def get_renderer_class(renderer_name)
+        renderer_class_name = "#{renderer_name.to_s.camelize}CollectionRenderer"
+        renderer = Object.const_get(renderer_class_name)
+        raise DisplayBlockNotDefinedException, "#{renderer.to_s} not defined" unless renderer.is_a?(Class)
+        renderer
+      end
+    end
+
+    class RenderResource
+      attr_accessor :helper, :resource, :renderer, :renderer_class
+
+      def initialize(resource, helper, options = {})
+        options.reverse_merge!({ :as => :text })
+
+        renderer_name = options.delete(:as)
+
+        self.renderer_class = get_renderer_class(renderer_name)
+        self.resource = resource
+        self.helper = helper
+        self.renderer = renderer_class.new(resource, helper)
+        self
+      end
+
+      def render(&block)
+        renderer.render(&block)
+      end
+
+      private
+
+      def get_renderer_class(renderer_name)
+        renderer_class_name = "#{renderer_name.to_s.camelize}ResourceRenderer"
+        renderer = Object.const_get(renderer_class_name)
+        raise DisplayBlockNotDefinedException, "#{renderer.to_s} not defined" unless renderer.is_a?(Class)
+        renderer
+      end
+    end
+
+    def render_resource(resource, options = {}, &block)
+      RenderResource.new(resource, self, options).render(&block)
+    end
+
+    def render_collection(collection, resource_class, options = {}, &block)
+      RenderCollection.new(collection, resource_class, self, options).render_collection(&block)
+    end
+  end
+end

data/app/resource_renderers/attribute_table_resource_renderer.rb

@@ -0,0 +1,41 @@
+require_dependency 'resource_renderer/resource_renderer/base'
+
+class AttributeTableResourceRenderer < ResourceRenderer::ResourceRenderer::Base
+  def row(attribute_name, options = {}, &block)
+    build_table_row(attribute_name, options, &block)
+  end
+
+  def render(&block)
+    helper.content_tag(:table, table_html_options) do
+      block.call(self)
+    end
+  end
+
+  private 
+
+  def table_html_options
+    nil
+  end
+
+  def build_table_row(attribute_name, options = {}, &block)
+    options.reverse_merge!(table_row_html_options: default_html_options_for_table_row(attribute_name))
+    table_row_html_options = options.delete(:table_row_html_options)
+
+    helper.content_tag(:tr, table_row_html_options) do
+      helper.content_tag(:th) do
+        helper.content_tag(:span, extract_label(attribute_name), class: 'key')
+      end +
+      helper.content_tag(:td) do
+        if block_given?
+          block.call(resource)
+        else
+          helper.content_tag(:span, display(attribute_name, options), class: 'value')
+        end
+      end
+    end
+  end
+
+  def default_html_options_for_table_row(attribute_name)
+    { role: attribute_name.to_s.dasherize }
+  end
+end

data/app/resource_renderers/bootstrap_attribute_table_resource_renderer.rb

@@ -0,0 +1,7 @@
+class BootstrapAttributeTableResourceRenderer < AttributeTableResourceRenderer
+  private
+  
+  def table_html_options
+    { class: 'table table-responsive table-condensed table-striped table-hover' }
+  end
+end

data/app/resource_renderers/bootstrap_thumbnail_resource_renderer.rb

@@ -0,0 +1,15 @@
+class BootstrapThumbnailResourceRenderer < ResourceRenderer::ResourceRenderer::Base
+    def render(&block)
+    helper.content_tag(:div) do
+      block.call(self)
+    end
+  end
+
+  def thumbnail(attribute_name, options = {}, &block)
+    options[:as] = :thumbnail
+
+    helper.content_tag(:div, class: 'col-xs-12 col-sm-6 col-md-4 col-lg-2') do
+      display(attribute_name, options, &block)
+    end
+  end
+end

data/app/resource_renderers/resource_renderer/resource_renderer/base.rb

@@ -0,0 +1,70 @@
+module ResourceRenderer
+  module ResourceRenderer
+    class Base
+      attr_accessor :helper, :resource
+
+      def initialize(resource, helper)
+        @resource, @helper = resource, helper
+      end
+
+      def render(&block)
+        helper.capture do
+          block.call(self)
+        end
+      end
+
+      def display(attribute_name, options = {}, &block)
+        attribute_renderer_name = options.delete(:as) if options.has_key?(:as)
+        label = options.delete(:label)
+        label ||= extract_label(attribute_name)
+
+        attribute_renderer(attribute_name, attribute_renderer_name, &block).display(attribute_name, label, options, &block)
+      end
+
+      def association(*args, &block)
+        options = args.extract_options!
+        options[:as] = :association
+        column(*args, options, &block)
+      end
+
+      def resource_class
+        @resource_class ||= resource.class
+      end
+
+      private
+
+      def attribute_renderer(attribute_name, attribute_renderer_name = nil, &block)
+        klass = attribute_renderer_class_for(attribute_name, attribute_renderer_name, &block)
+        klass.new(resource, helper)
+      end
+
+      def extract_label(attribute_name)
+        if resource_class.respond_to?(:human_attribute_name)
+          resource_class.human_attribute_name(attribute_name)
+        else
+          attribute_name.to_s
+        end
+      end
+
+      def attribute_value(attribute_name)
+        attribute_renderer(attribute_name)
+      end
+
+      def attribute_renderer_class_for(attribute_name, attribute_renderer_name = nil, &block)
+        displayer_type = if block_given?
+          :base
+        elsif attribute_renderer_name.present?
+          attribute_renderer_name
+        else
+          resource.send(attribute_name).class.name.demodulize.underscore.to_sym
+        end
+        klass_name = "#{displayer_type}_renderer".camelize
+        klass = Object.const_get(klass_name)
+        unless klass.is_a?(Class)
+          raise DisplayerNotDefinedException, "#{klass.to_s} not defined"
+        end
+        return klass
+      end
+    end
+  end
+end

data/app/resource_renderers/table_resource_renderer.rb

@@ -0,0 +1,60 @@
+class TableResourceRenderer < ResourceRenderer::ResourceRenderer::Base
+  def column(attribute_name, options = {}, &block)
+    build_table_data(attribute_name, options, &block)
+  end
+
+  def render(&block)
+    helper.content_tag(:tr) do
+      block.call(self)
+    end
+  end
+
+  def timestamps
+    column(:created_at) +
+    column(:updated_at)
+  end
+
+  def acts_as_published_actions
+    link_path = helper.controller.url_for(action: :toggle_published, id: resource.to_param)
+    column(:published_actions) do |resource| 
+      if resource.published?
+        helper.link_to(link_path, class: 'btn btn-xs btn-danger btn-responsive', method: :post) do
+          helper.content_tag(:span, nil, class: 'glyphicon glyphicon-eye-close') +
+          helper.content_tag(:span, helper.t('.unpublish', default: helper.t('acts_as_published.actions.unpublish')), class: 'btn-text')
+        end
+      else
+        helper.link_to(link_path, class: 'btn btn-xs btn-success btn-responsive', method: :post) do
+          helper.content_tag(:span, nil, class: 'glyphicon glyphicon-eye-open') +
+          helper.content_tag(:span, helper.t('.publish', default: helper.t('acts_as_published.actions.publish')), class: 'btn-text')
+        end
+      end
+    end
+  end
+
+  def acts_as_list_actions(options = {})
+    scope = options[:scope]
+
+    column_options = { as: :acts_as_list }
+    column_options[:scope] = scope if scope.present?
+    column :acts_as_list_actions, column_options
+  end
+
+  private 
+
+  def build_table_data(attribute_name, options = {}, &block)
+    options.reverse_merge!(table_column_html_options: default_html_options_for_table_column(attribute_name))
+    table_column_html_options = options.delete(:table_column_html_options)
+
+    helper.content_tag(:td, table_column_html_options) do
+      if block_given?
+        block.call(resource)
+      else
+        helper.content_tag(:span, display(attribute_name, options), class: 'value')
+      end
+    end
+  end
+
+  def default_html_options_for_table_column(attribute_name)
+    { role: attribute_name.to_s.dasherize }
+  end
+end

data/app/resource_renderers/text_resource_renderer.rb

@@ -0,0 +1,7 @@
+class TextResourceRenderer < ResourceRenderer::ResourceRenderer::Base
+  def render(&block)
+    helper.content_tag(:pre) do
+      block.call(self)
+    end
+  end
+end

data/app/resource_renderers/timeline_resource_renderer.rb

@@ -0,0 +1,36 @@
+class TimelineResourceRenderer < ResourceRenderer::ResourceRenderer::Base
+  def event(attribute_name, options = {}, &block)
+    build_event(attribute_name, options, &block)
+  end
+
+  private
+
+  def build_event(attribute_name, options, &block)
+    options.reverse_merge!(title_method: :to_s, description_method: :inspect, timestamp_method: :created_at)
+    @timestamp_method = options.delete(:timestamp_method)
+    @title_method = options.delete(:title_method)
+    @description_method = options.delete(:description_method)
+
+    event = resource.is_a?(Timeline::Event) ? resource : extract_event
+    
+
+    helper.content_tag(:div, class: 'timeline-block') do
+      helper.content_tag(:div, class: 'timeline-icon') do
+      end +
+      helper.content_tag(:div, class: 'timeline-content') do
+        helper.content_tag(:div, class: 'timeline-body') do
+          helper.content_tag(:div, event.title, class: 'timeline-title') + 
+          helper.content_tag(:div, event.description, class: 'timeline-description')
+        end + 
+        helper.content_tag(:div, I18n.l(event.happened_at), class: 'timeline-date')
+      end
+    end
+  end
+
+  def extract_event
+    Timeline::ExtractEventsService.call(resources: [resource], 
+                                        title_method: @title_method,
+                                        description_method: @description_method,
+                                        timestamp_method: @timestamp_method).events.first
+  end
+end

data/app/resource_renderers/unordered_list_resource_renderer.rb

@@ -0,0 +1,23 @@
+class UnorderedListResourceRenderer < ResourceRenderer::ResourceRenderer::Base
+  def display(attribute_name, options = {})
+    options.reverse_merge!(html_options: default_html_options_for(attribute_name))
+
+    html_options = options.delete(:html_options)
+    helper.content_tag(:li, html_options) do
+      helper.content_tag(:span, translated_attribute_name(attribute_name), class: 'key') + 
+      helper.content_tag(:span, attribute_value(attribute_name), class: 'value')
+    end
+  end
+
+  def render(&block)
+    helper.content_tag(:ul) do
+      block.call(self)
+    end
+  end
+
+  private 
+
+  def default_html_options_for(attribute_name)
+    { role: attribute_name.to_s.dasherize }
+  end
+end

data/app/services/timeline/extract_events_service.rb

@@ -0,0 +1,39 @@
+require 'timeline/event'
+
+module Timeline
+  class ExtractEventsService < Itsf::Services::V2::Service::Base
+    class Response < Itsf::Services::V2::Response::Base
+      attr_accessor :events
+    end
+
+    attr_accessor :resources, :title_method, :description_method, :timestamp_method
+
+    def do_work
+      return response unless valid?
+      response.events = extract_events
+      respond
+    end
+
+    private
+
+    def initialize_attributes
+      @title_method       = :title
+      @description_method = :description
+      @timestamp_method   = :created_at
+    end
+
+    def extract_events
+      info 'Extracting Events'
+      resources.collect do |resource|
+        Event.new(
+          title:       resource.send(title_method),
+          description: resource.send(description_method),
+          happened_at: resource.send(timestamp_method))
+      end
+    end
+
+    def resources
+      @resources || []
+    end
+  end
+end

data/app/values/timeline/event.rb

@@ -0,0 +1,11 @@
+module Timeline
+  class Event
+    attr_accessor :title, :description, :happened_at
+
+    def initialize(attributes)
+      attributes.each do |name, value|
+        send("#{name}=", value)
+      end
+    end
+  end
+end

data/lib/resource_renderer.rb

@@ -0,0 +1,5 @@
+require 'itsf_services'
+require 'resource_renderer/engine'
+
+module ResourceRenderer
+end

data/lib/resource_renderer/engine.rb

@@ -0,0 +1,4 @@
+module ResourceRenderer
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/resource_renderer/version.rb

@@ -0,0 +1,3 @@
+module ResourceRenderer
+  VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,242 @@
+--- !ruby/object:Gem::Specification
+name: resource_renderer
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Roberto Vasquez Angel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: itsf_services
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: shoulda-matchers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl_rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A simple way to render resources.
+email:
+- roberto@vasquez-angel.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- app/attribute_renderers/acts_as_list_renderer.rb
+- app/attribute_renderers/association_renderer.rb
+- app/attribute_renderers/attachment_renderer.rb
+- app/attribute_renderers/big_decimal_renderer.rb
+- app/attribute_renderers/boolean_renderer.rb
+- app/attribute_renderers/date_renderer.rb
+- app/attribute_renderers/duration_renderer.rb
+- app/attribute_renderers/email_renderer.rb
+- app/attribute_renderers/false_class_renderer.rb
+- app/attribute_renderers/fixnum_renderer.rb
+- app/attribute_renderers/image_renderer.rb
+- app/attribute_renderers/nil_class_renderer.rb
+- app/attribute_renderers/resource_renderer/attribute_renderer/base.rb
+- app/attribute_renderers/string_renderer.rb
+- app/attribute_renderers/text_renderer.rb
+- app/attribute_renderers/textile_doc_renderer.rb
+- app/attribute_renderers/thumbnail_renderer.rb
+- app/attribute_renderers/time_renderer.rb
+- app/attribute_renderers/true_class_renderer.rb
+- app/attribute_renderers/youtube_video_renderer.rb
+- app/collection_renderers/bootstrap_table_collection_renderer.rb
+- app/collection_renderers/bootstrap_thumbnail_collection_renderer.rb
+- app/collection_renderers/resource_renderer/collection_renderer/base.rb
+- app/collection_renderers/table_collection_renderer.rb
+- app/collection_renderers/timeline_collection_renderer.rb
+- app/helpers/resource_renderer/application_helper.rb
+- app/helpers/resource_renderer/view_helper.rb
+- app/resource_renderers/attribute_table_resource_renderer.rb
+- app/resource_renderers/bootstrap_attribute_table_resource_renderer.rb
+- app/resource_renderers/bootstrap_thumbnail_resource_renderer.rb
+- app/resource_renderers/resource_renderer/resource_renderer/base.rb
+- app/resource_renderers/table_resource_renderer.rb
+- app/resource_renderers/text_resource_renderer.rb
+- app/resource_renderers/timeline_resource_renderer.rb
+- app/resource_renderers/unordered_list_resource_renderer.rb
+- app/services/timeline/extract_events_service.rb
+- app/values/timeline/event.rb
+- lib/resource_renderer.rb
+- lib/resource_renderer/engine.rb
+- lib/resource_renderer/version.rb
+homepage: https://github.com/robotex82/resource_renderer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: A simple way to render resources.
+test_files: []
+has_rdoc: