azahara_schema 0.1.12 → 0.1.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: af8c74a55165b64dd1028655871bbccd2df367faf7f8e140c2574d5e3823260c
-  data.tar.gz: 2b066a64fe4b33863562dad9d13c38dad1cd73f5460368f057851ef3dc873ab7
+  metadata.gz: 6a38482119a210601a41eac9333f38109bba98ab82ba7da4e4a10e657338b1b6
+  data.tar.gz: 24457857de38a9e8ac27b74439279484ec45c1da150f3f4e3bf74639324659f8
 SHA512:
-  metadata.gz: e68614299630ffafb7d870b3a8aea26df55ddccd8bea8ea5deaeebfcea6e1b2f76364c9b45a3b435ccaebf4b613f7ce824d52fb1e2721bc99866dab91394a784
-  data.tar.gz: 22bd14b10428e52aa5d61ccd404cc8ae892264548842c780abcecdd7bb9f19b4a72eddedfe1c34c9e0d10940d72fde20683664c4485cfde0fbc04028838e3f60
+  metadata.gz: b76450d6a94770ed1ee49302872a070233ada6d01d2f28b890a74da2136fb0f45b57a866805734930d5c3e9e9badc8c4af944d9ed560572ec89097dbe7162cd0
+  data.tar.gz: acac345155a9445a757cb36506f8a9a97aa5106b0a3a9f3c81e057b4ce0563243c8ee58e80fa51bd3fef3394423b9cb6ec61f6f434bba3be6b61498daeb9ca92

data/app/helpers/azahara_schema/application_helper.rb

@@ -26,5 +26,9 @@ module AzaharaSchema
       end
     end
 
+    def attribute_formatter_for(schema_or_model, **options)
+      AttributeFormatter.formatter_for(schema_or_model).new(schema_or_model, self, options)
+    end
+
   end
 end

data/app/views/azahara_schema/_schema.html.erb

@@ -0,0 +1,6 @@
+<% if local_assigns.fetch(:filters, true) %>
+  <%= render 'azahara_schema/filters', schema: schema %>
+<% end %>
+<% schema.outputs.each do |output| %>
+  <%= render output %>
+<% end %>

data/lib/azahara_schema/attribute_formatter.rb

