beautiful_scaffold 1.0.1 → 2.0.2

data/lib/generators/beautiful_locale_generator.rb

@@ -1,35 +1,32 @@
 # encoding : utf-8
 class BeautifulLocaleGenerator < Rails::Generators::Base
-  require 'beautiful_scaffold_common_methods'
+  require_relative 'beautiful_scaffold_common_methods'
   include BeautifulScaffoldCommonMethods
 
   source_root File.expand_path('../templates', __FILE__)
 
-  argument :name, :type => :string, :desc => "type of locale : fr OR en OR de OR ja all..."
+  argument :name, :type => :string, :desc => "type of locale : fr, en, de, all"
 
   class_option :mountable_engine, :default => nil
-  
-  def install_locale
+
+  def list_locales
     availablelocale = ["fr", "en", "ja"]
-    
-    localestr = name.downcase
-    
-    locale_to_process = []
 
-    if localestr == 'all' then
-      locale_to_process = availablelocale
-    else
-      locale_to_process << localestr
-    end
-    
-    locale_to_process.each{ |temp_locale|
-      filename = "beautiful_scaffold.#{temp_locale}.yml"
-      gem_localepath = "app/locales/#{filename}"
-      app_localepath = "config/locales/#{filename}"
-      begin
-        copy_file gem_localepath, app_localepath
-      rescue
-        say_status("Error", "This beautiful_locale #{localestr} doesn't exist !", :red)
+    localestr = name.downcase
+    (localestr == 'all' ? availablelocale : [localestr])
+  end
+  
+  def install_locale
+    list_locales.each{ |temp_locale|
+
+      ["beautiful_scaffold.#{temp_locale}.yml"].each do |filename|
+        gem_localepath = "app/locales/#{filename}"
+        app_localepath = "config/locales/#{filename}"
+        begin
+          copy_file gem_localepath, app_localepath
+        rescue
+          say_status("Error", "This beautiful_locale #{temp_locale} doesn't exist !", :red)
+        end
       end
 
       rails_locale_file = "#{temp_locale}.yml"
@@ -41,7 +38,7 @@ class BeautifulLocaleGenerator < Rails::Generators::Base
       end
 
       willpaginate_locale_file = "will_paginate.#{temp_locale}.yml"
-      download_path = "https://raw.github.com/mislav/will_paginate/master/lib/will_paginate/locale/en.yml"
+      download_path = "https://raw.githubusercontent.com/tigrish/will-paginate-i18n/master/config/locales/#{temp_locale}.yml"
       begin
         get download_path, "config/locales/#{willpaginate_locale_file}"
         say_status("Warning", "You must modify Will_paginate locale at : Rails.root/config/locale/#{willpaginate_locale_file}", :red)
@@ -56,105 +53,112 @@ class BeautifulLocaleGenerator < Rails::Generators::Base
   def regenerate_app_locale
     require 'net/http'
 
-    already_processed = { name.downcase => {}}
+    app_path = (Rails.root || engine_opt)
+    app_name = Rails.application.class.name.split('::').first.downcase
+    prefix = engine_opt.blank? ? '' : "#{engine_opt.camelize}::"
 
-    app_name = (Rails.root || engine_opt)
-    engine_or_apps = (Rails.application.class.parent_name || engine_opt).downcase
+    already_processed = {}
+    hi18n = {}
 
-    puts "===>"
-    puts app_name
-    puts "=======>"
-    puts engine_or_apps
+    list_locales.each do |locale_str|
+      locale = locale_str.downcase
 
-    filepath = File.join(app_name, 'config', 'locales', "#{engine_or_apps}.#{name.downcase}.yml")
-    begin
-      hi18n                                   = YAML.load_file(filepath)
-    rescue
-      puts "Error loading locale file : #{filepath}"
-    end
+      already_processed[locale] ||= {}
+
+      filepath = File.join(app_path, 'config', 'locales', "#{app_name}.#{locale}.yml")
+      begin
+        if File.exist?(filepath)
+          hi18n = YAML.load_file(filepath)
+        end
+      rescue
+        puts "Error loading locale file (YAML invalid?) : #{filepath}"
+      end
 
-    hi18n                                 ||= { name.downcase => {} }
-    hi18n[name.downcase]                  ||= { 'app' => {} }
-    hi18n[name.downcase]['app']           ||= { 'models' => {} }
-    hi18n[name.downcase]['app']['models'] ||= {}
+      hi18n[locale]                  ||= { 'app' => {} }
+      hi18n[locale]['app']           ||= { 'models' => {} }
+      hi18n[locale]['app']['models'] ||= {}
 
-    # Feed data already translated
-    hi18n[name.downcase]['app']['models'].each{ |modelname,hshtranslations|
-      hshtranslations['bs_attributes'].each{ |attr, translated_attr|
-        already_processed[name.downcase][attr] = translated_attr
-      }
-    }
+      # Feed data already translated
+      hi18n[locale]['app']['models'].each do |modelname, hshtranslations|
+        hshtranslations['bs_attributes'].each do |attr, translated_attr|
+          already_processed[locale][attr] = translated_attr
+        end
+      end
 
-    Dir.glob("app/models/**/*").each { |model_file|
-      puts model_file
-      next if File.directory?(model_file) or
-        File.basename(model_file).first == '.' or
-        model_file.include?('/concerns/') or
-        model_file.include?('pdf_report.rb') or
-        model_file.include?('application_record.rb')
+      Dir.glob("app/models/**/*").each do |model_file|
+        puts model_file
 
-      model = File.basename(model_file, File.extname(model_file))
+        next if File.directory?(model_file) or
+          File.basename(model_file).first == '.' or
+          model_file.include?('/concerns/') or
+          model_file.include?('pdf_report.rb') or
+          model_file.include?('application_record.rb')
 
-      if !engine_opt.blank?
-        prefix = "#{engine_opt.camelize}::"
-      else
-        prefix = ''
-      end
-      klass = "#{prefix}#{model.camelize.constantize}"
+        model = File.basename(model_file, File.extname(model_file))
 
-      begin
+        klass = "#{prefix}#{model}".camelize.constantize
         sorted_attr = klass.attribute_names.sort
-      rescue
-        next
-      end
 
-      newmodel = !hi18n[name.downcase]['app']['models'].has_key?(model)
+        newmodel = !hi18n[locale]['app']['models'].has_key?(model)
 
-      hi18n[name.downcase]['app']['models'][model] ||= {
+        hi18n[locale]['app']['models'][model] ||= {
           'bs_caption'            => model,
           'bs_caption_plural'     => model.pluralize,
           'bs_attributes'         => {},
-      }
-
-      if newmodel then
-        bs_caption          = (begin translate_string(name.downcase, model) rescue model end)
-        bs_caption_plural   = (begin translate_string(name.downcase, model.pluralize) rescue model.pluralize end)
+        }
+
+        if newmodel then
+          bs_caption = ""
+          begin
+            bs_caption = translate_string(locale, model)
+          rescue Exception => e
+            puts "Erreur traduction #{e.backtrace}"
+            bs_caption = model
+          end
+          bs_caption_plural = ""
+          begin
+            bs_caption_plural = translate_string(locale, model.pluralize)
+          rescue Exception => e
+            puts "Erreur traduction #{e.backtrace}"
+            bs_caption_plural = model.pluralize
+          end
 
-        hi18n[name.downcase]['app']['models'][model]['bs_caption'] = bs_caption
-        hi18n[name.downcase]['app']['models'][model]['bs_caption_plural'] = bs_caption_plural
-      end
+          hi18n[locale]['app']['models'][model]['bs_caption'] = bs_caption
+          hi18n[locale]['app']['models'][model]['bs_caption_plural'] = bs_caption_plural
+        end
 
-      hi18n[name.downcase]['app']['models'][model]['bs_attributes'] ||= {}
-
-      sorted_attr.each { |k|
-        # Si pas déjà renseigné
-        if hi18n[name.downcase]['app']['models'][model]['bs_attributes'][k].blank? then
-          # Si pas déjà traduit
-          if already_processed[name.downcase][k].nil? then
-            begin
-              attr_translate = translate_string(name.downcase, k)
-              already_processed[name.downcase][k] = attr_translate
-            rescue
-              puts "Plantage translate API"
-              attr_translate = k
+        hi18n[locale]['app']['models'][model]['bs_attributes'] ||= {}
+
+        sorted_attr.each do |k|
+          # Si pas déjà renseigné
+          if hi18n[locale]['app']['models'][model]['bs_attributes'][k].blank?
+            # Si pas déjà traduit
+            if already_processed[locale][k].blank?
+              begin
+                attr_translate = translate_string(locale, k)
+                already_processed[locale][k] = attr_translate
+              rescue
+                puts "Plantage translate API"
+                attr_translate = k
+              end
+            else
+              attr_translate = already_processed[locale][k]
             end
           else
-            attr_translate = already_processed[name.downcase][k]
+            # Récupère l'attribut traduit
+            attr_translate = hi18n[locale]['app']['models'][model]['bs_attributes'][k]
           end
-        else
-          # Récupère l'attribut traduit
-          attr_translate = hi18n[name.downcase]['app']['models'][model]['bs_attributes'][k]
-        end
 
-        hi18n[name.downcase]['app']['models'][model]['bs_attributes'][k] = attr_translate
-      }
-    }
+          hi18n[locale]['app']['models'][model]['bs_attributes'][k] = attr_translate
+        end
+      end
 
-    File.unlink(filepath) if File.exist?(filepath)
+      File.unlink(filepath) if File.exist?(filepath)
 
-    file = File.open(filepath, "w")
-    file.write(hi18n.to_yaml)
-    file.close
+      file = File.open(filepath, "w")
+      file.write(hi18n[locale].to_yaml)
+      file.close
+    end
   end
 
   private
@@ -162,14 +166,13 @@ class BeautifulLocaleGenerator < Rails::Generators::Base
   def translate_string(locale, str)
     # See http://www.microsofttranslator.com/dev/
     #
-    if locale == "en" then
+    if locale == "en"
       attr_translate = "#{str.gsub(/_/, " ")}"
     else
-      url_domain    = "mymemory.translated.net"
-      url_translate = "/api/get?q=to_translate&langpair=en%7C#{locale}"
+      url_domain = "api.mymemory.translated.net"
+      url_query = "/get?q=#{str.gsub(/_/, "%20")}&langpair=en%7C#{locale}"
 
-      urlstr = url_translate.gsub(/to_translate/, str.gsub(/_/, "%20"))
-      json = JSON.parse(Net::HTTP.get(url_domain, urlstr))
+      json = JSON.parse(Net::HTTP.get(url_domain, url_query))
       attr_translate = json["responseData"]["translatedText"].strip.downcase
     end
     raise 'Free Limit' if attr_translate =~ /mymemory/

data/lib/generators/beautiful_migration_generator.rb

@@ -1,20 +1,21 @@
 # encoding : utf-8
 class BeautifulMigrationGenerator < Rails::Generators::Base
-  require 'beautiful_scaffold_common_methods'
+  require_relative 'beautiful_scaffold_common_methods'
   include BeautifulScaffoldCommonMethods
 
   #include Rails::Generators::ResourceHelpers
 
   source_root File.expand_path('../templates', __FILE__)
 
-  argument :name, :type => :string, :desc => "Name of the migration CamelCase AddXxxToYyy (Yyy must be plural)"
-  argument :myattributes, :type => :array, :default => [], :banner => "field:type field:type (for bt relation model:references)"
+  argument :name, type: :string, desc: "Name of the migration (in CamelCase) AddXxxTo[Engine]Yyy (Yyy must be plural)"
+  argument :myattributes, type: :array, default: [], banner: "field:type field:type (for bt relation model:references)"
 
-  class_option :namespace, :default => nil
-  class_option :donttouchgem, :default => nil
+  class_option :namespace, default: nil
+  class_option :donttouchgem, default: nil
+  class_option :mountable_engine, default: nil
 
   def install_gems
-    if options[:donttouchgem].blank? then
+    if options[:donttouchgem].blank?
       require_gems
     end
   end
@@ -24,7 +25,7 @@ class BeautifulMigrationGenerator < Rails::Generators::Base
     @fulltext_field = []
     myattributes.each{ |attr|
       a,t = attr.split(':')
-      if ['richtext', 'wysiwyg'].include?(t) then
+      if ['richtext', 'wysiwyg'].include?(t)
         # _typetext = {bbcode|html|text|wiki|textile|markdown}
         # _fulltext = text without any code
         @fulltext_field << [a + '_typetext', 'string'].join(':')
@@ -34,24 +35,15 @@ class BeautifulMigrationGenerator < Rails::Generators::Base
   end
 
   def generate_model
-    generate("migration", "#{name} #{beautiful_attr_to_rails_attr(true).join(' ')} #{@fulltext_field.join(' ')}")
+    generate("migration", "#{name} #{beautiful_attr_to_rails_attr.join(' ')} #{@fulltext_field.join(' ')}")
   end
 
   def add_to_model
-    myattributes.each{ |attr|
-      a,t = attr.split(':')
-      if ['references', 'reference'].include?(t) then
-        inject_into_file("app/models/#{model}.rb", "\n  belongs_to :#{a}", :after => "ApplicationRecord")
-        inject_into_file("app/models/#{a}.rb", "\n  has_many :#{model_pluralize}, :dependent => :nullify", :after => "ApplicationRecord")
-        a += "_id"
-      end
-
-      inject_into_file("app/models/#{model}.rb", ":#{a},", :after => "def self.permitted_attributes\n    return ")
-    }
+    add_relation
   end
 
   def generate_views
-    commonpath = "app/views/#{namespace_for_url}#{model_pluralize}/"
+    commonpath = "app/views/#{engine_name}#{namespace_for_url}#{model_pluralize}/"
     
     # Form
     inject_into_file("#{commonpath}_form.html.erb", render_partial("app/views/partials/_form_field.html.erb"), :before => "<!-- Beautiful_scaffold - AddField - Do not remove -->\n" )
@@ -68,7 +60,9 @@ class BeautifulMigrationGenerator < Rails::Generators::Base
   private
 
   def model
-    return name.scan(/^Add(.*)To(.*)$/).flatten[1].underscore.singularize
+    model_extracted = name.scan(/^Add(.*)To(.*)$/).flatten[1].underscore.singularize
+    model_extracted = model_extracted.gsub("#{options[:mountable_engine].underscore}_",'') if !options[:mountable_engine].blank?
+    return model_extracted
   end
 
 end

data/lib/generators/beautiful_scaffold_common_methods.rb

@@ -8,7 +8,7 @@ module BeautifulScaffoldCommonMethods
   #############
 
   def engine_opt
-    options[:mountable_engine].to_s
+    options[:mountable_engine].to_s.downcase
   end
 
   def engine_name
@@ -16,38 +16,38 @@ module BeautifulScaffoldCommonMethods
   end
 
   def engine_camel
-    options[:mountable_engine].camelize
+    options[:mountable_engine].to_s.camelize
   end
 
   #############
   # Namespace
   #############
-  
+
   def namespace_for_class
     str = namespace_alone
     str = str.camelcase + '::' if not str.blank?
     return str
   end
-  
+
   def namespace_for_route
     str = namespace_alone
     str = str.downcase + '_' if not str.blank?
     return str
   end
-  
+
   def namespace_for_url
     str = namespace_alone
     str = str.downcase + '/' if not str.blank?
     return str
   end
-  
+
   def namespace_alone
     return options[:namespace].to_s.downcase
   end
 
   def render_partial(path)
     source  = File.expand_path(find_in_source_paths(path.to_s))
-    result = ERB.new(::File.binread(source), nil, '-').result(binding)
+    result = ERB.new(::File.binread(source), trim_mode: '-').result(binding)
     return result
   end
 
@@ -74,7 +74,7 @@ module BeautifulScaffoldCommonMethods
   def model_class
     model.camelize
   end
-  
+
   ############
   # Table
   ############
@@ -117,7 +117,7 @@ module BeautifulScaffoldCommonMethods
   def available_views
     %w(index edit show new _form)
   end
-  
+
   def attributes
     # https://raw.github.com/rails/rails/master/railties/lib/rails/generators/generated_attribute.rb
     require 'rails/generators/generated_attribute'
@@ -127,19 +127,21 @@ module BeautifulScaffoldCommonMethods
     }
   end
 
-  def beautiful_attr_to_rails_attr(for_migration = false)
+  def beautiful_attr_to_rails_attr #(for_migration = false)
     newmyattributes = []
     myattributes.each{ |attr|
       a,t = attr.split(':')
       newt = t
-      if ['wysiwyg'].include?(t) then
+
+      # Special columns
+      if ['wysiwyg'].include?(t)
         newt = 'text'
-      elsif t == 'price' then
+      elsif t == 'price'
         newt = 'float'
-      elsif ['references', 'reference'].include?(t) and for_migration then
-        a = a + '_id'
+      elsif ['references', 'reference'].include?(t) # Because Rails generate corrupted files (migrations)
+        a = "#{a}_id"
         newt = 'integer:index'
-      elsif t == 'color' then
+      elsif t == 'color'
         newt = 'string'
       end
 
@@ -154,10 +156,15 @@ module BeautifulScaffoldCommonMethods
     myattributes.each{ |attr|
       a,t = attr.split(':')
 
-      if ['references', 'reference'].include?(t) then
+      if ['references', 'reference'].include?(t)
         a = a + '_id'
       end
 
+      # Add the typetext to permitted_attr
+      if t == 'wysiwyg'
+        newmyattributes << "#{a}_typetext"
+      end
+
       newmyattributes << a
     }
 
@@ -168,7 +175,7 @@ module BeautifulScaffoldCommonMethods
     fulltext_field = []
     myattributes.each{ |attr|
       a,t = attr.split(':')
-      if ['wysiwyg'].include?(t) then
+      if ['wysiwyg'].include?(t)
         fulltext_field << a
       end
     }
@@ -181,18 +188,19 @@ module BeautifulScaffoldCommonMethods
 
   def require_gems
     gems = {
-      'less-rails' => '2.8.0',
       'will_paginate' => nil, # v 3.1.5
-      'ransack' => '1.8.2',
-      'polyamorous' => '1.3.1',
+      'ransack' => nil, #'2.3.2',
       'jquery-ui-rails' => nil,
-      'prawn' => '2.1.0',
-      'prawn-table' => '0.2.2',
+      'prawn' => nil, #'2.1.0',
+      'prawn-table' => nil, #'0.2.2',
       'sanitize' => nil,
-      'twitter-bootstrap-rails' => '3.2.2',
-      'chardinjs-rails' => nil,
+      #'twitter-bootstrap-rails' => '3.2.2', # Bootstrap 3 for Rails 6+
+      'bootstrap' => '~> 4.3.1', # Bootstrap 4 for Rails 6+
+      'font-awesome-sass' => '~> 5.13.0',
       'momentjs-rails' => '>= 2.9.0',
-      'bootstrap3-datetimepicker-rails' => '~> 4.17.47'
+      'bootstrap4-datetime-picker-rails' => nil,
+      'jquery-rails' => '4.3.1',
+      'jstree-rails-4' => '3.3.8'
     }
 
     # Si engine il faut mettre les gems dans le gemspec et faire le require
@@ -200,8 +208,30 @@ module BeautifulScaffoldCommonMethods
       puts "============> Engine : You must add gems to your main app \n #{gems.to_a.map{ |a| "gem '#{a[0]}'#{(a[1].nil? ? '' : ", '#{a[1]}'")} " }.join("\n")}"
     end
 
+    gemfile_content = File.read('Gemfile')
     gems.each{ |gem_to_add, version|
-      gem(gem_to_add, version)
+      # Bug add at every times, need to check if already present
+      if !gemfile_content.include?(gem_to_add)
+        gem(gem_to_add, version)
+      end
+    }
+  end
+
+  def add_relation
+    myattributes.each{ |attr|
+      a,t = attr.split(':')
+
+      foreign_key = a
+
+      if ['references', 'reference'].include?(t)
+        foreign_key = "#{a}_id"
+
+        # question (model) belongs_to user (a)
+        inject_into_file("app/models/#{engine_name}#{model}.rb", "\n  belongs_to :#{a}, optional: true", :after => "ApplicationRecord")
+        inject_into_file("app/models/#{engine_name}#{a}.rb", "\n  has_many :#{model_pluralize}, :dependent => :nullify", :after => "ApplicationRecord")
+      end
+
+      inject_into_file("app/models/#{engine_name}#{model}.rb", ":#{foreign_key},", :after => "def self.permitted_attributes\n    return ")
     }
   end