locomotivecms_mounter_pull_19 1.5.4

data/lib/locomotive/mounter/utils/yaml_front_matters_template.rb

@@ -0,0 +1,45 @@
+module Locomotive
+  module Mounter
+    module Utils
+
+      # YAML Front-matters for HAML/Liquid templates
+      class YAMLFrontMattersTemplate
+
+        attr_accessor :filepath, :attributes, :raw_source, :line_offset
+
+        def initialize(filepath)
+          self.filepath     = filepath
+          self.line_offset  = 0
+
+          self.fetch_attributes_and_raw_source(File.read(self.filepath))
+        end
+
+        def source
+          return @source if @source
+
+          @source = if self.filepath.ends_with?('.haml')
+            Haml::Engine.new(self.raw_source).render
+          else
+            self.raw_source
+          end
+        end
+
+        protected
+
+        def fetch_attributes_and_raw_source(data)
+          if data =~ /^(---\s*\n.*?\n?)^(---\s*$\n?)(.*)/m
+            self.line_offset  = $1.count("\n") + 1
+            self.attributes   = YAML.load($1)
+            self.raw_source   = $3
+          else
+            self.attributes = nil
+            self.raw_source = data
+          end
+
+          self.raw_source = self.raw_source.force_encoding('utf-8')
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/mounter/version.rb

@@ -0,0 +1,8 @@
+# encoding: utf-8
+module Locomotive
+  module Mounter #:nodoc
+
+    VERSION = '1.5.4'
+
+  end
+end

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

@@ -0,0 +1,74 @@
+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
+
+        def self.teardown
+          @@instance = nil
+        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
+
+            credentials = self.parameters.select { |k, _| %w(uri email password api_key).include?(k.to_s) }
+            ssl_version = self.parameters[:ssl_version] ? self.parameters[:ssl_version].to_sym : :TLSv1_2
+            self.uri    = credentials[:uri]
+
+            begin
+              Locomotive::Mounter::EngineApi.ssl_version(ssl_version)
+              Locomotive::Mounter::EngineApi.set_token(credentials)
+            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, TranslationsWriter, PagesWriter, ThemeAssetsWriter].tap do |_writers|
+              # modify the list depending on the parameters
+              if self.parameters
+                if self.parameters[:data] == false && !(self.parameters[:only].try(:include?, 'content_entries'))
+                  _writers.delete(ContentEntriesWriter)
+                end
+
+                if self.parameters[:translations] == false && !(self.parameters[:only].try(:include?, 'translations'))
+                  _writers.delete(TranslationsWriter)
+                end
+              end
+            end
+          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/api/base.rb