@@ -0,0 +1,121 @@
+module AzaharaSchema
+  class AttributeFormatter
+
+    def self.default_formatter=(formatter_klass)
+      @default_formatter = formatter_klass
+    end
+
+    def self.default_formatter
+      @default_formatter || AzaharaSchema::AttributeFormatter
+    end
+
+    def self.formatter_for(schema_or_entity)
+      klass = schema_or_entity.class if !schema_or_entity.is_a?(Class)
+      klass = schema_or_entity.model if schema_or_entity.is_a?(::AzaharaSchema::Schema)
+      klass ||= schema_or_entity
+      klasses = [klass]
+      while klass != klass.base_class
+        klass = klass.superclass
+        klasses << klass
+      end
+      klasses.each do |kls|
+        schema_klass = "#{kls.name}Formatter".safe_constantize || "Formatters::#{kls.name}Formatter".safe_constantize
+        return schema_klass if schema_klass
+      end
+      default_formatter
+    end
+
+    attr_reader :model, :template
+
+    def initialize(schema_or_entity, template, **options)
+      @schema = schema_or_entity if schema_or_entity.is_a?(::AzaharaSchema::Schema)
+      @entity = schema_or_entity if schema_or_entity.is_a?(::ActiveRecord::Base)
+      @model = @schema ? @schema.model : (@entity ? schema_or_entity.class : schema_or_entity)
+      @options = options
+      @template = template
+    end
+
+    def new_path(**options)
+      template.new_polymorphic_path(model, options)
+    end
+
+    def show_path(entity, **options)
+      template.polymorphic_path(entity, options)
+    end
+
+    def icon_class_for_attribute(attribute)
+      'fa'
+    end
+
+    def attribute_human_value(attribute, entity, **options)
+      val = attribute.value(entity)
+      case attribute.type
+      when 'love'
+        attribute.available_values.detect{|l, v| v == val }.try(:[], 0)
+      when 'list'
+        attribute.attribute_name.human_list_value(val, options)
+      else
+        val
+      end
+    end
+
+    def formatted_value(attribute, entity, **options)
+      real_formatter(attribute).format_value(attribute, attribute_human_value(attribute, entity), options)
+    end
+
+    def html_formatted_value(attribute, entity, **options)
+      format_value_html(attribute, attribute.value(entity), options)
+    end
+
+    def attribute_html_label(attribute, **options)
+      attribute.attribute_name.human(options)
+    end
+
+    def labeled_html_attribute_value(attribute, entity, **options)
+      template.content_tag('div', class: 'attribute') do
+        s = ''.html_safe
+        s << template.content_tag('div', attribute_html_label(attribute, options), class: 'label')
+        s << template.content_tag('div', format_value_html(attribute, attribute.value(entity), options), class: 'value')
+        s
+      end
+    end
+
+
+    def format_value(attribute, unformated_value, **options)
+      case attribute.type
+      when 'datetime'
+        l(unformated_value)
+      else
+        unformated_value
+      end
+    end
+
+    def format_value_html(attribute, unformated_value, **options)
+      formated_value = real_formatter(attribute).format_value(attribute, unformated_value, options)
+    end
+
+    def real_formatter(attribute)
+      if attribute.respond_to?(:attribute)
+        self.class.formatter_for(attribute.attribute.model).new(attribute.attribute.model, template, @options).real_formatter(attribute.attribute)
+      else
+        self
+      end
+    end
+
+    def real_formatter_and_attribute(attribute)
+      if attribute.respond_to?(:attribute)
+        self.class.formatter_for(attribute.attribute.model).new(attribute.attribute.model, template, @options).real_formatter_and_attribute(attribute.attribute)
+      else
+        [self, attribute]
+      end
+    end
+
+    def with_real_formatter_and_attribute(attribute, &block)
+      yield real_formatter_and_attribute(attribute)
+    end
+
+    private
+      delegate :l, :t, to: :template
+
+  end
+end

data/lib/azahara_schema/attribute_name.rb

@@ -7,8 +7,13 @@ module AzaharaSchema
       @attribute = attribute
     end
 
-    def human
-      I18n.t(i18n_scoped_key, default: i18n_fallback_keys)
+    def human(**options)
+      I18n.t(i18n_scoped_key, options.merge(default: i18n_fallback_keys))
+    end
+
+    def human_list_value(value, **options)
+      return '' unless value.present?
+      I18n.t(i18n_scoped_list_key(value.to_s), options.merge(default: i18n_list_fallback_keys(value)+[value.to_s]))
     end
 
     def model_i18n_key
@@ -19,8 +24,16 @@ module AzaharaSchema
       attribute.name
     end
 
+    def i18n_scope
+      'activerecord.attributes.' + model_i18n_key.to_s
+    end
+
     def i18n_scoped_key
-      ('activerecord.attributes.' + model_i18n_key.to_s + '.' + i18n_key.to_s).to_sym
+      (i18n_scope + '.' + i18n_key.to_s).to_sym
+    end
+
+    def i18n_scoped_list_key(value)
+      i18n_scope + '.' + i18n_key.to_s.pluralize + '.' + value.to_s
     end
 
     def i18n_fallback_keys
@@ -30,7 +43,18 @@ module AzaharaSchema
         keys.concat( parent_attr_name.i18n_fallback_keys )
         keys
       else
-        [ i18n_scoped_key.to_sym ]
+        []
+      end
+    end
+
+    def i18n_list_fallback_keys(value)
+      if attribute.respond_to?(:attribute)
+        parent_attr_name = attribute.attribute.attribute_name
+        keys = [ parent_attr_name.i18n_scoped_list_key(value).to_sym ]
+        keys.concat( parent_attr_name.i18n_list_fallback_keys(value) )
+        keys
+      else
+        []
       end
     end
   end

data/lib/azahara_schema/cancan/controller_resource_patch.rb

