locomotivecms_mounter 1.0.0.alpha1

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

@@ -0,0 +1,152 @@
+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
+
+          def prepare
+            super
+
+            # 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']
+                theme_asset.size  = attributes['raw_size'].to_i
+              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
+              file    = self.build_temp_file(theme_asset)
+              params  = theme_asset.to_params.merge(source: file, performing_plain_text: false)
+
+              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, file)
+                  response = self.put :theme_assets, theme_asset._id, params
+
+                  status = self.response_to_status(response)
+                end
+              else
+                response = self.post :theme_assets, params, nil, true
+
+                status = self.response_to_status(response)
+              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
+            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(theme_asset.content)
+            end
+
+            File.new(path)
+          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 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 changed in order to update it
+          # if so or simply skip it.
+          #
+          # @param [ Object ] theme_asset The theme asset
+          # @param [ Object ] tmp_file The size of the file (after precompilation if required)
+          #
+          # @return [ Boolean ] True if the source of the 2 assets (local and remote) is different.
+          #
+          def theme_asset_changed?(theme_asset, tmp_file)
+            if theme_asset.stylesheet_or_javascript?
+              if theme_asset.precompiled?
+                # puts "[#{theme_asset.filename} PRECOMPILED] local size #{File.size(tmp_file)} / remote size #{theme_asset.size}"
+                File.size(tmp_file) != theme_asset.size
+              else
+                # puts "[#{theme_asset.filename}] local size #{File.size(tmp_file)} / remote size #{theme_asset.size}"
+                File.size(tmp_file) != theme_asset.size
+              end
+            else
+              File.size(tmp_file) != theme_asset.size
+            end
+
+            # (!theme_asset.stylesheet_or_javascript? && File.size(file) != theme_asset.size) ||
+            # (theme_asset.stylesheet_or_javascript? && theme_asset.content.size != theme_asset.size)
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module Api
+
+        # Push translations to a remote LocomotiveCMS engine.
+        #
+        # The force option is not used.
+        #
+        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
+
+              success = translation.persisted? ? self.update_translation(translation) : self.create_translation(translation)
+
+              self.output_resource_op_status translation, success ? :success : :error
+              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?
+          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 }
+
+            # make a call to the API for the update
+            response = self.put :translations, translation._id, params
+
+            !response.nil?
+          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/api.rb

