locomotivecms_mounter_pull_19 1.5.4

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

@@ -0,0 +1,88 @@
+module Locomotive
+  module Mounter
+    module Reader
+      module FileSystem
+
+        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_from_filesystem
+
+            self.items
+          end
+
+          protected
+
+          def fetch_from_filesystem
+            Dir.glob(File.join(self.root_dir, '*.yml')).each do |filepath|
+              attributes = self.read_yaml(filepath)
+
+              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']
+
+            # TODO: raise an error if no fields
+
+            attributes.delete('fields').each_with_index do |_attributes, index|
+              hash = { name: _attributes.keys.first, position: index }.merge(_attributes.values.first)
+
+              if options = hash.delete('select_options')
+                hash['select_options'] = self.sanitize_select_options(options)
+              end
+
+              (attributes['fields'] ||= []) << hash
+            end
+
+            attributes[:mounting_point] = self.mounting_point
+
+            unless self.items.key?(slug)
+              self.items[slug] = Locomotive::Mounter::Models::ContentType.new(attributes)
+            end
+
+            self.items[slug]
+          end
+
+          # Take the list of options described in the YAML file
+          # and convert it into a nice array of hashes
+          #
+          # @params [ Array ] options The list of raw options
+          #
+          # @return [ Array ] The sanitized list of options
+          #
+          def sanitize_select_options(options)
+            [].tap do |array|
+              options.each_with_index do |object, position|
+                array << { name: object, position: position }
+              end
+            end
+          end
+
+          # Return the directory where all the definition of
+          # the content types are stored.
+          #
+          # @return [ String ] The content types directory
+          #
+          def root_dir
+            File.join(self.runner.path, 'app', 'content_types')
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,211 @@
+module Locomotive
+  module Mounter
+    module Reader
+      module FileSystem
+
+        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, not_found = self.pages['index'], self.pages['404']
+
+            # localize the fullpath for the 2 core pages: index and 404
+            [index, not_found].each { |p| p.localize_fullpath(self.locales) }
+
+            self.build_relationships(index, self.pages_to_list)
+
+            # Locomotive::Mounter.with_locale(:en) { self.to_s } # DEBUG
+
+            # Locomotive::Mounter.with_locale(:fr) { self.to_s } # DEBUG
+
+            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)
+            # do not use an empty template for other locales than the default one
+            parent.set_default_template_for_each_locale(self.default_locale)
+
+            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)
+
+              # localize the fullpath in all the locales
+              page.localize_fullpath
+
+              # 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
+            position, last_dirname = nil, nil
+
+            Dir.glob(File.join(self.root_dir, '**/*')).sort.each do |filepath|
+              next unless File.directory?(filepath) || filepath =~ /\.(#{Locomotive::Mounter::TEMPLATE_EXTENSIONS.join('|')})$/
+
+              if last_dirname != File.dirname(filepath)
+                position, last_dirname = 100, File.dirname(filepath)
+              end
+
+              page = self.add(filepath, position: position)
+
+              next if File.directory?(filepath) || page.nil?
+
+              if locale = self.filepath_locale(filepath)
+                Locomotive::Mounter.with_locale(locale) do
+                  self.set_attributes_from_header(page, filepath)
+                end
+              else
+                Locomotive::Mounter.logger.warn "Unknown locale in the '#{File.basename(filepath)}' file."
+              end
+
+              position += 1
+            end
+          end
+
+          # Add a new page in the global hash of pages.
+          # If the page exists, override it.
+          #
+          # @param [ String ] filepath The path of the template
+          # @param [ Hash ] attributes The attributes of the new page
+          #
+          # @return [ Object ] A newly created page or the existing one
+          #
+          def add(filepath, attributes = {})
+            fullpath = self.filepath_to_fullpath(filepath)
+
+            unless self.pages.key?(fullpath)
+              attributes[:title]    = File.basename(fullpath).humanize
+              attributes[:fullpath] = fullpath
+
+              page = Locomotive::Mounter::Models::Page.new(attributes)
+              page.mounting_point = self.mounting_point
+              page.filepath       = File.expand_path(filepath)
+
+              page.template = OpenStruct.new(raw_source: '') if File.directory?(filepath)
+
+              self.pages[fullpath] = page
+            end
+
+            self.pages[fullpath]
+          end
+
+          # Set attributes of a page from the information
+          # stored in the header of the template (YAML matters).
+          # It also stores the template.
+          #
+          # @param [ Object ] page The page
+          # @param [ String ] filepath The path of the template
+          #
+          def set_attributes_from_header(page, filepath)
+            template = Locomotive::Mounter::Utils::YAMLFrontMattersTemplate.new(filepath)
+
+            if template.attributes
+              attributes = template.attributes.clone
+
+              # set the editable elements
+              page.set_editable_elements(attributes.delete('editable_elements'))
+
+              # set the content type
+              if content_type_slug = attributes.delete('content_type')
+                attributes['templatized']   = true
+                attributes['content_type']  = self.mounting_point.content_types.values.find { |ct| ct.slug == content_type_slug }
+              end
+
+              page.attributes = attributes
+            end
+
+            page.template = template
+          end
+
+          # Return the directory where all the templates of
+          # pages are stored in the filesystem.
+          #
+          # @return [ String ] The root directory
+          #
+          def root_dir
+            File.join(self.runner.path, 'app', 'views', 'pages')
+          end
+
+          # Take the path to a file on the filesystem
+          # and return its matching value for a Page.
+          #
+          # @param [ String ] filepath The path to the file
+          #
+          # @return [ String ] The fullpath of the page
+          #
+          def filepath_to_fullpath(filepath)
+            fullpath = filepath.gsub(File.join(self.root_dir, '/'), '')
+
+            fullpath.gsub!(/^\.\//, '')
+
+            fullpath.split('.').first.dasherize
+          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
+
+          # Output simply the tree structure of the pages.
+          #
+          # Note: only for debug purpose
+          #
+          def to_s(page = nil)
+            page ||= self.pages['index']
+
+            puts "#{"  " * (page.try(:depth) + 1)} #{page.fullpath.inspect} (#{page.title}, position=#{page.position}, template=#{page.template_translations.keys.inspect})"
+
+            (page.children || []).each { |child| self.to_s(child) }
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Locomotive
+  module Mounter
+    module Reader
+     module FileSystem
+
+       class SiteReader < Base
+
+         def read
+           config_path = File.join(self.runner.path, 'config', 'site.yml')
+
+           site = self.read_yaml(config_path)
+
+           # set the default locale first
+           Locomotive::Mounter.locale = site['locales'].first.to_sym rescue Locomotive::Mounter.locale
+
+           Locomotive::Mounter::Models::Site.new(site).tap do |_site|
+            # set the time zone for the next Time operations (UTC by default)
+            Time.zone = ActiveSupport::TimeZone.new(_site.timezone || 'UTC')
+           end
+         end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,115 @@
+module Locomotive
+  module Mounter
+    module Reader
+      module FileSystem
+
+        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_from_filesystem
+
+            self.set_default_template_for_each_locale
+
+            self.items
+          end
+
+          protected
+
+          # Record snippets found in file system
+          def fetch_from_filesystem
+            Dir.glob(File.join(self.root_dir, "*.{#{Locomotive::Mounter::TEMPLATE_EXTENSIONS.join(',')}}")).each do |filepath|
+              fullpath = File.basename(filepath)
+
+              snippet = self.add(filepath)
+
+              Locomotive::Mounter.with_locale(self.filepath_locale(filepath)) do
+                snippet.template = self.fetch_template(filepath)
+              end
+            end
+          end
+
+          # Set a default template (coming from the default locale)
+          # for each snippet which does not have a translated version
+          # of the template in each locale.
+          #
+          def set_default_template_for_each_locale
+            self.items.values.each do |snippet|
+              default_template = snippet.template
+
+              next if default_template.blank?
+
+              self.locales.map(&:to_sym).each do |locale|
+                next if locale == self.default_locale
+
+                _template = snippet.template_translations[locale]
+
+                if !_template.is_a?(Exception) && _template.blank?
+                  snippet.template_translations[locale] = default_template
+                end
+              end
+            end
+          end
+
+          # Return the directory where all the templates of
+          # snippets are stored in the filesystem.
+          #
+          # @return [ String ] The snippets directory
+          #
+          def root_dir
+            File.join(self.runner.path, 'app', 'views', 'snippets')
+          end
+
+          # Add a new snippet in the global hash of snippets.
+          # If the snippet exists, it returns it.
+          #
+          # @param [ String ] filepath The path to the file
+          #
+          # @return [ Object ] A newly created snippet or the existing one
+          #
+          def add(filepath)
+            slug = self.filepath_to_slug(filepath)
+
+            unless self.items.key?(slug)
+              self.items[slug] = Locomotive::Mounter::Models::Snippet.new({
+                name:     slug.humanize,
+                slug:     slug,
+                template: self.fetch_template(filepath)
+              })
+            end
+
+            self.items[slug]
+          end
+
+          # Convert a filepath to a slug
+          #
+          # @param [ String ] filepath The path to the file
+          #
+          # @return [ String ] The slug
+          #
+          def filepath_to_slug(filepath)
+            File.basename(filepath).split('.').first.permalink
+          end
+
+          # From a filepath, parse the template inside.
+          # and return the related Tilt instance.
+          # It may return the exception if the template is invalid
+          # (only for HAML templates).
+          #
+          # @param [ String ] filepath The path to the file
+          #
+          # @return [ Object ] The Tilt template or the exception itself if the template is invalid
+          #
+          def fetch_template(filepath)
+            Locomotive::Mounter::Utils::YAMLFrontMattersTemplate.new(filepath)
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+module Locomotive
+  module Mounter
+    module Reader
+      module FileSystem
+
+        class ThemeAssetsReader < Base
+
+          # Build the list of theme assets from the public folder with eager loading.
+          #
+          # @return [ Array ] The cached list of theme assets
+          #
+          def read
+            ThemeAssetsArray.new(self.root_dir)
+          end
+
+          protected
+
+          # Return the directory where all the theme assets
+          # are stored in the filesystem.
+          #
+          # @return [ String ] The theme assets directory
+          #
+          def root_dir
+            File.join(self.runner.path, 'public')
+          end
+
+        end
+
+      end
+
+      class ThemeAssetsArray
+
+        attr_accessor :root_dir
+
+        def initialize(root_dir)
+          self.root_dir = root_dir
+        end
+
+        def list
+          return @list unless @list.nil?
+
+          # Follows symlinks and makes sure subdirectories are handled
+          glob_pattern = '**/*/**/*'
+
+          @list = [].tap do |list|
+            Dir.glob(File.join(self.root_dir, glob_pattern)).each do |file|
+              next if self.exclude?(file)
+
+              folder = File.dirname(file.gsub("#{self.root_dir}/", ''))
+
+              asset = Locomotive::Mounter::Models::ThemeAsset.new(folder: folder, filepath: file)
+
+              list << asset
+            end
+          end
+        end
+
+        alias :values :list
+
+        # Tell if the file has to be excluded from the array
+        # of theme assets. It does not have to be a folder
+        # or be in the samples folder or owns a name starting with
+        # the underscore character.
+        #
+        # @param [ String ] file The full path to the file
+        #
+        # @return [ Boolean ] True if it does not have to be included in the list.
+        #
+        def exclude?(file)
+          File.directory?(file) ||
+          file.starts_with?(File.join(self.root_dir, 'samples')) ||
+          File.basename(file).starts_with?('_')
+        end
+
+        # This class acts a proxy of an array
+        def method_missing(name, *args, &block)
+          self.list.send(name.to_sym, *args, &block)
+        end
+
+      end
+    end
+  end
+end