@@ -0,0 +1,17 @@
+# redefine cancan collection load to schema load
+module AzaharaSchema
+  module CanCan
+    module ControllerResourcePatch
+
+      def load_collection
+        schema = ::AzaharaSchema::Schema.schema_for(resource_class)
+        if @options[:trough]
+          schema.add_filter(parent_name.to_s+'_id', '=', parent_resource.id)
+        end
+        schema.visibility_scope!(current_ability, authorization_action)
+        schema
+      end
+
+    end
+  end
+end

data/lib/azahara_schema/controller_additions.rb

@@ -0,0 +1,26 @@
+module AzaharaSchema
+  module ControllerAdditions
+
+    def azahara_schema_index(**options)
+      resource_schema = self.class.cancan_resource_class.new(self).send(:collection_instance)
+      resource_schema.from_params(params)
+      respond_to do |format|
+        format.html
+        format.json {
+          json_result = {}
+          if params['_type'] == 'query'
+            json_result[:results] = resource_schema.entities.collect do |o|
+                {id: o.id, text: o.to_s, residence: o.person.residence.to_s}
+              end
+          elsif params['_type'] == 'count'
+            json_result = {count: resource_schema.entity_count}
+          else
+            json_result = resource_schema
+          end
+          render json: json_result
+        }
+      end
+    end
+
+  end
+end

data/lib/azahara_schema/engine.rb

@@ -8,6 +8,7 @@ require 'azahara_schema/outputs'
 require 'azahara_schema/output'
 require 'azahara_schema/schema'
 require 'azahara_schema/model_schema'
+require 'azahara_schema/attribute_formatter'
 
 module AzaharaSchema
   class Engine < ::Rails::Engine
@@ -18,6 +19,19 @@ module AzaharaSchema
       g.fixture_replacement :factory_girl, :dir => 'spec/factories'
     end
 
+    initializer 'azahara_schema.controller_additions' do
+      if Object.const_defined?('CanCan::ControllerResource')
+        require 'azahara_schema/cancan/controller_resource_patch'
+        ::CanCan::ControllerResource.send(:prepend, AzaharaSchema::CanCan::ControllerResourcePatch)
+
+        require 'azahara_schema/controller_additions'
+        ActiveSupport.on_load(:action_controller) do
+          include ::AzaharaSchema::ControllerAdditions
+        end
+      end
+
+    end
+
     config.to_prepare do
       ::ApplicationController.helper(AzaharaSchema::ApplicationHelper)
     end

data/lib/azahara_schema/model_schema.rb

@@ -1,5 +1,6 @@
 module AzaharaSchema
   class ModelSchema < Schema
+
     def initialize(**attrs)
       super(model, attrs)
     end
@@ -12,6 +13,14 @@ module AzaharaSchema
       @model ||= self.class.name.sub(/Schema/, '').constantize
     end
 
+    def visibility_scope!(ability, authorization_action=:index)
+      @entity_scope = model.accessible_by(ability, authorization_action)
+    end
+
+    def entity_scope
+      @entity_scope || super
+    end
+
     # dummy implementations for rewrite
     def uncollapsable_filters
       available_filters.select{|name, filter| always_visible_filters.include?(name) }
@@ -21,5 +30,10 @@ module AzaharaSchema
       available_filters.select{|name, filter| !always_visible_filters.include?(name) }
     end
 
+    # rendering
+    def to_partial_path
+      'azahara_schema/schema'
+    end
+
   end
 end

data/lib/azahara_schema/output.rb

@@ -4,7 +4,11 @@ module AzaharaSchema
     attr_reader :schema
 
     def self.key
-      self.name.split('::').last.underscore
+      self.name.split('::').last.sub(/Output$/, '').underscore
+    end
+
+    def key
+      self.class.key
     end
 
     def initialize(schema)
@@ -23,5 +27,10 @@ module AzaharaSchema
       model_name.i18n_key
     end
 
+    # rendering
+    def to_partial_path
+      'azahara_schema/outputs/'+key
+    end
+
   end
 end

data/lib/azahara_schema/outputs.rb

@@ -1,6 +1,8 @@
 module AzaharaSchema
   class Outputs
 
+    include Enumerable
+
     def self.registered_outputs
       @registered_outputs ||= {}
     end
@@ -26,5 +28,11 @@ module AzaharaSchema
       self.class.output_class(output).new(@schema)
     end
 
