carload 0.4.5 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 38d8d86c279079a2b6738899dc9719a2e390f7cf
-  data.tar.gz: 2a1ba96d3612bffa65e66e86c54f8dae2e02baa8
+  metadata.gz: 189b67589521f80841e31c1d6b88faf83808fdcb
+  data.tar.gz: 48ba545a059e0dcd99778f25364dd3a406a9b5aa
 SHA512:
-  metadata.gz: 662f9e8185472e55a3babe45e1eb00d17dd59d1b18132ea914d4e237a6b0997a407923373a41b66ab4a3a7e483b490da31216da7f2b150b718b558b3b5d3a648
-  data.tar.gz: 25e7242afb48a2dff092174cdff5b3067fb366a9ea08deba67b7ed89a51b91d9f08026775c49d168f3a1f032f435bb3084bd0e6e432d247af2e568eb1bbb327e
+  metadata.gz: 768362151f2686fc48f7f5573f63e40b599bdbfc5bf2c6a3ef93268004c9702150c51ad9ce577498aacccd6f3e520c35b7bf6d0b81cb0139c4f52d14f1a00329
+  data.tar.gz: e4fa219c45c59ecda87d186cd3353cf5406ccf89f21c68885e0fa77c0890b25e0e5d41af809f1a7b1adf7fafe537dbb9fc45cb6eeb0519e9ea3b24056af22db5

data/app/helpers/carload/application_helper.rb

@@ -9,8 +9,9 @@ module Carload
     end
 
     def polymorphic? attribute_name
-      Dashboard.model(@model_name).associated_models.each_value do |associated_model|
-        return associated_model[:name] if attribute_name =~ /#{associated_model[:name]}/ and associated_model[:polymorphic]
+      Dashboard.model(@model_name).associations.each_value do |association|
+        reflection = association[:reflection]
+        return reflection.name if attribute_name =~ /#{reflection.name}/ and reflection.options[:polymorphic]
       end
       false
     end
@@ -19,12 +20,20 @@ module Carload
       attribute_name.to_s =~ /image|logo|img/
     end
 
-    def id_or_ids associated_model
-      case associated_model[:association_type]
-      when :has_many
-        "#{associated_model[:name]}_ids"
+    def associated_model_name model_name, attribute_name
+      x = attribute_name.gsub(/_ids?$/, '').to_sym
+      Dashboard.model(model_name).associations.each do |name, association|
+        return association[:class_name] || x, name if name.to_s.singularize.to_sym == x
+      end
+      raise 'Should not go here!'
+    end
+
+    def id_or_ids reflection
+      case reflection
+      when ActiveRecord::Reflection::HasManyReflection
+        "#{reflection.name.to_s.singularize}_ids"
       else
-        "#{associated_model[:name]}_id"
+        "#{reflection.name}_id"
       end
     end
   end

data/app/helpers/carload/dashboard_helper.rb

@@ -7,43 +7,32 @@ module Carload
           selected: options[:value],
           input_html: { class: 'use-select2' }
       elsif attribute_name =~ /_id$/
-        associated_model = attribute_name.gsub(/_id$/, '').to_sym
-        association_specs = Dashboard.model(model_name).associated_models[associated_model]
-        label_attribute = association_specs[:choose_by]
-        form.association associated_model,
+        class_name, association_name = associated_model_name model_name, attribute_name
+        association = Dashboard.model(model_name).associations[association_name]
+        label_attribute = association[:choose_by]
+        form.association association_name,
           label_method: label_attribute,
-          label: t("activerecord.models.#{associated_model}"),
+          label: t("activerecord.models.#{class_name}"),
           input_html: {
             class: 'use-select2',
             data: {
-              placeholder: t('carload.placeholder.select', thing: t("activerecord.attributes.#{associated_model}.#{label_attribute}"))
+              placeholder: t('carload.placeholder.select', thing: t("activerecord.attributes.#{class_name}.#{label_attribute}"))
             }
           }
       elsif attribute_name =~ /_ids$/
-        # Mandle many-to-many association.
-        associated_model = attribute_name.gsub(/_ids$/, '').to_sym
-        association_specs = Dashboard.model(model_name).associated_models[associated_model]
-        label_attribute = association_specs[:choose_by]
+        class_name, association_name = associated_model_name model_name, attribute_name
+        association = Dashboard.model(model_name).associations[association_name]
+        label_attribute = association[:choose_by]
         form.input attribute_name,
