locomotivecms_mounter 1.0.0.alpha1

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

@@ -0,0 +1,323 @@
+module Locomotive
+  module Mounter
+    module Writer
+      module Api
+
+        class Base
+
+          @@buffer_enabled  = false
+          @@buffer_log      = ''
+
+          attr_accessor :mounting_point, :runner
+
+          delegate :default_locale, :locales, :site, to: :mounting_point
+
+          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 force option to true, some resources (site, content assets, ...etc)
+          # may overide the content of the remote engine during the push operation.
+          # By default, its value is false.
+          #
+          # @return [ Boolean ] True if the force option has been set to true
+          #
+          def force?
+            self.runner.parameters[:force] || false
+          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) by 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 ] raw True if the result has to be converted into object.
+          #
+          # @return [ Object] The object or a collection of objects.
+          #
+          def get(resource_name, locale = nil, raw = false)
+            params = { query: {} }
+
+            params[:query][:locale] = locale if locale
+
+            response  = Locomotive::Mounter::EngineApi.get("/#{resource_name}.json", params)
+            data      = response.parsed_response
+
+            if response.success?
+              return data if raw
+              self.raw_data_to_object(data)
+            else
+              nil
+            end
+          end
+
+          # Create a resource by the API.
+          #
+          # @param [ String ] resource_name The path to the resource (usually, the resource name)
+          # @param [ Hash ] params The attributes of the resource
+          # @param [ String ] locale The locale for the request
+          # @param [ Boolean ] raw True if the result has to be converted into object.
+          #
+          # @return [ Object] The response of the API or nil if an error occurs
+          #
+          def post(resource_name, params, locale = nil, raw = false)
+            params_name = resource_name.to_s.split('/').last.singularize
+
+            query = { query: { params_name => params } }
+
+            query[:query][:locale] = locale if locale
+
+            response  = Locomotive::Mounter::EngineApi.post("/#{resource_name}.json", query)
+            data      = response.parsed_response
+
+            if response.success?
+              return data if raw
+              self.raw_data_to_object(data)
+            else
+              message = data
+
+              message = data.map do |attribute, errors|
+                "      #{attribute} => #{[*errors].join(', ')}\n".colorize(color: :red)
+              end.join("\n") if data.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
+            end
+          end
+
+          # Update a resource by the API.
+          #
+          # @param [ String ] resource_name The path to the resource (usually, the resource name)
+          # @param [ String ] id The unique identifier 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 or nil if an error occurs
+          #
+          def put(resource_name, id, params, locale = nil)
+            params_name = resource_name.to_s.split('/').last.singularize
+
+            query = { query: { params_name => params } }
+
+            query[:query][:locale] = locale if locale
+
+            response  = Locomotive::Mounter::EngineApi.put("/#{resource_name}/#{id}.json", query)
+            data      = response.parsed_response
+
+            if response.success?
+              self.raw_data_to_object(data)
+            else
+              message = data
+
+              message = data.map do |attribute, errors|
+                "      #{attribute} => #{[*errors].join(', ')}" #.colorize(color: :red)
+              end.join("\n") if data.respond_to?(:keys)
+
+              raise WriterException.new(message)
+
+              # data.each do |attribute, errors|
+              #   self.log "\t\t #{attribute} => #{[*errors].join(', ')}".colorize(color: :red)
+              # end if data.respond_to?(:keys)
+              # nil
+            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\/.*\.[a-zA-Z0-9]+/) do |match|
+              url = self.runner.content_assets_writer.write(match)
+              url || match
+            end
+          end
+
+          protected
+
+          def response_to_status(response)
+            response ? :success : :error
+          end
+
+          # Convert raw data into the corresponding object (Page, Site, ...etc)
+          #
+          # @param [ Hash ] data The attributes of the object
+          #
+          # @return [ Object ] A new instance of the object
+          #
+          def raw_data_to_object(data)
+            case data
+            when Hash then data.to_hash.delete_if { |k, _| !self.safe_attributes.include?(k) }
+            when Array
+              data.map do |row|
+                # puts "#{row.inspect}\n---" # DEBUG
+                row.delete_if { |k, _| !self.safe_attributes.include?(k) }
+              end
+            else
+              data
+            end
+          end
+
+          # Print the the title for each kind of resource.
+          #
+          def output_title
+            msg = "* Pushing #{self.class.name.gsub(/Writer$/, '').demodulize}"
+            self.log msg.colorize(background: :white, color: :black) + "\n"
+          end
+
+          # Print the current locale.
+          #
+          def output_locale
+            locale = Locomotive::Mounter.locale.to_s
+            self.log "  #{locale.colorize(background: :blue, color: :white)}\n"
+          end
+
+          # Print the message about the creation / update of a resource.
+          #
+          # @param [ Object ] resource The resource (Site, Page, ...etc).
+          #
+          def output_resource_op(resource)
+            self.log self.resource_message(resource)
+          end
+
+          # Print the message about the creation / update of a resource.
+          #
+          # @param [ Object ] resource The resource (Site, Page, ...etc).
+          # @param [ Symbol ] status :success, :error, :skipped
+          # @param [ String ] errors The error messages
+          #
+          def output_resource_op_status(resource, status = :success, errors = nil)
+            status_label = case status
+            when :success         then 'done'.colorize(color: :green)
+            when :error           then 'error'.colorize(color: :red)
+            when :skipped         then 'skipped'.colorize(color: :magenta)
+            when :not_translated  then 'not translated (itself or parent)'.colorize(color: :yellow)
+            end
+
+            spaces = '.' * (80 - self.resource_message(resource).size)
+            self.log "#{spaces}[#{status_label}]\n"
+
+            if errors && status == :error
+              self.log "#{errors.colorize(color: :red)}\n"
+            end
+          end
+
+          # Return the message about the creation / update of a resource.
+          #
+          # @param [ Object ] resource The resource (Site, Page, ...etc).
+          #
+          # @return [ String ] The message
+          #
+          def resource_message(resource)
+            op_label = resource.persisted? ? 'updating': 'creating'
+            "    #{op_label} #{resource.to_s}"
+          end
+
+          # Log a message to the console or the logger depending on the options
+          # of the runner. Info is the log level if case the logger has been chosen.
+          #
+          # @param [ String ] message The message to log.
+          #
+          def log(message)
+            # puts "buffer ? #{@@buffer_enabled.inspect}"
+            if @@buffer_enabled
+              @@buffer_log << message
+            else
+              if self.runner.parameters[:console]
+                print message
+              else
+                Mounter.logger.info message #.gsub(/\n$/, '')
+              end
+            end
+          end
+
+          # Put in a buffer the logs generated when executing the block.
+          # It means that they will not output unless the flush_log_buffer
+          # method is called.
+          #
+          # @return [ Object ] Thee value returned by the call of the block
+          #
+          def buffer_log(&block)
+            @@buffer_log = ''
+            @@buffer_enabled = true
+            if block_given?
+              block.call.tap { @@buffer_enabled = false }
+            end
+          end
+
+          # Flush the logs put in a buffer.
+          #
+          def flush_log_buffer
+            @@buffer_enabled = false
+            self.log(@@buffer_log)
+            @@buffer_log = ''
+          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,223 @@
+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|
+              self.get("content_types/#{slug}/entries", nil, true).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
+          #
+          # @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|
+              case field.type.to_sym
+              when :string, :text
+                params[field.name] = self.replace_content_assets!(value)
+              when :date, :select, :boolean
+                params[field.name] = 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
+              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