+    def each(&block)
+      @schema.enabled_outputs.each do |o|
+        yield output(o)
+      end
+    end
+
   end
 end

data/lib/azahara_schema/schema.rb

@@ -29,7 +29,7 @@ module AzaharaSchema
       operators_for_filters[filter] = operators
     end
 
-    attr_accessor :model, :association, :parent_schema
+    attr_accessor :model, :enabled_outputs, :association, :parent_schema
     attr_accessor :search_query
 
     def initialize(model, **attributes)
@@ -37,6 +37,7 @@ module AzaharaSchema
       @association = attributes[:association]
       @parent_schema = attributes[:parent_schema]
       @column_names = attributes[:columns]
+      @enabled_outputs = attributes[:outputs] || default_outputs
     end
 
     def searchable_attributes
@@ -66,6 +67,10 @@ module AzaharaSchema
 
     # DEFAULTS
 
+    def default_outputs
+      []
+    end
+
     def default_columns
       [main_attribute_name]
     end
@@ -173,7 +178,9 @@ module AzaharaSchema
     end
 
     def attribute_for_column(col)
-      Attribute.new(model, col.name, col.type)
+      t = 'list' if model.defined_enums[col.name]
+      t ||= col.type
+      Attribute.new(model, col.name, t)
     end
 
     def initialize_available_attributes
@@ -199,18 +206,15 @@ module AzaharaSchema
       query.split if query
     end
 
-    def entities
-      scope = model.respond_to?(:visible) ? model.visible : model.all
-      columns.each do |col|
-        scope = col.add_preload(scope)
-      end
+    def entity_scope
+      model.respond_to?(:visible) ? model.visible : model.all
+    end
+
+    def filtered_scope
+      scope = entity_scope
       filters.each do |name, attrs|
         scope = available_filters[name].add_statement(scope, attrs[:o], attrs[:v])
       end
-      sort.each do |name, order|
-        att = attribute(name)
-        scope = att.add_sort(scope, order) if att
-      end
       if (tokens = tokenize_search_query)
         searchable_attributes.each{|a| scope = a.add_join(scope) }
         arl = searchable_attributes[0].arel_statement('~', tokens) if searchable_attributes.any?
@@ -220,6 +224,22 @@ module AzaharaSchema
       scope
     end
 
+    def entity_count
+      filtered_scope.count
+    end
+
+    def entities
+      scope = filtered_scope
+      columns.each do |col|
+        scope = col.add_preload(scope)
+      end
+      sort.each do |name, order|
+        att = attribute(name)
+        scope = att.add_sort(scope, order) if att
+      end
+      scope
+    end
+
     def build_json_options!(options={})
       columns.each{|col| col.build_json_options!(options) }
       options

data/lib/azahara_schema/version.rb

@@ -1,3 +1,3 @@
 module AzaharaSchema
-  VERSION = '0.1.12'
+  VERSION = '0.1.13'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: azahara_schema
 version: !ruby/object:Gem::Version
-  version: 0.1.12
+  version: 0.1.13
 platform: ruby
 authors:
 - Ondřej Ezr
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-15 00:00:00.000000000 Z
+date: 2017-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -61,6 +61,7 @@ files:
 - app/models/action_schema/application_record.rb
 - app/views/azahara_schema/_filters.html.erb
 - app/views/azahara_schema/_index_form.html.erb
+- app/views/azahara_schema/_schema.html.erb
 - app/views/layouts/action_schema/application.html.erb
 - config/locales/cs.yml
 - config/routes.rb
@@ -68,7 +69,10 @@ files:
 - lib/azahara_schema/aggregation_attribute.rb
 - lib/azahara_schema/association_attribute.rb
 - lib/azahara_schema/attribute.rb
+- lib/azahara_schema/attribute_formatter.rb
 - lib/azahara_schema/attribute_name.rb
+- lib/azahara_schema/cancan/controller_resource_patch.rb
+- lib/azahara_schema/controller_additions.rb
 - lib/azahara_schema/derived_attribute.rb
 - lib/azahara_schema/engine.rb
 - lib/azahara_schema/field_format.rb
@@ -98,7 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.2
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: Gem to support developement of rails application with schema over an entity