解决CommunityEngine在windows下部署时候样式丢失的问题

最新推荐文章于 2023-11-23 12:08:44 发布

forlinux

最新推荐文章于 2023-11-23 12:08:44 发布

阅读量1.1k

点赞数

分类专栏： Python/Perl/Ruby Rails 文章标签： windows accessor application file schema types

本文链接：https://blog.csdn.net/forlinux/article/details/2975118

版权

Python/Perl/Ruby 同时被 2 个专栏收录

8 篇文章 0 订阅

订阅专栏

Rails

5 篇文章 0 订阅

订阅专栏

CommunityEngine 是Rails下一个相当不错的社会化网络插件。

在linux下测试使用时候，相当的顺利，但在Windows下使用时，且在启动的时候出现以下错误，虽然可以正常启动，却发现样式全没了。

 
 Attempting to copy plugin assets from 'E:/workspace/beeblio/vendor/plugins/community_engine/assets' to 'E:/workspace/beeblio/public/plugin_assets'
WARNING: Couldn't create the public file structure for plugin 'community_engine'; Error follows:
Invalid argument - E:/workspace/beeblio/public/plugin_assets/community_engine/E:
Attempting to copy plugin assets from 'E:/workspace/beeblio/vendor/plugins/community_engine/engine_plugins/tiny_mce/public' to 'E:/workspace/beeblio/public/plugin_assets'
WARNING: Couldn't create the public file structure for plugin 'tiny_mce'; Error follows:
Invalid argument - E:/workspace/beeblio/public/plugin_assets/tiny_mce/E:
checking plugin 'engines' for 'application_helper'
checking plugin 'community_engine' for 'application_helper'
 

折腾半天，后来，发现，其实这根本不是CE的问题，而是CE用到的另一个插件Engine的bug

解决办法是：

打开Vendor/plugins/engines/lib/engines.rb

把第148行 #FileUtils.mkdir_p(base_target_dir) 调整为 FileUtils.mkdir_p(destination)

再次启动CE，发现，样式全回来了，SO cool。

 
  require 'active_support'