@@ -0,0 +1,62 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module Api
+
+        # Build a singleton instance of the Runner class.
+        #
+        # @return [ Object ] A singleton instance of the Runner class
+        #
+        def self.instance
+          @@instance ||= Runner.new(:api)
+        end
+
+        class Runner < Locomotive::Mounter::Writer::Runner
+
+          attr_accessor :uri
+
+          # Call the LocomotiveCMS engine to get a token for
+          # the next API calls
+          def prepare
+            # by default, do not push data (content entries and editable elements)
+            self.parameters[:data] ||= false
+
+            self.uri  = self.parameters.delete(:uri)
+            email     = self.parameters.delete(:email)
+            password  = self.parameters.delete(:password)
+
+            if uri.blank? || email.blank? || password.blank?
+              raise Locomotive::Mounter::WriterException.new("one or many API credentials (uri, email, password) are missing")
+            end
+
+            begin
+              Locomotive::Mounter::EngineApi.set_token(uri, email, password)
+            rescue Exception => e
+              raise Locomotive::Mounter::WriterException.new("unable to get an API token: #{e.message}")
+            end
+          end
+
+          # Ordered list of atomic writers
+          #
+          # @return [ Array ] List of classes
+          #
+          def writers
+            [SiteWriter, SnippetsWriter, ContentTypesWriter, ContentEntriesWriter, PagesWriter, ThemeAssetsWriter, TranslationsWriter]
+          end
+
+          # Get the writer to push content assets
+          #
+          # @return [ Object ] A memoized instance of the content assets writer
+          #
+          def content_assets_writer
+            @content_assets_writer ||= ContentAssetsWriter.new(self.mounting_point, self).tap do |writer|
+              writer.prepare
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module FileSystem
+
+        class Base
+
+          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
+          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
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module FileSystem
+
+        class ContentAssetsWriter < Base
+
+          # It creates the theme assets folders
+          def prepare
+            self.create_folder 'public'
+          end
+
+          # It writes all the snippets into files
+          def write
+            self.mounting_point.content_assets.each do |asset|
+              self.open_file(self.target_asset_path(asset)) do |file|
+                file.write(asset.content)
+              end
+            end
+          end
+
+          protected
+
+          def target_asset_path(asset)
+            File.join('public', asset.folder, asset.filename)
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module FileSystem
+
+        class ContentEntriesWriter < Base
+
+          # It creates the data folder
+          def prepare
+            self.create_folder 'data'
+          end
+
+          # It writes all the content types into files
+          def write
+            self.mounting_point.content_types.each do |filename, content_type|
+              entries = (content_type.entries || []).map(&:to_hash)
+
+              self.open_file("data/#{filename}.yml") do |file|
+                file.write(entries.to_yaml)
+              end
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module FileSystem
+
+        class ContentTypesWriter < Base
+
+          # It creates the content types folder
+          def prepare
+            self.create_folder 'app/content_types'
+          end
+
+          # It writes all the content types into files
+          def write
+            self.mounting_point.content_types.each do |filename, content_type|
+              self.open_file("app/content_types/#{filename}.yml") do |file|
+                file.write(content_type.to_yaml)
+              end
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,73 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module FileSystem
+
+        class PagesWriter < Base
+
+          # It creates the pages folder
+          def prepare
+            self.create_folder 'app/views/pages'
+          end
+
+          # It writes all the pages into files
+          def write
+            self.write_page(self.mounting_point.pages['index'])
+
+            self.write_page(self.mounting_point.pages['404'])
+          end
+
+          protected
+
+          # Write the information about a page into the filesystem.
+          # Called itself recursively. Called at first by the write method
+          #
+          # @param [ Object ] page The page
+          # @param [ String ] path The parent path
+          #
+          def write_page(page, path = '')
+            # Note: we assume the current locale is the default one
+            page.translated_in.each do |locale|
+              default_locale = locale.to_sym == self.mounting_point.default_locale.to_sym
+
+              filepath = (path.blank? ? page.slug : File.join(path, page.slug)).underscore
+
+              Locomotive::Mounter.with_locale(locale) do
+                self.write_page_to_fs(page, filepath, default_locale ? nil : locale)
+              end
+            end
+
+            # also write the nested pages
+            (page.children || []).each do |child|
+              self.write_page(child, page.depth == 0 ? '' : page.slug)
+            end
+          end
+
+          # Write into the filesystem the file about the page which will store
+          # information about this page + template.
+          # The file is localized meaning a same page could generate a file for each translation.
+          #
+          # @param [ Object ] page The page
+          # @param [ String ] filepath The path to the file describing the page (not localized)
+          # @param [ Locale ] locale The locale, nil if default locale
+          #
+          #
+          def write_page_to_fs(page, filepath, locale)
+            _filepath = "#{filepath}.liquid"
+            _filepath.gsub!(/.liquid$/, ".#{locale}.liquid") if locale
+
+            # unless page.template.nil?
+              _filepath = File.join('app', 'views', 'pages', _filepath)
+
+              self.open_file(_filepath) do |file|
+                file.write(page.to_yaml)
+              end
+            # end
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module FileSystem
+
+        class SiteWriter < Base
+
+          # It creates the config folder
+          def prepare
+            self.create_folder 'config'
+          end
+
+          # It fills the config/site.yml file
+          def write
+            self.open_file('config/site.yml') do |file|
+              file.write(self.mounting_point.site.to_yaml)
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module FileSystem
+
+        class SnippetsWriter < Base
+
+          # It creates the snippets folder
+          def prepare
+            self.create_folder 'app/views/snippets'
+          end
+
+          # It writes all the snippets into files
+          def write
+            self.mounting_point.snippets.each do |filepath, snippet|
+              # Note: we assume the current locale is the default one
+              snippet.translated_in.each do |locale|
+                default_locale = locale.to_sym == self.mounting_point.default_locale.to_sym
+
+                Locomotive::Mounter.with_locale(locale) do
+                  self.write_snippet_to_fs(snippet, filepath, default_locale ? nil : locale)
+                end
+              end
+            end
+          end
+
+          protected
+
+          # Write into the filesystem the file which stores the snippet template
+          # The file is localized meaning a same snippet could generate a file for each translation.
+          #
+          # @param [ Object ] snippet The snippet
+          # @param [ String ] filepath The path to the file
+          # @param [ Locale ] locale The locale, nil if default locale
+          #
+          def write_snippet_to_fs(snippet, filepath, locale)
+            _filepath = "#{filepath}.liquid"
+            _filepath.gsub!(/.liquid$/, ".#{locale}.liquid") if locale
+
+            unless snippet.template.blank?
+              _filepath = File.join('app', 'views', 'snippets', _filepath)
+
+              self.open_file(_filepath) do |file|
+                file.write(snippet.source)
+              end
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module FileSystem
+
+        class ThemeAssetsWriter < Base
+
+          # Create the theme assets folders
+          #
+          def prepare
+            self.create_folder 'public'
+          end
+
+          # Write all the snippets into files
+          #
+          def write
+            self.mounting_point.theme_assets.each do |asset|
+              self.open_file(self.target_asset_path(asset)) do |file|
+                file.write(asset.content)
+              end
+            end
+          end
+
+          protected
+
+          def target_asset_path(asset)
+            File.join('public', asset.folder, asset.filename)
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module FileSystem
+
+        class TranslationsWriter < Base
+
+          def prepare
+            self.create_folder 'config'
+          end
+
+          def write
+            self.open_file('config/translations.yml') do |file|
+              file.write self.mounting_point.translations.map(&:to_params).to_yaml
+            end
+          end
+        end
+
+      end
+    end
+  end
+end