-          label: t("activerecord.attributes.#{associated_model}.#{label_attribute}") + " (#{t("activerecord.models.#{associated_model}")})",
-          collection: associated_model.to_s.camelize.constantize.all,
+          label: t("activerecord.attributes.#{class_name}.#{label_attribute}") + " (#{t("activerecord.models.#{class_name}")})",
+          collection: class_name.to_s.camelize.constantize.all,
           label_method: label_attribute,
           value_method: :id,
           input_html: {
             class: 'use-select2',
             multiple: true,
             data: {
-              placeholder: t('carload.placeholder.select', thing: t("activerecord.attributes.#{associated_model}.#{label_attribute}"))
-            }
-          }
-      elsif attribute_name =~ /_type$/
-        associated_model = attribute_name.gsub(/_type$/, '').to_sym
-        association_specs = Dashboard.model(model_name).associated_models[associated_model]
-        form.input attribute_name, collection: association_specs[:instance_models].map{ |x| x.to_s.camelize },
-          input_html: {
-            class: 'use-select2',
-            data: {
-              placeholder: t('carload.placeholder.select', thing: t("activerecord.attributes.#{model_name}.#{attribute_name}"))
+              placeholder: t('carload.placeholder.select', thing: t("activerecord.attributes.#{class_name}.#{label_attribute}"))
             }
           }
       elsif needs_upload?(model_name, attribute_name) and image?(attribute_name)
@@ -99,7 +88,11 @@ module Carload
           raise UnsupportedError.new("attribute #{attribute}") if attribute.size != 3
           model_name = attribute[1].to_s.singularize
           attribute_name = attribute[2]
-          "#{t("activerecord.attributes.#{model_name}.#{attribute_name}", raise: true)} (#{t("activerecord.models.#{model_name}", raise: true)})"
+          begin
+            "#{t("activerecord.attributes.#{model_name}.#{attribute_name}", raise: true)} (#{t("activerecord.models.#{model_name}", raise: true)})"
+          rescue
+            "#{t("activerecord.attributes.#{@model_name}.#{model_name}.#{attribute_name}", raise: true)}"
+          end
         else
           "#{t("activerecord.attributes.#{attribute.join('.')}", raise: true)} (#{t("activerecord.models.#{attribute[0].to_s.singularize}", raise: true)})"
         end

data/app/views/carload/dashboard/_form.html.erb

@@ -5,15 +5,17 @@
     <%= generate_input f, @model_name, name, type: column.type %>
   <% end %>
   <!-- Polymorphics -->
-  <% Dashboard.model(@model_name).associated_models.each_value do |associated_model| %>
-    <% next if associated_model[:polymorphic] != true %>
-    <%= generate_input f, @model_name, associated_model[:name], polymorphic: true,
-      value: "#{@object.send("#{associated_model[:name]}_id")},#{@object.send("#{associated_model[:name]}_type")}" %>
+  <% Dashboard.model(@model_name).associations.each_value do |association| %>
+    <% reflection = association[:reflection] %>
+    <% next unless reflection.options[:polymorphic] %>
+    <%= generate_input f, @model_name, reflection.name, polymorphic: true,
+      value: "#{@object.send("#{reflection.name}_id")},#{@object.send("#{reflection.name}_type")}" %>
   <% end %>
   <!-- Join tables -->
-  <% Dashboard.model(@model_name).associated_models.each_value do |associated_model| %>
-    <% next if not associated_model[:join_table] %>
-    <%= generate_input f, @model_name, id_or_ids(associated_model) %>
+  <% Dashboard.model(@model_name).associations.each_value do |association| %>
+    <% reflection = association[:reflection] %>
+    <% next unless reflection.options[:through] %>
+    <%= generate_input f, @model_name, id_or_ids(reflection.delegate_reflection) %>
   <% end %>
   <%= f.button :submit, t('carload.action.submit'), class: 'btn btn-primary' %>
 <% end %>

data/lib/carload.rb

@@ -9,7 +9,6 @@ Gem.loaded_specs['carload'].dependencies.each do |dependency|
 end
 
 require 'carload/extended_hash'
-require 'carload/association_pipelines'
 require 'carload/model_spec'
 require 'carload/dashboard'
 require 'carload/engine'

data/lib/carload/dashboard.rb

@@ -18,9 +18,7 @@ module Carload
         model_a = options.keys.first
         model_b = options.values.first
         options.shift
-        options[:name] = model_b
-        @@models[model_a] ||= ModelSpec.new
-        @@models[model_a].associated_models[model_b] = options
+        @@models[model_a].associations[model_b] = options
       end
 
       def models
@@ -49,11 +47,12 @@ module Carload
   end
           RUBY
           default = false
-          next if spec.associated_models.empty?
-          spec.associated_models.each_value do |associated_model|
-            next unless associated_model[:choose_by]
+          next if spec.associations.empty?
+          spec.associations.each_value do |association|
+            next unless association[:choose_by]
+            reflection = association[:reflection]
             content << <<-RUBY