require File.join(File.dirname(__FILE__), 'engines/plugin')
require File.join(File.dirname(__FILE__), 'engines/plugin/list')
require File.join(File.dirname(__FILE__), 'engines/plugin/loader')
require File.join(File.dirname(__FILE__), 'engines/plugin/locator')
require File.join(File.dirname(__FILE__), 'engines/assets')
require File.join(File.dirname(__FILE__), 'engines/rails_extensions/rails')
# == Parameters 
# 
# The Engines module has a number of public configuration parameters: 
# 
# [+public_directory+]  The directory into which plugin assets should be 
#                       mirrored. Defaults to <tt>RAILS_ROOT/public/plugin_assets</tt>. 
# [+schema_info_table+] The table to use when storing plugin migration  
#                       version information. Defaults to +plugin_schema_info+. 
# 
# Additionally, there are a few flags which control the behaviour of 
# some of the features the engines plugin adds to Rails: 
# 
# [+disable_application_view_loading+] A boolean flag determining whether 
#                                      or not views should be loaded from  
#                                      the main <tt>app/views</tt> directory. 
#                                      Defaults to false; probably only  
#                                      useful when testing your plugin. 
# [+disable_application_code_loading+] A boolean flag determining whether 
#                                      or not to load controllers/helpers  
#                                      from the main +app+ directory, 
#                                      if corresponding code exists within  
#                                      a plugin. Defaults to false; again,  
#                                      probably only useful when testing  
#                                      your plugin. 
# [+disable_code_mixing+] A boolean flag indicating whether all plugin 
#                         copies of a particular controller/helper should  
#                         be loaded and allowed to override each other,  
#                         or if the first matching file should be loaded  
#                         instead. Defaults to false. 
# 
module Engines
  # The set of all loaded plugins 
  mattr_accessor :plugins
  self.plugins = Engines::Plugin::List.new  
  
  # List of extensions to load, can be changed in init.rb before calling Engines.init 
  mattr_accessor :rails_extensions
  self.rails_extensions = %w(action_mailer asset_helpers routing migrations dependencies)
  
  # The name of the public directory to mirror public engine assets into. 
  # Defaults to <tt>RAILS_ROOT/public/plugin_assets</tt>. 
  mattr_accessor :public_directory
  self.public_directory = File.join(RAILS_ROOT, 'public', 'plugin_assets')
  # The table in which to store plugin schema information. Defaults to 
  # "plugin_schema_info". 
  mattr_accessor :schema_info_table
  self.schema_info_table = "plugin_schema_info"
  #-- 
  # These attributes control the behaviour of the engines extensions 
  #++ 
  
  # Set this to true if views should *only* be loaded from plugins 
  mattr_accessor :disable_application_view_loading
  self.disable_application_view_loading = false
  
  # Set this to true if controller/helper code shouldn't be loaded  
  # from the application 
  mattr_accessor :disable_application_code_loading
  self.disable_application_code_loading = false
  
  # Set this ti true if code should not be mixed (i.e. it will be loaded 
  # from the first valid path on $LOAD_PATH) 
  mattr_accessor :disable_code_mixing
  self.disable_code_mixing = false
  
  # This is used to determine which files are candidates for the "code 
  # mixing" feature that the engines plugin provides, where classes from 
  # plugins can be loaded, and then code from the application loaded 
  # on top of that code to override certain methods. 
  mattr_accessor :code_mixing_file_types
  self.code_mixing_file_types = %w(controller helper)
  
  class << self
    def init
      load_extensions
      Engines::Assets.initialize_base_public_directory
    end
    
    def logger
      RAILS_DEFAULT_LOGGER
    end
    
    def load_extensions
      rails_extensions.each { |name| require "engines/rails_extensions/#{name}" }
      # load the testing extensions, if we are in the test environment. 
      require "engines/testing" if RAILS_ENV == "test"
    end
    
    def select_existing_paths(paths)
      paths.select { |path| File.directory?(path) }
    end  
  
    # The engines plugin will, by default, mix code from controllers and helpers, 
    # allowing application code to override specific methods in the corresponding 
    # controller or helper classes and modules. However, if other file types should 
    # also be mixed like this, they can be added by calling this method. For example, 
    # if you want to include "things" within your plugin and override them from 
    # your applications, you should use the following layout: 
    # 
    #   app/ 
    #    +-- things/ 
    #    |       +-- one_thing.rb 
    #    |       +-- another_thing.rb 
    #   ... 
    #   vendor/ 
    #       +-- plugins/ 
    #                +-- my_plugin/ 
    #                           +-- app/ 
    #                                +-- things/ 
    #                                        +-- one_thing.rb 
    #                                        +-- another_thing.rb 
    # 
    # The important point here is that your "things" are named <whatever>_thing.rb, 
    # and that they are placed within plugin/app/things (the pluralized form of 'thing'). 
    #  
    # It's important to note that you'll also want to ensure that the "things" are 
    # on your load path in your plugin's init.rb: 
    # 
    #   Rails.plugins[:my_plugin].code_paths << "app/things" 
    # 
    def mix_code_from(*types)
      self.code_mixing_file_types += types.map { |x| x.to_s.singularize }
    end
    
    # A general purpose method to mirror a directory (+source+) into a destination 
    # directory, including all files and subdirectories. Files will not be mirrored 
    # if they are identical already (checked via FileUtils#identical?). 
    def mirror_files_from(source, destination)
      return unless File.directory?(source)
      
      # TODO: use Rake::FileList#pathmap?     
      source_files = Dir[source + "/**/*"]
      source_dirs = source_files.select { |d| File.directory?(d) }
      source_files -= source_dirs
      
      unless source_files.empty?
        base_target_dir = File.join(destination, File.dirname(source_files.first))
        #FileUtils.mkdir_p(base_target_dir) 
        FileUtils.mkdir_p(destination)
      end
      
      source_dirs.each do |dir|
        # strip down these paths so we have simple, relative paths we can 
        # add to the destination 
        target_dir = File.join(destination, dir.gsub(source, ''))
        begin        
          FileUtils.mkdir_p(target_dir)
        rescue Exception => e
          raise "Could not create directory #{target_dir}: /n" + e
        end
      end
      
      source_files.each do |file|
        begin
          target = File.join(destination, file.gsub(source, ''))
          unless File.exist?(target) && FileUtils.identical?(file, target)
            FileUtils.cp(file, target)
          end 
        rescue Exception => e
          raise "Could not copy #{file} to #{target}: /n" + e 
        end
      end  
    end   
  end  
end
 
 