locomotivecms_mounter_pull_19 1.5.4

data/lib/locomotive/mounter/writer/api/snippets_writer.rb

@@ -0,0 +1,111 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module Api
+
+        # Push snippets to a remote LocomotiveCMS engine.
+        #
+        # The force option is not used.
+        #
+        class SnippetsWriter < Base
+
+          def prepare
+            super
+
+            # set the unique identifier to each local snippet
+            self.get(:snippets, nil, true).each do |attributes|
+              snippet = self.snippets[attributes['slug']]
+
+              snippet._id = attributes['id'] if snippet
+            end
+          end
+
+          # Write all the snippets to the remote destination
+          def write
+            self.each_locale do |locale|
+              self.output_locale
+
+              self.snippets.values.each { |snippet| self.write_snippet(snippet) }
+            end
+          end
+
+          protected
+
+          # Write a snippet by calling the API.
+          #
+          # @param [ Object ] snippet The snippet
+          #
+          def write_snippet(snippet)
+            locale = Locomotive::Mounter.locale
+
+            return unless snippet.translated_in?(locale)
+
+            self.output_resource_op snippet
+
+            success = snippet.persisted? ? self.update_snippet(snippet) : self.create_snippet(snippet)
+
+            self.output_resource_op_status snippet, success ? :success : :error
+            self.flush_log_buffer
+          end
+
+          # Persist a snippet by calling the API. The returned id
+          # is then set to the snippet itself.
+          #
+          # @param [ Object ] snippet The snippet to create
+          #
+          # @return [ Boolean ] True if the call to the API succeeded
+          #
+          def create_snippet(snippet)
+            params = self.buffer_log { snippet_to_params(snippet) }
+
+            # make a call to the API to create the snippet, no need to set
+            # the locale since it first happens for the default locale.
+            response = self.post :snippets, params, nil, true
+
+            snippet._id = response['id'] if response
+
+            !response.nil?
+          end
+
+          # Update a snippet by calling the API.
+          #
+          # @param [ Object ] snippet The snippet to persist
+          #
+          # @return [ Boolean ] True if the call to the API succeeded
+          #
+          def update_snippet(snippet)
+            params = self.buffer_log { snippet_to_params(snippet) }
+
+            locale = Locomotive::Mounter.locale
+
+            # make a call to the API for the update
+            response = self.put :snippets, snippet._id, params, locale
+
+            !response.nil?
+          end
+
+          # Shortcut to get all the local snippets.
+          #
+          # @return [ Hash ] The hash whose key is the slug and the value is the snippet itself
+          #
+          def snippets
+            self.mounting_point.snippets
+          end
+
+          # Return the parameters of a snippet sent by the API.
+          #
+          # @param [ Object ] snippet The snippet
+          #
+          # @return [ Hash ] The parameters of the page
+          #
+          def snippet_to_params(snippet)
+            snippet.to_params.tap do |params|
+              params[:template] = self.replace_content_assets!(params[:template])
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/locomotive/mounter/writer/api/theme_assets_writer.rb

