locomotivecms_mounter 1.0.0.alpha1

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

@@ -0,0 +1,49 @@
+module Locomotive
+  module Mounter
+    module Reader
+     module Api
+
+       class Base
+
+         attr_accessor :runner, :items
+
+         def initialize(runner)
+           self.runner  = runner
+           self.items   = {}
+         end
+
+         def mounting_point
+           self.runner.mounting_point
+         end
+
+         def locales
+           self.mounting_point.locales
+         end
+
+         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).parsed_response
+
+           return response if raw
+
+           case response
+           when Hash then response.to_hash.delete_if { |k, _| !self.safe_attributes.include?(k) }
+           when Array
+             response.map do |row|
+               # puts "#{row.inspect}\n---" # DEBUG
+               row.delete_if { |k, _| !self.safe_attributes.include?(k) }
+             end
+           else
+             response
+           end
+         end
+
+       end
+
+     end
+   end
+ end
+end

data/lib/locomotive/mounter/reader/api/content_assets_reader.rb

@@ -0,0 +1,40 @@
+module Locomotive
+  module Mounter
+    module Reader
+      module Api
+
+        class ContentAssetsReader < Base
+
+          # Build the list of theme assets from the public folder with eager loading.
+          #
+          # @return [ Array ] The cached list of theme assets
+          #
+          def read
+            base_uri = self.runner.uri.split('/').first
+            base_uri = "http://#{base_uri}" unless base_uri =~ /^http:\/\//
+
+            self.get(:content_assets).each do |attributes|
+              url = attributes.delete('url')
+
+              attributes['folder']  = 'samples/assets'
+              attributes['uri']     = URI(url =~ /http:\/\// ? url : "#{base_uri}#{url}")
+
+              self.items[url] = Locomotive::Mounter::Models::ContentAsset.new(attributes)
+            end
+
+            self.items
+          end
+
+          protected
+
+          def safe_attributes
+            %w(_id url)
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/mounter/reader/api/content_entries_reader.rb

@@ -0,0 +1,141 @@
+module Locomotive
+  module Mounter
+    module Reader
+      module Api
+
+        class ContentEntriesReader < Base
+
+          attr_accessor :ids, :relationships
+
+          def initialize(runner)
+            self.ids, self.relationships = {}, []
+            super
+          end
+
+          # Build the list of content types from the folder on the file system.
+          #
+          # @return [ Array ] The un-ordered list of content types
+          #
+          def read
+            self.fetch
+
+            self.resolve_relationships
+
+            self.items
+          end
+
+          protected
+
+          def fetch
+            self.mounting_point.content_types.each do |slug, content_type|
+              entries = self.get("content_types/#{slug}/entries", nil, true)
+
+              entries.each do |attributes|
+                locales = attributes.delete('translated_in') || []
+
+                entry = self.add(content_type, attributes)
+
+                # get all the translated versions
+                locales.each do |locale|
+                  _attributes = self.get("content_types/#{slug}/entries/#{entry._id}", locale, true)
+
+                  Locomotive::Mounter.with_locale(locale) do
+                    self.filter_attributes(content_type, _attributes).each do |key, value|
+                      entry.send(:"#{key}=", value)
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          # Add a content entry for a content type.
+          #
+          # @param [ Object ] content_type The content type
+          # @param [ Hash ] attributes The attributes of the content entry
+          #
+          # @return [ Object] The newly created content entry
+          #
+          def add(content_type, attributes)
+            _attributes = self.filter_attributes(content_type, attributes)
+
+            # puts "_attributes = #{_attributes.inspect}" # DEBUG
+
+            entry = content_type.build_entry(_attributes)
+
+            key = File.join(content_type.slug, entry._slug)
+
+            self.items[key] = self.ids[entry._id] = entry
+          end
+
+          # Filter the attributes coming directly from an API call.
+          #
+          # @param [ Object ] content_type The content type
+          # @param [ Hash ] attributes The attributes of the content entry
+          #
+          # @return [ Object] The attributes understandable by the content entry
+          #
+          def filter_attributes(content_type, original_attributes)
+            attributes = original_attributes.clone.keep_if { |k, v| %w(_id _slug seo_title meta_keywords meta_description _position).include?(k) }
+
+            content_type.fields.each do |field|
+              value = (case field.type
+              when :string, :boolean
+                original_attributes[field.name]
+              when :text
+                self.replace_urls_by_content_assets(original_attributes[field.name])
+              when :select
+                field.name_for_select_option(original_attributes[field.name])
+              when :date
+                original_attributes["formatted_#{field.name}"]
+              when :belongs_to, :many_to_many
+                # push a relationship in the waiting line in order to be resolved at last
+                target_field_name = field.type == :belongs_to ? "#{field.name}_id" : "#{field.name}_ids"
+                self.relationships << { id: attributes['_id'], field: field.name, target_ids: original_attributes[target_field_name] }
+                nil
+              else
+                nil
+              end)
+
+              attributes[field.name] = value unless value.nil?
+            end
+
+            attributes
+          end        
+
+          # Some entries have what it is called "relationships" field
+          # which can be only resolved once all the entries have been fetched
+          #
+          def resolve_relationships
+            self.relationships.each do |relationship|
+              source_entry, target_ids = self.ids[relationship[:id]], relationship[:target_ids]
+
+              target_entries = self.ids.select { |k, _| [*target_ids].include?(k) }.values
+
+              # single entry (belongs_to) or an array (many_to_many) ?
+              target_entries = target_entries.first unless target_ids.is_a?(Array)
+
+              source_entry.send(:"#{relationship[:field]}=", target_entries)
+            end
+          end
+
+          # For a given content, parse it and replace all the urls from content assets
+          # by their corresponding locale ones.
+          #
+          # @param [ String ] content The content to parse
+          #
+          # @return [ String ] The content with local urls
+          #
+          def replace_urls_by_content_assets(content)
+            self.mounting_point.content_assets.each do |path, asset|
+              content.gsub!(path, asset.local_filepath)
+            end
+            content
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/mounter/reader/api/content_types_reader.rb

@@ -0,0 +1,74 @@
+module Locomotive
+  module Mounter
+    module Reader
+      module Api
+
+        class ContentTypesReader < Base
+
+          # Build the list of content types from the folder in the file system.
+          #
+          # @return [ Array ] The un-ordered list of content types
+          #
+          def read
+            self.fetch
+
+            self.enable_relationships
+
+            self.items
+          end
+
+          protected
+
+          def fetch
+            self.get(:content_types).each do |attributes|
+              self.add(attributes)
+            end
+          end
+
+          # Add a new content type in the global hash of content types.
+          # If the content type exists, it returns it.
+          #
+          # @param [ Hash ] attributes The attributes of the content type
+          #
+          # @return [ Object ] A newly created content type or the existing one
+          #
+          def add(attributes)
+            slug = attributes['slug']
+
+            attributes.delete('entries_custom_fields').each do |_attributes|
+              _attributes = _attributes.delete_if { |k, v| v.blank? || %w(id updated_at created_at).include?(k) }
+
+              # TODO: select options
+
+              (attributes['fields'] ||= []) << _attributes
+            end
+
+            unless self.items.key?(slug)
+              self.items[slug] = Locomotive::Mounter::Models::ContentType.new(attributes)
+            end
+
+            self.items[slug]
+          end
+
+          # Make sure that each "relationship" field of a content type is
+          # correctly connected to the target content type.
+          def enable_relationships
+            self.items.each do |_, content_type|
+              content_type.fields.find_all(&:is_relationship?).each do |field|
+                # look for the target content type from its class name
+                target = self.items.values.find { |_content_type| _content_type.klass_name == field.class_name }
+                field.class_name = target.slug
+              end
+            end
+          end
+
+          def safe_attributes
+            %w(name slug description order_by order_direction label_field_name group_by_field_id public_submission_accounts entries_custom_fields klass_name)
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/mounter/reader/api/pages_reader.rb

@@ -0,0 +1,174 @@
+module Locomotive
+  module Mounter
+    module Reader
+      module Api
+
+        class PagesReader < Base
+
+          attr_accessor :pages
+
+          def initialize(runner)
+            self.pages = {}
+            super
+          end
+
+          # Build the tree of pages based on the filesystem structure
+          #
+          # @return [ Hash ] The pages organized as a Hash (using the fullpath as the key)
+          #
+          def read
+            self.fetch
+
+            index = self.pages['index']
+
+            self.build_relationships(index, self.pages_to_list)
+
+            # Locomotive::Mounter.with_locale(:fr) { self.to_s } # DEBUG
+            # self.to_s
+
+            self.pages
+          end
+
+          protected
+
+          # Create a ordered list of pages from the Hash
+          #
+          # @return [ Array ] An ordered list of pages
+          #
+          def pages_to_list
+            # sort by fullpath first
+            list = self.pages.values.sort { |a, b| a.fullpath <=> b.fullpath }
+            # sort finally by depth
+            list.sort { |a, b| a.depth <=> b.depth }
+          end
+
+          def build_relationships(parent, list)
+            list.dup.each do |page|
+              next unless self.is_subpage_of?(page.fullpath, parent.fullpath)
+
+              # attach the page to the parent (order by position), also set the parent
+              parent.add_child(page)
+
+              # remove the page from the list
+              list.delete(page)
+
+              # go under
+              self.build_relationships(page, list)
+            end
+          end
+
+          # Record pages found in file system
+          def fetch
+            self.get(:pages).each do |attributes|
+              page = self.add(attributes['fullpath'], attributes)
+
+              self.mounting_point.locales[1..-1].each do |locale|
+                # if not translated, no need to make an api call for that locale
+                next unless page.translated_in?(locale)
+
+                Locomotive::Mounter.with_locale(locale) do
+                  localized_attributes = self.get("pages/#{page._id}", locale)
+
+                  # delete useless attributes
+                  localized_attributes.delete('target_klass_slug')
+
+                  # isolate the editable elements
+                  editable_elements = self.filter_editable_elements(localized_attributes.delete('editable_elements'))
+
+                  page.attributes = localized_attributes
+
+                  page.set_editable_elements(editable_elements)
+                end
+              end
+            end
+          end
+
+          # Add a new page in the global hash of pages.
+          # If the page exists, then do nothing.
+          #
+          # @param [ String ] fullpath The fullpath used as the key for the hash
+          # @param [ Hash ] attributes The attributes of the new page
+          #
+          # @return [ Object ] A newly created page or the existing one
+          #
+          def add(fullpath, attributes = {})
+            unless self.pages.key?(fullpath)
+              # editable elements
+              editable_elements = self.filter_editable_elements(attributes.delete('editable_elements'))
+
+              # content type
+              if content_type_slug = attributes.delete('target_klass_slug')
+                attributes['content_type'] = self.mounting_point.content_types[content_type_slug] #.values.find { |ct| ct._id == content_type_id }              
+              end
+
+              self.pages[fullpath] = Locomotive::Mounter::Models::Page.new(attributes)
+
+              self.pages[fullpath].set_editable_elements(editable_elements)
+            end
+
+            self.pages[fullpath]
+          end
+
+          # Tell is a page described by its fullpath is a sub page of a parent page
+          # also described by its fullpath
+          #
+          # @param [ String ] fullpath The full path of the page to test
+          # @param [ String ] parent_fullpath The full path of the parent page
+          #
+          # @return [ Boolean] True if the page is a sub page of the parent one
+          #
+          def is_subpage_of?(fullpath, parent_fullpath)
+            return false if %w(index 404).include?(fullpath)
+
+            if parent_fullpath == 'index' && fullpath.split('/').size == 1
+              return true
+            end
+
+            File.dirname(fullpath.dasherize) == parent_fullpath.dasherize
+          end
+
+          # Only keep the minimal attributes from a list of
+          # editable elements hashes. It also replaces the url to 
+          # content assets by their corresponding local ones.
+          #
+          # @param [ Array ] list The list of the editable elements with all the attributes
+          #
+          # @return [ Array ] The list of editable elements with the right attributes
+          #
+          def filter_editable_elements(list)
+            list.map do |attributes|
+              attributes.keep_if { |k, _| %w(_id block slug content).include?(k) }.tap do |hash|
+                self.mounting_point.content_assets.each do |path, asset|
+                  hash['content'].gsub!(path, asset.local_filepath)
+                end
+              end
+            end
+          end
+
+          def safe_attributes
+            %w(_id title slug handle fullpath translated_in target_klass_slug
+            published listed templatized editable_elements
+            redirect_url cache_strategy response_type position
+            seo_title meta_keywords meta_description raw_template)
+          end
+
+          # Output simply the tree structure of the pages.
+          #
+          # Note: only for debug purpose
+          #
+          def to_s(page = nil)
+            page ||= self.pages['index']
+
+            return unless page.translated_in?(Locomotive::Mounter.locale)
+
+            puts "#{"  " * (page.try(:depth) + 1)} #{page.fullpath.inspect} (#{page.title}, position=#{page.position})"
+
+            (page.children || []).each { |child| self.to_s(child) }
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/mounter/reader/api/site_reader.rb

@@ -0,0 +1,37 @@
+module Locomotive
+  module Mounter
+    module Reader
+      module Api
+
+        class SiteReader < Base
+
+          def read
+            # get the site from the API
+            site = self.get(:current_site)
+
+            # set the default locale first
+            Locomotive::Mounter.locale = site['locales'].first.to_sym
+
+            Locomotive::Mounter::Models::Site.new(site).tap do |site|
+              # fetch the information in other locales
+              site.locales[1..-1].each do |locale|
+                Locomotive::Mounter.with_locale(locale) do
+                  self.get(:current_site, locale).each do |name, value|
+                    next unless %w(seo_title meta_keywords meta_description).include?(name)
+                    site.send(:"#{name}=", value)
+                  end
+                end
+              end
+            end
+          end
+
+          def safe_attributes
+            %w(name locales seo_title meta_keywords meta_description domains subdomain)
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/mounter/reader/api/snippets_reader.rb

@@ -0,0 +1,59 @@
+module Locomotive
+  module Mounter
+    module Reader
+      module Api
+
+        class SnippetsReader < Base
+
+          # Build the list of snippets from the folder on the file system.
+          #
+          # @return [ Array ] The un-ordered list of snippets
+          #
+          def read
+            self.fetch
+
+            self.items
+          end
+
+          protected
+
+          # Record snippets found in file system
+          def fetch
+            self.get(:snippets).each do |attributes|
+              snippet = self.add(attributes.delete('slug'), attributes)
+
+              self.mounting_point.locales[1..-1].each do |locale|
+                Locomotive::Mounter.with_locale(locale) do
+                  localized_attributes = self.get("snippets/#{snippet._id}", locale)
+                  snippet.attributes = localized_attributes
+                end
+              end
+            end
+          end
+
+          # Add a new snippet in the global hash of snippets.
+          # If the snippet exists, it returns it.
+
+          # @param [ String ] slug The slug of the snippet
+          # @param [ Hash ] attributes The attributes of the snippet
+          #
+          # @return [ Object ] A newly created snippet or the existing one
+          #
+          def add(slug, attributes)
+            unless self.items.key?(slug)
+              self.items[slug] = Locomotive::Mounter::Models::Snippet.new(attributes)
+            end
+
+            self.items[slug]
+          end
+
+          def safe_attributes
+            %w(_id name slug template)
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/locomotive/mounter/reader/api/theme_assets_reader.rb

@@ -0,0 +1,42 @@
+module Locomotive
+  module Mounter
+    module Reader
+      module Api
+
+        class ThemeAssetsReader < Base
+
+          def initialize(runner)
+            super
+            self.items = []
+          end
+
+          # Build the list of theme assets from the public folder with eager loading.
+          #
+          # @return [ Array ] The cached list of theme assets
+          #
+          def read
+            base_uri = self.runner.uri.split('/').first
+            base_uri = "http://#{base_uri}" unless base_uri =~ /^http:\/\//
+
+            self.items = self.get(:theme_assets).map do |attributes|
+              url = attributes.delete('url')
+
+              attributes['uri'] = URI(url =~ /http:\/\// ? url : "#{base_uri}#{url}")
+
+              Locomotive::Mounter::Models::ThemeAsset.new(attributes)
+            end
+          end
+
+          protected
+
+          def safe_attributes
+            %w(_id folder url)
+          end
+
+        end
+
+      end
+
+    end
+  end
+end

data/lib/locomotive/mounter/reader/api/translations_reader.rb

@@ -0,0 +1,28 @@
+module Locomotive
+  module Mounter
+    module Reader
+      module Api
+
+        class TranslationsReader < Base
+
+          # Build the list of translations
+          #
+          # @return [ Array ] The cached list of theme assets
+          #
+          def read
+            self.items = get(:translations).map do |attributes|
+              Locomotive::Mounter::Models::Translation.new(attributes)
+            end
+          end
+          
+          protected
+          def safe_attributes
+            %w[_id key values]
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Locomotive
+  module Mounter
+    module Reader
+      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::Reader::Runner
+
+          attr_accessor :uri
+
+          # Call the LocomotiveCMS engine to get a token for
+          # the next API calls
+          def prepare
+            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::ReaderException.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::ReaderException.new("unable to get an API token: #{e.message}")
+            end
+          end
+
+          # Ordered list of atomic readers
+          #
+          # @return [ Array ] List of classes
+          #
+          def readers
+            [SiteReader, ContentAssetsReader, SnippetsReader, ContentTypesReader, ContentEntriesReader, PagesReader, ThemeAssetsReader, TranslationsReader]
+          end
+
+        end
+
+      end
+    end
+  end
+end