@@ -0,0 +1,172 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module Api
+
+        class Base
+
+          include Locomotive::Mounter::Utils::Output
+
+          attr_accessor :mounting_point, :runner
+
+          delegate :default_locale, :locales, :site, :sprockets, to: :mounting_point
+
+          delegate :content_assets_writer, to: :runner
+
+          delegate :force?, to: :runner
+
+          def initialize(mounting_point, runner)
+            self.mounting_point = mounting_point
+            self.runner         = runner
+          end
+
+          # A write may have to do some work before being launched.
+          # By default, it displays to the output the resource being pushed.
+          #
+          def prepare
+            self.output_title
+          end
+
+          # By setting the data option to true, user content (content entries and
+          # editable elements from page) can be pushed too.
+          # By default, its value is false.
+          #
+          # @return [ Boolean ] True if the data option has been set to true
+          #
+          def data?
+            self.runner.parameters[:data] || false
+          end
+
+          # Get remote resource(s) from the API
+          #
+          # @param [ String ] resource_name The path to the resource (usually, the resource name)
+          # @param [ String ] locale The locale for the request
+          # @param [ Boolean ] dont_filter_attributes False if the we want to only keep the attributes defined by the safe_attributes method
+          #
+          # @return [ Object] The object or a collection of objects.
+          #
+          def get(resource_name, locale = nil, dont_filter_attributes = false)
+            attribute_names = dont_filter_attributes ? nil : self.safe_attributes
+
+            begin
+              Locomotive::Mounter::EngineApi.fetch(resource_name, {}, locale, attribute_names)
+            rescue ApiReadException => e
+              raise WriterException.new(e.message)
+            end
+          end
+
+          # Create a resource from the API.
+          #
+          # @param [ String ] resource_name The path to the resource (usually, the resource name)
+          # @param [ Hash ] attributes The attributes of the resource
+          # @param [ String ] locale The locale for the request
+          # @param [ Boolean ] raw True if the result has to be filtered in order to keep only the attributes defined by the safe_attributes method
+          #
+          # @return [ Object] The response of the API or nil if an error occurs
+          #
+          def post(resource_name, attributes, locale = nil, dont_filter_attributes = false)
+            attribute_names = dont_filter_attributes ? nil : self.safe_attributes
+
+            begin
+              Locomotive::Mounter::EngineApi.create(resource_name, attributes, locale, attribute_names)
+            rescue ApiWriteException => e
+              message = e.message
+              message = message.map do |attribute, errors|
+                "      #{attribute} => #{[*errors].join(', ')}\n".colorize(color: :red)
+              end.join("\n") if message.respond_to?(:keys)
+
+              raise WriterException.new(message)
+            end
+          end
+
+          # Update a resource from the API.
+          #
+          # @param [ String ] resource_name The path to the resource (usually, the resource name)
+          # @param [ Hash ] attributes The attributes of the resource
+          # @param [ Hash ] params The attributes of the resource
+          # @param [ String ] locale The locale for the request
+          #
+          # @return [ Object] The response of the API
+          #
+          def put(resource_name, id, attributes, locale = nil)
+            begin
+              Locomotive::Mounter::EngineApi.update(resource_name, id, attributes, locale, self.safe_attributes)
+            rescue ApiWriteException => e
+              message = e.message
+              message = message.map do |attribute, errors|
+                "      #{attribute} => #{[*errors].join(', ')}\n".colorize(color: :red)
+              end.join("\n") if message.respond_to?(:keys)
+
+              raise WriterException.new(message)
+
+              # self.log "\n"
+              # data.each do |attribute, errors|
+              #   self.log "      #{attribute} => #{[*errors].join(', ')}\n".colorize(color: :red)
+              # end if data.respond_to?(:keys)
+              # nil # DEBUG
+            end
+          end
+
+          def safe_attributes
+            %w(_id)
+          end
+
+          # Loop on each locale of the mounting point and
+          # change the current locale at the same time.
+          def each_locale(&block)
+            self.mounting_point.locales.each do |locale|
+              Locomotive::Mounter.with_locale(locale) do
+                block.call(locale)
+              end
+            end
+          end
+
+          # Return the absolute path from a relative path
+          # pointing to an asset within the public folder
+          #
+          # @param [ String ] path The path to the file within the public folder
+          #
+          # @return [ String ] The absolute path
+          #
+          def absolute_path(path)
+            File.join(self.mounting_point.path, 'public', path)
+          end
+
+          # Take a path and convert it to a File object if possible
+          #
+          # @param [ String ] path The path to the file within the public folder
+          #
+          # @return [ Object ] The file
+          #
+          def path_to_file(path)
+            File.new(self.absolute_path(path))
+          end
+
+          # Take in the source the assets whose url begins by "/samples",
+          # upload them to the engine and replace them by their remote url.
+          #
+          # @param [ String ] source The source text
+          #
+          # @return [ String ] The source with remote urls
+          #
+          def replace_content_assets!(source)
+            return source if source.blank?
+
+            source.to_s.gsub(/\/samples\/\S*\.[a-zA-Z0-9]+/) do |match|
+              url = self.content_assets_writer.write(match)
+              url || match
+            end
+          end
+
+          protected
+
+          def response_to_status(response)
+            response ? :success : :error
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module Api
+
+        # Push content assets to a remote LocomotiveCMS engine.
+        #
+        # The assets come from editable content blocks, for instance, in a
+        # the text fields of content entries or within editable_***_text.
+        # If an asset with the same filename already exists in the engine,
+        # the local version will not pushed unless the :force_assets option is passed
+        #
+        class ContentAssetsWriter < Base
+
+          attr_accessor :remote_assets
+
+          def prepare
+            self.remote_assets = {}
+
+            # assign an _id to a local content type if possible
+            self.get(:content_assets, nil, true).each do |attributes|
+              self.remote_assets[attributes['full_filename']] = attributes
+            end
+          end
+
+          def write(local_path)
+            status    = :skipped
+            asset     = self.build_asset(local_path)
+            response  = self.remote_assets[asset.filename]
+
+            asset._id = response['_id'] if response
+
+            self.output_resource_op asset
+
+            if !asset.exists?
+              status = :error
+            elsif asset.persisted?
+              if asset.size != response['size'].to_i && self.force_assets?
+                # update it
+                response = self.put :content_assets, asset._id, asset.to_params
+                status = self.response_to_status(response)
+              end
+            else
+              # create it
+              response = self.post :content_assets, asset.to_params, nil, true
+              status = self.response_to_status(response)
+
+              self.remote_assets[response['full_filename']] = response
+            end
+
+            self.output_resource_op_status asset, status
+
+            [:success, :skipped].include?(status) ? response['url'] : nil
+          end
+
+          protected
+
+          def build_asset(local_path)
+            Locomotive::Mounter::Models::ContentAsset.new(filepath: self.absolute_path(local_path))
+          end
+
+          def force_assets?
+            self.runner.parameters[:force_assets] || false
+          end
+
+          def resource_message(resource)
+            "  #{super}"
+          end
+
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,227 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module Api
+
+        # Push content entries to a remote LocomotiveCMS engine.
+        #
+        # TODO: They get created or changed only if the
+        # :data option has been passed.
+        #
+        class ContentEntriesWriter < Base
+
+          attr_accessor :with_relationships
+
+          def prepare
+            return unless self.data?
+
+            super
+
+            # initialize the list storing all the entries including relationships
+            self.with_relationships = []
+
+            # assign an _id to a local content entry if possible
+            self.content_types.each do |slug, content_type|
+              entries = self.get("content_types/#{slug}/entries", nil, true)
+
+              entries.each do |attributes|
+                content_entry = content_type.find_entry(attributes['_slug'])
+
+                if content_entry
+                  self.apply_response(content_entry, attributes)
+                end
+              end
+            end
+          end
+
+          def write
+            return unless self.data?
+
+            self.each_locale do |locale|
+              self.output_locale
+
+              self.content_types.each do |slug, content_type|
+                (content_type.entries || []).each do |entry|
+                  next unless entry.translated_in?(locale)
+
+                  if entry.persisted?
+                    self.update_content_entry(slug, entry)
+                  else
+                    self.create_content_entry(slug, entry)
+                  end
+
+                  self.register_relationships(slug, entry)
+                end # content entries
+              end # content type
+            end # locale
+
+            self.persist_content_entries_with_relationships
+          end
+
+          protected
+
+          # Persist a content entry by calling the API. It is enhanced then
+          # by the response if no errors occured.
+          #
+          # @param [ String ] content_type The slug of the content type
+          # @param [ Object ] content_entry The content entry to create
+          #
+          def create_content_entry(content_type, content_entry)
+            # log before
+            self.output_resource_op content_entry
+
+            # get the params
+            params = self.buffer_log { self.content_entry_to_params(content_entry) }
+
+            # send the request
+            response = self.post "content_types/#{content_type}/entries", params, nil, true
+
+            self.apply_response(content_entry, response)
+
+            status = self.response_to_status(response)
+
+            # log after
+            self.output_resource_op_status content_entry, status
+            self.flush_log_buffer
+          end
+
+          # Update a content entry by calling the API.
+          #
+          # @param [ String ] content_type The slug of the content type
+          # @param [ Object ] content_entry The content entry to update
+          #
+          def update_content_entry(content_type, content_entry)
+            locale  = Locomotive::Mounter.locale
+
+            # log before
+            self.output_resource_op content_entry
+
+            # get the params
+            params = self.buffer_log { self.content_entry_to_params(content_entry) }
+
+            # send the request
+            response = self.put "content_types/#{content_type}/entries", content_entry._id, params, locale
+
+            status = self.response_to_status(response)
+
+            # log after
+            self.output_resource_op_status content_entry, status
+            self.flush_log_buffer
+          end
+
+          # Save to the remote engine the content entries owning
+          # a relationship field. This can be done once ALL the
+          # the content entries have been first created.
+          #
+          def persist_content_entries_with_relationships
+            unless self.with_relationships.empty?
+              self.log "\n    setting relationships for all the content entries\n"
+
+              updates = self.content_entries_with_relationships_to_hash
+
+              updates.each do |params|
+                _id, slug = params.delete(:_id), params.delete(:slug)
+                self.put "content_types/#{slug}/entries", _id, params
+              end
+            end
+          end
+
+          # Build hash storing the values of the relationships (belongs_to and has_many).
+          # The key is the id of the content entry
+          #
+          # @return [ Hash ] The updates to process
+          #
+          def content_entries_with_relationships_to_hash
+            [].tap do |updates|
+              self.with_relationships.each do |(slug, content_entry)|
+                changes = {}
+
+                content_entry.content_type.fields.each do |field|
+                  case field.type.to_sym
+                  when :belongs_to
+                    if target_id = content_entry.dynamic_getter(field.name).try(:_id)
+                      changes["#{field.name}_id"] = target_id
+                    end
+                  when :many_to_many
+                    target_ids = content_entry.dynamic_getter(field.name).map(&:_id).compact
+                    unless target_ids.empty?
+                      changes["#{field.name}_ids"] = target_ids
+                    end
+                  end
+                end
+
+                updates << { _id: content_entry._id, slug: slug }.merge(changes)
+              end
+            end
+          end
+
+          # Return the list of content types
+          #
+          # @return [ Array ] List of content types
+          #
+          def content_types
+            self.mounting_point.content_types
+          end
+
+          # Take a content entry and get the params related to that content entry.
+          #
+          # @param [ Object ] entry The content entry
+          #
+          # @return [ Hash ] The params
+          #
+          def content_entry_to_params(entry)
+            params = entry.to_params
+
+            entry.each_dynamic_field do |field, value|
+              unless field.is_relationship?
+                case field.type.to_sym
+                when :string, :text
+                  params[field.name] = self.replace_content_assets!(value)
+                when :file
+                  if value =~ %r(^http://)
+                    params[field.name] = value
+                  elsif value && self.mounting_point.path
+                    path = File.join(self.mounting_point.path, 'public', value)
+                    params[field.name] = File.new(path)
+                  end
+                else
+                  params[field.name] = value
+                end
+              end
+            end
+
+            params
+          end
+
+          # Keep track of both the content entries which
+          # includes a relationship field and also
+          # the selection options.
+          #
+          # @param [ String ] slug The slug of the content type
+          # @param [ Object ] entry The content entry
+          #
+          def register_relationships(slug, entry)
+            entry.each_dynamic_field do |field, value|
+              if %w(belongs_to many_to_many).include?(field.type.to_s)
+                self.with_relationships << [slug, entry]
+                return # no need to go further and avoid duplicate entries
+              end
+            end
+          end
+
+          # Enhance the content entry with the information returned by an API call.
+          #
+          # @param [ Object ] content_entry The content entry instance
+          # @param [ Hash ] response The API response
+          #
+          def apply_response(content_entry, response)
+            return if content_entry.nil? || response.nil?
+
+            content_entry._id = response['_id']
+          end
+
+        end
+      end
+    end
+  end
+end