@@ -0,0 +1,201 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module Api
+
+        # Push theme assets to a remote LocomotiveCMS engine.
+        #
+        # New assets are automatically pushed.
+        # Existing ones are not pushed unless the :force option is
+        # passed OR if the size of the asset (if not a javascript or stylesheet) has changed.
+        #
+        class ThemeAssetsWriter < Base
+
+          # Other local attributes
+          attr_accessor :tmp_folder
+
+          # store checksums of remote assets. needed to check if an asset has to be updated or not
+          attr_accessor :checksums
+
+          # the assets stored in the engine have the same base url
+          attr_accessor :remote_base_url
+
+          # cache the compiled theme assets to avoid to perform compilation more than once
+          attr_accessor :cached_compiled_assets
+
+          def prepare
+            super
+
+            self.checksums = {}
+
+            self.cached_compiled_assets = {}
+
+            # prepare the place where the assets will be stored temporarily.
+            self.create_tmp_folder
+
+            # assign an _id to a local content type if possible
+            self.get(:theme_assets, nil, true).each do |attributes|
+              remote_path = File.join(attributes['folder'], File.basename(attributes['local_path']))
+
+              if theme_asset = self.theme_assets[remote_path]
+                theme_asset._id                 = attributes['id']
+                self.checksums[theme_asset._id] = attributes['checksum']
+              end
+
+              if remote_base_url.nil?
+                attributes['url'] =~ /(.*\/sites\/[0-9a-f]+\/theme)/
+                self.remote_base_url = $1
+              end
+            end
+          end
+
+          def write
+            self.theme_assets_by_priority.each do |theme_asset|
+              # track it in the logs
+              self.output_resource_op theme_asset
+
+              status  = :skipped
+              errors  = []
+              file    = self.build_temp_file(theme_asset)
+              params  = theme_asset.to_params.merge(source: file, performing_plain_text: false)
+
+              begin
+                if theme_asset.persisted?
+                  # we only update it if the size has changed or if the force option has been set.
+                  if self.force? || self.theme_asset_changed?(theme_asset)
+                    response  = self.put :theme_assets, theme_asset._id, params
+                    status    = self.response_to_status(response)
+                  else
+                    status = :same
+                  end
+                else
+                  response  = self.post :theme_assets, params, nil, true
+                  status    = self.response_to_status(response)
+                end
+              rescue Exception => e
+                if self.force?
+                  status, errors = :error, e.message
+                else
+                  raise e
+                end
+              end
+
+              # very important. we do not want a huge number of non-closed file descriptor.
+              file.close
+
+              # track the status
+              self.output_resource_op_status theme_asset, status, errors
+            end
+
+            # make the stuff like they were before
+            self.remove_tmp_folder
+          end
+
+          protected
+
+          # Create the folder to store temporarily the files.
+          #
+          def create_tmp_folder
+            self.tmp_folder = self.runner.parameters[:tmp_dir] || File.join(Dir.getwd, '.push-tmp')
+
+            FileUtils.mkdir_p(self.tmp_folder)
+          end
+
+          # Clean the folder which had stored temporarily the files.
+          #
+          def remove_tmp_folder
+            FileUtils.rm_rf(self.tmp_folder) if self.tmp_folder
+          end
+
+          # Build a temp file from a theme asset.
+          #
+          # @param [ Object ] theme_asset The theme asset
+          #
+          # @return [ File ] The file descriptor
+          #
+          def build_temp_file(theme_asset)
+            path = File.join(self.tmp_folder, theme_asset.path)
+
+            FileUtils.mkdir_p(File.dirname(path))
+
+            File.open(path, 'w') do |file|
+              file.write(self.content_of(theme_asset))
+            end
+
+            File.new(path)
+          end
+
+          # Shortcut to get all the theme assets.
+          #
+          # @return [ Hash ] The hash whose key is the slug and the value is the snippet itself
+          #
+          def theme_assets
+            return @theme_assets if @theme_assets
+
+            @theme_assets = {}.tap do |hash|
+              self.mounting_point.theme_assets.each do |theme_asset|
+                hash[theme_asset.path] = theme_asset
+              end
+            end
+          end
+
+          # List of theme assets sorted by their priority.
+          #
+          # @return [ Array ] Sorted list of the theme assets
+          #
+          def theme_assets_by_priority
+            self.theme_assets.values.sort { |a, b| a.priority <=> b.priority }
+          end
+
+          # Tell if the theme_asset has been changed in order to update it
+          # if so or simply skip it.
+          #
+          # @param [ Object ] theme_asset The theme asset
+          #
+          # @return [ Boolean ] True if the checksums of the local and remote files are different.
+          #
+          def theme_asset_changed?(theme_asset)
+            content = self.content_of(theme_asset)
+
+            if theme_asset.stylesheet_or_javascript?
+              # we need to compare compiled contents (sass, coffeescript) with the right urls inside
+              content = content.gsub(/[("'](\/(stylesheets|javascripts|fonts|images|media|others)\/(([^;.]+)\/)*([a-zA-Z_\-0-9]+)\.[a-z]{2,3})[)"']/) do |path|
+                sanitized_path = path.gsub(/[("')]/, '').gsub(/^\//, '')
+                sanitized_path = File.join(self.remote_base_url, sanitized_path)
+
+                "#{path.first}#{sanitized_path}#{path.last}"
+              end
+            end
+
+            # compare local checksum with the remote one
+            Digest::MD5.hexdigest(content) != self.checksums[theme_asset._id]
+          end
+
+          # Return the content of a theme asset.
+          # If the theme asset is either a stylesheet or javascript file,
+          # it uses Sprockets to compile it.
+          # Otherwise, it returns the raw content of the asset.
+          #
+          # @return [ String ] The content of the theme asset
+          #
+          def content_of(theme_asset)
+            if theme_asset.stylesheet_or_javascript?
+              if self.cached_compiled_assets[theme_asset.path].nil?
+                self.cached_compiled_assets[theme_asset.path] = self.sprockets[theme_asset.short_path].to_s
+              end
+
+              self.cached_compiled_assets[theme_asset.path]
+            else
+              theme_asset.content
+            end
+          end
+
+          def sprockets
+            Locomotive::Mounter::Extensions::Sprockets.environment(self.mounting_point.path, true)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/locomotive/mounter/writer/api/translations_writer.rb

@@ -0,0 +1,85 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module Api
+
+        # Push translations to a remote LocomotiveCMS engine.
+        #
+        class TranslationsWriter < Base
+
+          def prepare
+            super
+
+            # set the unique identifier to each local translation
+            (self.get(:translations, nil, true) || []).each do |attributes|
+              translation = self.translations[attributes['key']]
+
+              translation._id = attributes['id'] if translation
+            end
+          end
+
+          # Write all the translations to the remote destination
+          def write
+            self.translations.each do |key, translation|
+              self.output_resource_op translation
+
+              status = translation.persisted? ? self.update_translation(translation) : self.create_translation(translation)
+
+              self.output_resource_op_status translation, status
+              self.flush_log_buffer
+            end
+          end
+
+          protected
+
+          # Persist a translation by calling the API. The returned id
+          # is then set to the translation itself.
+          #
+          # @param [ Object ] translation The translation to create
+          #
+          # @return [ Boolean ] True if the call to the API succeeded
+          #
+          def create_translation(translation)
+            params = self.buffer_log { translation.to_params }
+
+            # make a call to the API to create the translation, no need to set
+            # the locale since it first happens for the default locale.
+            response = self.post :translations, params, nil, true
+
+            translation._id = response['id'] if response
+
+            !response.nil? ? :success : :error
+          end
+
+          # Update a translation by calling the API.
+          #
+          # @param [ Object ] translation The translation to persist
+          #
+          # @return [ Boolean ] True if the call to the API succeeded
+          #
+          def update_translation(translation)
+            params = self.buffer_log { translation.to_params }
+
+            if self.data?
+              # make a call to the API for the update
+              response = self.put :translations, translation._id, params
+
+              !response.nil? ? :success : :error
+            else
+              :skipped
+            end
+          end
+
+          # Shortcut to get all the local translations.
+          #
+          # @return [ Hash ] The hash whose key is the tr key and the value is translation itself
+          #
+          def translations
+            self.mounting_point.translations
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/locomotive/mounter/writer/file_system.rb

@@ -0,0 +1,44 @@
+module Locomotive
+  module Mounter
+    module Writer
+
+      module FileSystem
+
+        # Build a singleton instance of the Runner class.
+        #
+        # @return [ Object ] A singleton instance of the Runner class
+        #
+        def self.instance
+          @@instance ||= Runner.new(:file_system)
+        end
+
+        class Runner < Locomotive::Mounter::Writer::Runner
+
+          attr_accessor :target_path
+
+          # Check the existence of the target_path parameter
+          #
+          def prepare
+            self.target_path = parameters[:target_path]
+
+            if self.target_path.blank?
+             raise Locomotive::Mounter::WriterException.new('target_path is required')
+           end
+          end
+
+          # List of all the writers
+          #
+          # @return [ Array ] List of the writer classes
+          #
+          def writers
+            [SiteWriter, SnippetsWriter, ContentTypesWriter, ContentEntriesWriter, PagesWriter, ThemeAssetsWriter, ContentAssetsWriter, TranslationsWriter]
+            # [SiteWriter, PagesWriter, SnippetsWriter, ContentTypesWriter, ContentEntriesWriter, ContentAssetsWriter, ThemeAssetsWriter, TranslationsWriter]
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/mounter/writer/file_system/base.rb

@@ -0,0 +1,70 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module FileSystem
+
+        class Base
+
+          include Locomotive::Mounter::Utils::Output
+
+          attr_accessor :mounting_point, :runner
+
+          def initialize(mounting_point, runner)
+            self.mounting_point = mounting_point
+            self.runner         = runner
+          end
+
+          # It should always be called before executing the write method.
+          # Writers inheriting from this class can overide it
+          #
+          def prepare
+            self.output_title(:writing)
+          end
+
+          # Writers inheriting from this class *must* overide it
+          def write
+            raise 'The write method has to be overridden'
+          end
+
+          # Helper method to create a folder from a relative path
+          #
+          # @param [ String ] path The relative path
+          #
+          def create_folder(path)
+            fullpath = File.join(self.target_path, path)
+            unless File.exists?(fullpath)
+              FileUtils.mkdir_p(fullpath)
+            end
+          end
+
+          # Open a file described by the relative path. The file will be closed after the execution of the block.
+          #
+          # @param [ String ] path The relative path
+          # @param [ String ] mode The file mode ('w' by default)
+          # @param [ Lambda ] &block The block passed to the File.open method
+          #
+          def open_file(path, mode = 'w', &block)
+            # make sure the target folder exists
+            self.create_folder(File.dirname(path))
+
+            fullpath = File.join(self.target_path, path)
+
+            File.open(fullpath, mode, &block)
+          end
+
+          def target_path
+            self.runner.target_path
+          end
+
+          protected
+
+          def resource_message(resource)
+            "    writing #{truncate(resource.to_s)}"
+          end
+
+        end
+
+      end
+    end
+  end
+end