-  associate(#{{ name.to_sym => associated_model[:name], choose_by: associated_model[:choose_by].to_sym }})
+  associate(#{{ name.to_sym => reflection.name, choose_by: association[:choose_by] }})
             RUBY
           end
         end

data/lib/carload/engine.rb

@@ -13,9 +13,15 @@ module Carload
       # Fill up associations of models.
       Dashboard.models.each do |name, spec|
         spec.klass = name.to_s.camelize.constantize
-        spec.klass.reflect_on_all_associations.each do |association|
-          spec.handle_association association, rescue: true
+        spec.klass.reflect_on_all_associations.each do |reflection|
+          next unless spec.associations.has_key? reflection.name
+          spec.associations[reflection.name][:reflection] = reflection
+          # Record real class name.
+          if reflection.options.has_key? :class_name
+            spec.associations[reflection.name][:class_name] = reflection.options[:class_name].to_s.underscore.to_sym
+          end
         end
+        spec.process_associaitons
       end
       # Reopen model classes to add pg text search.
       case (Carload.search_engine rescue nil)
@@ -56,16 +62,16 @@ module Carload
       end
       # Reopen model classes to handle polymorphic association.
       Dashboard.models.each do |name, spec|
-        spec.associated_models.values.select { |x| x[:polymorphic] == true }.each do |associated_model|
+        spec.associations.values.select { |x| x[:reflection].options[:polymorphic] }.each do |association|
           polymorphic_objects = []
-          associated_model[:instance_models].each do |instance_model|
+          association[:instance_models].each do |instance_model|
             Dashboard.model(instance_model).klass.all.each do |object|
-              polymorphic_objects << ["#{object.class} - #{object.send(associated_model[:choose_by])}", "#{object.id},#{object.class}"]
+              polymorphic_objects << ["#{object.class} - #{object.send(association[:choose_by])}", "#{object.id},#{object.class}"]
             end
           end
           spec.klass.class_eval do
             class_eval <<-RUBY
-              def self.#{associated_model[:name].to_s.pluralize}
+              def self.#{association[:reflection].name.to_s.pluralize}
                 #{polymorphic_objects}
               end
             RUBY

data/lib/carload/model_spec.rb

@@ -1,8 +1,6 @@
 module Carload
   class ModelSpec
-    include AssociationPipelines
-
-    attr_accessor :name, :klass, :default, :attributes, :index_page, :associated_models
+    attr_accessor :name, :klass, :default, :attributes, :index_page, :associations
 
     SkippedAttributes = [
       'id', 'created_at', 'updated_at',
@@ -13,13 +11,6 @@ module Carload
       'last_sign_in_ip'
     ].freeze
 
-    AssociationTypes = {
-      ActiveRecord::Reflection::BelongsToReflection => :belongs_to,
-      ActiveRecord::Reflection::HasOneReflection => :has_one,
-      ActiveRecord::Reflection::HasManyReflection => :has_many,
-      ActiveRecord::Reflection::ThroughReflection => :through
-    }
-
     def initialize model_class = nil
       @default = false
       @attributes = ExtendedHash.new
@@ -28,20 +19,55 @@ module Carload
       @index_page[:shows][:attributes] ||= []
       @index_page[:searches] = ExtendedHash.new
       @index_page[:searches][:attributes] ||= []
-      @associated_models = {}
+      @associations ||= {}
       if model_class
         @name = model_class.name.underscore
         @klass = model_class
         @attributes[:permitted] = (model_class.column_names - SkippedAttributes).map(&:to_sym)
-        # Handle model associations.
-        model_class.reflect_on_all_associations.each do |association|
-          handle_association association
-        end
         @attributes[:permitted].each do |attribute|
           next if attribute.class == Hash
           @index_page[:shows][:attributes] << attribute
           @index_page[:searches][:attributes] << { name: attribute.to_sym, term: :cont }
         end
+        model_class.reflect_on_all_associations.each do |reflection|
+          @associations[reflection.name] = {
+            reflection: reflection,
+            choose_by: nil
+          }
+        end
+        process_associaitons
+      end
+    end
+
+    def process_associaitons
+      @associations.each_value do |association|
+        reflection = association[:reflection]
+        if join_table = reflection.options[:through] and @associations.has_key? join_table
+          # Filter join table.
+          @associations.select { |k, v| v[:reflection].name == join_table }.values.first[:filtered] = true
+          # Permit foreign id.
+          case reflection.delegate_reflection
+          when ActiveRecord::Reflection::HasOneReflection
+            @attributes[:permitted] << :"#{reflection.delegate_reflection.name}_id"
+          when ActiveRecord::Reflection::HasManyReflection
+            @attributes[:permitted] << { :"#{reflection.delegate_reflection.name.to_s.singularize}_ids" => [] }
+          end
+        elsif reflection.options[:polymorphic]
+          ActiveRecord::Base.descendants.each do |_model|
+            next if _model.name == 'ApplicationRecord' or _model.name.underscore == @name.to_s
+            _model.reflect_on_all_associations.each do |_reflection|
+              next unless _reflection.options[:as] == reflection.name
+              if association.has_key? :attributes
+                association[:attributes] = association[:attributes] & _model.column_names
+              else
+                association[:attributes] = _model.column_names - SkippedAttributes
+              end
+              association[:instance_models] ||= []
+              association[:instance_models] << _model.name.underscore.to_sym
+            end
+          end
+          association[:attributes] = association[:attributes].map(&:to_sym)
+        end
       end
     end
 
@@ -51,48 +77,5 @@ module Carload
       not @index_page[:shows][:attributes] == spec.index_page[:shows][:attributes] or
       not @index_page[:searches][:attributes] == spec.index_page[:searches][:attributes]
     end
-
-    def revise!
-      # Handle associated models if necessary.
-      @associated_models.each_value do |associated_model|
-        next unless associated_model[:choose_by]
-        if associated_model[:association_type] == :has_many
-          show_name = [:pluck, associated_model[:name].to_s.pluralize.to_sym, associated_model[:choose_by]]
-        else
-          show_name = "#{associated_model[:name]}.#{associated_model[:choose_by]}"
-        end
-        @index_page[:shows][:attributes].delete_if { |x| x == :"#{associated_model[:name]}_id" }
-        @index_page[:shows][:attributes] << show_name
-      end
-    end
-
-    def handle_association association, options = {}
-      begin
-        _association = (association.delegate_reflection rescue nil) || association
-        name = (_association.klass.name.underscore.to_sym rescue nil) || _association.name
-        association_type = AssociationTypes[_association.class]
-        polymorphic = association.options[:polymorphic] || association.options[:as]
-        foreign_key =  @klass.column_names.include?("#{(_association.klass.name.underscore rescue nil) || _association.name}_id")
-        join_table = association.options[:through].to_s.singularize.to_sym if association.options[:through]
-        @associated_models[name] = {
-          name: name,
-          association_type: association_type,
-          polymorphic: polymorphic,
-          foreign_key: foreign_key,
-          join_table: join_table,
-          choose_by: nil
-        }.merge @associated_models[name] || {}
-        association_pipelines.each { |pipeline| send pipeline, association }
-        # Delete join-table model!
-        if association.options[:through]
-          @associated_models.delete association.options[:through]
-          @associated_models.delete association.options[:through].to_s.singularize.to_sym
-        end
-      rescue => e
-        raise e unless options[:rescue]
-        raise e if not e&.original_exception&.class == PG::UndefinedTable and
-                   not e.class == ActiveRecord::NoDatabaseError
-      end
-    end
   end
 end

data/lib/carload/version.rb

@@ -1,3 +1,3 @@
 module Carload
-  VERSION = '0.4.5'
+  VERSION = '0.5.0'
 end

data/lib/generators/carload/dash_generator.rb

@@ -3,42 +3,53 @@ module Carload
     source_root File.expand_path('../templates', __FILE__)
 
     def change_dashboard_file
+      # It is necessary to load models manually.
+      Rails.application.eager_load!
       # Process model once atime.
-      model = file_name
       model_specs = {}
-      Rails.application.eager_load! # It is necessary to load models manually.
       ActiveRecord::Base.descendants.each do |model| # Rails 5 can use ApplicationRecord.
         next if model.name == 'ApplicationRecord' or model.name == 'PgSearch::Document'
-        name = model.name.underscore
-        model_specs[name] = ModelSpec.new model
+        model_specs[model.name.underscore.to_sym] = ModelSpec.new model
       end
-      spec = model_specs[model]
-      if not spec.associated_models.empty?
+      model_name = file_name.to_sym
+      spec = model_specs[model_name]
+      if not spec.associations.empty?
         cli = HighLine.new
-        spec.associated_models.each_value do |associated_model|
-          next if associated_model[:attributes].empty?
-          if associated_model[:polymorphic]
-            attributes = associated_model[:attributes]
+        spec.associations.each do |name, association|
+          next if association[:filtered]
+          reflection = association[:reflection]
+          next if reflection.class ==
+          if reflection.options[:polymorphic]
+            attributes = association[:attributes]
+          elsif reflection.options[:class_name]
+            attributes = model_specs[reflection.options[:class_name].underscore.to_sym].attributes.permitted.select { |x| x.class != Hash }
           else
-            attributes = model_specs[associated_model[:name].to_s].attributes.permitted.select { |x| x.class != Hash }
+            attributes = model_specs[reflection.name.to_s.singularize.to_sym].attributes.permitted.select { |x| x.class != Hash }
           end
           if attributes.size == 1
-            associated_model[:choose_by] = attributes.first
+            association[:choose_by] = attributes.first
           else
-            associated_model[:choose_by] = cli.choose do |menu|
-              menu.prompt = "Choose the attribute of model #{associated_model[:name]} for choosing in #{model}? "
+            association[:choose_by] = cli.choose do |menu|
+              menu.prompt = "Choose the attribute of model #{reflection.name} for choosing in #{model_name}? "
               attributes.each do |attribute|
                 next if attribute.to_s =~ /_id$/
                 menu.choice attribute
               end
             end
           end
+          # Change corresponding show attribute.
+          spec.index_page[:shows][:attributes] = spec.index_page[:shows][:attributes].map do |attribute|
+            if attribute.to_s =~ /#{name}/
+              attribute = "#{name}.#{association[:choose_by]}"
+            else
+              attribute
+            end
+          end
         end
-        spec.revise!
       end
       # Check if model exists in dashboard file, but it may be changed.
-      if not Dashboard.models.keys.include? model.to_sym or Dashboard.model(model).changed? spec
-        Dashboard.models[model.to_sym] = spec
+      if not Dashboard.models.keys.include? model_name or Dashboard.model(model_name).changed? spec
+        Dashboard.models[model_name] = spec
         Dashboard.write 'app/carload/dashboard.rb'
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: carload
 version: !ruby/object:Gem::Version
-  version: 0.4.5
+  version: 0.5.0
 platform: ruby
 authors:
 - Li Dong
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-09 00:00:00.000000000 Z
+date: 2016-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -296,7 +296,6 @@ files:
 - config/routes.rb
 - db/migrate/20161030074822_carload_enable_zhparser_extension.rb
 - lib/carload.rb
-- lib/carload/association_pipelines.rb
 - lib/carload/dashboard.rb
 - lib/carload/engine.rb
 - lib/carload/exceptions.rb

data/lib/carload/association_pipelines.rb

@@ -1,52 +0,0 @@
-module Carload
-  module AssociationPipelines
-    def association_pipelines
-      [ :pipeline_1, :pipeline_2, :pipeline_3 ]
-    end
-
-    # Find polymorphic instance models.
-    def pipeline_1 association
-      return unless association.options[:polymorphic]
-      associated_model = @associated_models[association.name]
-      ActiveRecord::Base.descendants.each do |model|
-        next if model.name == 'ApplicationRecord' or model.name.underscore == @name.to_s
-        model.reflect_on_all_associations.each do |model_association|
-          next unless model_association.options[:as] == association.name
-          associated_model[:instance_models] ||= []
-          associated_model[:instance_models] << model.name.underscore.to_sym
-          if not associated_model[:attributes]
-            associated_model[:attributes] = model.column_names - ModelSpec::SkippedAttributes
-          else
-            associated_model[:attributes] = associated_model[:attributes] & model.column_names
-          end
-        end
-      end
-    end
-
-    # Add possible attributes to let user choose.
-    def pipeline_2 association
-      return unless associated_model = @associated_models[association.name.to_s.singularize.to_sym]
-      model = association.name.to_s.singularize.camelize.constantize rescue return
-      associated_model[:attributes] ||= []
-      associated_model[:attributes] = model.column_names - ModelSpec::SkippedAttributes
-      associated_model[:attributes] = associated_model[:attributes] - [
-        "#{@name}_id",
-        "#{associated_model[:polymorphic]}_id",
-        "#{associated_model[:polymorphic]}_type"
-      ]
-    end
-
-    # Add has-many permitted attribute.
-    def pipeline_3 association
-      _association = (association.delegate_reflection rescue nil) || association
-      return unless _association.class == ActiveRecord::Reflection::HasManyReflection
-      # Exclude join table.
-      return unless @klass.reflect_on_all_associations.select { |x| x.options[:through] == _association.name }.empty?
-      @attributes[:permitted].each do |permitted|
-        next unless permitted.class == Hash
-        return if permitted.keys.first == :"#{_association.class_name.underscore}_ids"
-      end
-      @attributes[:permitted] << { :"#{_association.class_name.underscore}_ids" => [] }
-    end
-  end
-end